1 //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains support for constructing a dwarf compile unit. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "DwarfCompileUnit.h" 14 #include "AddressPool.h" 15 #include "DwarfExpression.h" 16 #include "llvm/ADT/None.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/ADT/SmallString.h" 19 #include "llvm/BinaryFormat/Dwarf.h" 20 #include "llvm/CodeGen/AsmPrinter.h" 21 #include "llvm/CodeGen/DIE.h" 22 #include "llvm/CodeGen/MachineFunction.h" 23 #include "llvm/CodeGen/MachineInstr.h" 24 #include "llvm/CodeGen/MachineOperand.h" 25 #include "llvm/CodeGen/TargetFrameLowering.h" 26 #include "llvm/CodeGen/TargetRegisterInfo.h" 27 #include "llvm/CodeGen/TargetSubtargetInfo.h" 28 #include "llvm/IR/DataLayout.h" 29 #include "llvm/IR/DebugInfo.h" 30 #include "llvm/IR/GlobalVariable.h" 31 #include "llvm/MC/MCSection.h" 32 #include "llvm/MC/MCStreamer.h" 33 #include "llvm/MC/MCSymbol.h" 34 #include "llvm/MC/MCSymbolWasm.h" 35 #include "llvm/MC/MachineLocation.h" 36 #include "llvm/Target/TargetLoweringObjectFile.h" 37 #include "llvm/Target/TargetMachine.h" 38 #include "llvm/Target/TargetOptions.h" 39 #include <iterator> 40 #include <string> 41 #include <utility> 42 43 using namespace llvm; 44 45 static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) { 46 47 // According to DWARF Debugging Information Format Version 5, 48 // 3.1.2 Skeleton Compilation Unit Entries: 49 // "When generating a split DWARF object file (see Section 7.3.2 50 // on page 187), the compilation unit in the .debug_info section 51 // is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit" 52 if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton) 53 return dwarf::DW_TAG_skeleton_unit; 54 55 return dwarf::DW_TAG_compile_unit; 56 } 57 58 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, 59 AsmPrinter *A, DwarfDebug *DW, 60 DwarfFile *DWU, UnitKind Kind) 61 : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU), UniqueID(UID) { 62 insertDIE(Node, &getUnitDie()); 63 MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin"); 64 } 65 66 /// addLabelAddress - Add a dwarf label attribute data and value using 67 /// DW_FORM_addr or DW_FORM_GNU_addr_index. 68 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute, 69 const MCSymbol *Label) { 70 // Don't use the address pool in non-fission or in the skeleton unit itself. 71 if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5) 72 return addLocalLabelAddress(Die, Attribute, Label); 73 74 if (Label) 75 DD->addArangeLabel(SymbolCU(this, Label)); 76 77 bool UseAddrOffsetFormOrExpressions = 78 DD->useAddrOffsetForm() || DD->useAddrOffsetExpressions(); 79 80 const MCSymbol *Base = nullptr; 81 if (Label->isInSection() && UseAddrOffsetFormOrExpressions) 82 Base = DD->getSectionLabel(&Label->getSection()); 83 84 if (!Base || Base == Label) { 85 unsigned idx = DD->getAddressPool().getIndex(Label); 86 addAttribute(Die, Attribute, 87 DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx 88 : dwarf::DW_FORM_GNU_addr_index, 89 DIEInteger(idx)); 90 return; 91 } 92 93 // Could be extended to work with DWARFv4 Split DWARF if that's important for 94 // someone. In that case DW_FORM_data would be used. 95 assert(DD->getDwarfVersion() >= 5 && 96 "Addr+offset expressions are only valuable when using debug_addr (to " 97 "reduce relocations) available in DWARFv5 or higher"); 98 if (DD->useAddrOffsetExpressions()) { 99 auto *Loc = new (DIEValueAllocator) DIEBlock(); 100 addPoolOpAddress(*Loc, Label); 101 addBlock(Die, Attribute, dwarf::DW_FORM_exprloc, Loc); 102 } else 103 addAttribute(Die, Attribute, dwarf::DW_FORM_LLVM_addrx_offset, 104 new (DIEValueAllocator) DIEAddrOffset( 105 DD->getAddressPool().getIndex(Base), Label, Base)); 106 } 107 108 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, 109 dwarf::Attribute Attribute, 110 const MCSymbol *Label) { 111 if (Label) 112 DD->addArangeLabel(SymbolCU(this, Label)); 113 114 if (Label) 115 addAttribute(Die, Attribute, dwarf::DW_FORM_addr, DIELabel(Label)); 116 else 117 addAttribute(Die, Attribute, dwarf::DW_FORM_addr, DIEInteger(0)); 118 } 119 120 unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) { 121 // If we print assembly, we can't separate .file entries according to 122 // compile units. Thus all files will belong to the default compile unit. 123 124 // FIXME: add a better feature test than hasRawTextSupport. Even better, 125 // extend .file to support this. 126 unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID(); 127 if (!File) 128 return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None, 129 CUID); 130 return Asm->OutStreamer->emitDwarfFileDirective( 131 0, File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File), 132 File->getSource(), CUID); 133 } 134 135 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE( 136 const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) { 137 // Check for pre-existence. 138 if (DIE *Die = getDIE(GV)) 139 return Die; 140 141 assert(GV); 142 143 auto *GVContext = GV->getScope(); 144 const DIType *GTy = GV->getType(); 145 146 // Construct the context before querying for the existence of the DIE in 147 // case such construction creates the DIE. 148 auto *CB = GVContext ? dyn_cast<DICommonBlock>(GVContext) : nullptr; 149 DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs) 150 : getOrCreateContextDIE(GVContext); 151 152 // Add to map. 153 DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV); 154 DIScope *DeclContext; 155 if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) { 156 DeclContext = SDMDecl->getScope(); 157 assert(SDMDecl->isStaticMember() && "Expected static member decl"); 158 assert(GV->isDefinition()); 159 // We need the declaration DIE that is in the static member's class. 160 DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl); 161 addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE); 162 // If the global variable's type is different from the one in the class 163 // member type, assume that it's more specific and also emit it. 164 if (GTy != SDMDecl->getBaseType()) 165 addType(*VariableDIE, GTy); 166 } else { 167 DeclContext = GV->getScope(); 168 // Add name and type. 169 addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName()); 170 if (GTy) 171 addType(*VariableDIE, GTy); 172 173 // Add scoping info. 174 if (!GV->isLocalToUnit()) 175 addFlag(*VariableDIE, dwarf::DW_AT_external); 176 177 // Add line number info. 178 addSourceLine(*VariableDIE, GV); 179 } 180 181 if (!GV->isDefinition()) 182 addFlag(*VariableDIE, dwarf::DW_AT_declaration); 183 else 184 addGlobalName(GV->getName(), *VariableDIE, DeclContext); 185 186 if (uint32_t AlignInBytes = GV->getAlignInBytes()) 187 addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, 188 AlignInBytes); 189 190 if (MDTuple *TP = GV->getTemplateParams()) 191 addTemplateParams(*VariableDIE, DINodeArray(TP)); 192 193 // Add location. 194 addLocationAttribute(VariableDIE, GV, GlobalExprs); 195 196 return VariableDIE; 197 } 198 199 void DwarfCompileUnit::addLocationAttribute( 200 DIE *VariableDIE, const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) { 201 bool addToAccelTable = false; 202 DIELoc *Loc = nullptr; 203 Optional<unsigned> NVPTXAddressSpace; 204 std::unique_ptr<DIEDwarfExpression> DwarfExpr; 205 for (const auto &GE : GlobalExprs) { 206 const GlobalVariable *Global = GE.Var; 207 const DIExpression *Expr = GE.Expr; 208 209 // For compatibility with DWARF 3 and earlier, 210 // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) or 211 // DW_AT_location(DW_OP_consts, X, DW_OP_stack_value) becomes 212 // DW_AT_const_value(X). 213 if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) { 214 addToAccelTable = true; 215 addConstantValue( 216 *VariableDIE, 217 DIExpression::SignedOrUnsignedConstant::UnsignedConstant == 218 *Expr->isConstant(), 219 Expr->getElement(1)); 220 break; 221 } 222 223 // We cannot describe the location of dllimport'd variables: the 224 // computation of their address requires loads from the IAT. 225 if (Global && Global->hasDLLImportStorageClass()) 226 continue; 227 228 // Nothing to describe without address or constant. 229 if (!Global && (!Expr || !Expr->isConstant())) 230 continue; 231 232 if (Global && Global->isThreadLocal() && 233 !Asm->getObjFileLowering().supportDebugThreadLocalLocation()) 234 continue; 235 236 if (!Loc) { 237 addToAccelTable = true; 238 Loc = new (DIEValueAllocator) DIELoc; 239 DwarfExpr = std::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc); 240 } 241 242 if (Expr) { 243 // According to 244 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf 245 // cuda-gdb requires DW_AT_address_class for all variables to be able to 246 // correctly interpret address space of the variable address. 247 // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef 248 // sequence for the NVPTX + gdb target. 249 unsigned LocalNVPTXAddressSpace; 250 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { 251 const DIExpression *NewExpr = 252 DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace); 253 if (NewExpr != Expr) { 254 Expr = NewExpr; 255 NVPTXAddressSpace = LocalNVPTXAddressSpace; 256 } 257 } 258 DwarfExpr->addFragmentOffset(Expr); 259 } 260 261 if (Global) { 262 const MCSymbol *Sym = Asm->getSymbol(Global); 263 if (Global->isThreadLocal()) { 264 if (Asm->TM.useEmulatedTLS()) { 265 // TODO: add debug info for emulated thread local mode. 266 } else { 267 // FIXME: Make this work with -gsplit-dwarf. 268 unsigned PointerSize = Asm->getDataLayout().getPointerSize(); 269 assert((PointerSize == 4 || PointerSize == 8) && 270 "Add support for other sizes if necessary"); 271 // Based on GCC's support for TLS: 272 if (!DD->useSplitDwarf()) { 273 // 1) Start with a constNu of the appropriate pointer size 274 addUInt(*Loc, dwarf::DW_FORM_data1, 275 PointerSize == 4 ? dwarf::DW_OP_const4u 276 : dwarf::DW_OP_const8u); 277 // 2) containing the (relocated) offset of the TLS variable 278 // within the module's TLS block. 279 addExpr(*Loc, 280 PointerSize == 4 ? dwarf::DW_FORM_data4 281 : dwarf::DW_FORM_data8, 282 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); 283 } else { 284 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); 285 addUInt(*Loc, dwarf::DW_FORM_udata, 286 DD->getAddressPool().getIndex(Sym, /* TLS */ true)); 287 } 288 // 3) followed by an OP to make the debugger do a TLS lookup. 289 addUInt(*Loc, dwarf::DW_FORM_data1, 290 DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address 291 : dwarf::DW_OP_form_tls_address); 292 } 293 } else { 294 DD->addArangeLabel(SymbolCU(this, Sym)); 295 addOpAddress(*Loc, Sym); 296 } 297 } 298 // Global variables attached to symbols are memory locations. 299 // It would be better if this were unconditional, but malformed input that 300 // mixes non-fragments and fragments for the same variable is too expensive 301 // to detect in the verifier. 302 if (DwarfExpr->isUnknownLocation()) 303 DwarfExpr->setMemoryLocationKind(); 304 DwarfExpr->addExpression(Expr); 305 } 306 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { 307 // According to 308 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf 309 // cuda-gdb requires DW_AT_address_class for all variables to be able to 310 // correctly interpret address space of the variable address. 311 const unsigned NVPTX_ADDR_global_space = 5; 312 addUInt(*VariableDIE, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1, 313 NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_global_space); 314 } 315 if (Loc) 316 addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize()); 317 318 if (DD->useAllLinkageNames()) 319 addLinkageName(*VariableDIE, GV->getLinkageName()); 320 321 if (addToAccelTable) { 322 DD->addAccelName(*CUNode, GV->getName(), *VariableDIE); 323 324 // If the linkage name is different than the name, go ahead and output 325 // that as well into the name table. 326 if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() && 327 DD->useAllLinkageNames()) 328 DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE); 329 } 330 } 331 332 DIE *DwarfCompileUnit::getOrCreateCommonBlock( 333 const DICommonBlock *CB, ArrayRef<GlobalExpr> GlobalExprs) { 334 // Construct the context before querying for the existence of the DIE in case 335 // such construction creates the DIE. 336 DIE *ContextDIE = getOrCreateContextDIE(CB->getScope()); 337 338 if (DIE *NDie = getDIE(CB)) 339 return NDie; 340 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_common_block, *ContextDIE, CB); 341 StringRef Name = CB->getName().empty() ? "_BLNK_" : CB->getName(); 342 addString(NDie, dwarf::DW_AT_name, Name); 343 addGlobalName(Name, NDie, CB->getScope()); 344 if (CB->getFile()) 345 addSourceLine(NDie, CB->getLineNo(), CB->getFile()); 346 if (DIGlobalVariable *V = CB->getDecl()) 347 getCU().addLocationAttribute(&NDie, V, GlobalExprs); 348 return &NDie; 349 } 350 351 void DwarfCompileUnit::addRange(RangeSpan Range) { 352 DD->insertSectionLabel(Range.Begin); 353 354 bool SameAsPrevCU = this == DD->getPrevCU(); 355 DD->setPrevCU(this); 356 // If we have no current ranges just add the range and return, otherwise, 357 // check the current section and CU against the previous section and CU we 358 // emitted into and the subprogram was contained within. If these are the 359 // same then extend our current range, otherwise add this as a new range. 360 if (CURanges.empty() || !SameAsPrevCU || 361 (&CURanges.back().End->getSection() != 362 &Range.End->getSection())) { 363 CURanges.push_back(Range); 364 return; 365 } 366 367 CURanges.back().End = Range.End; 368 } 369 370 void DwarfCompileUnit::initStmtList() { 371 if (CUNode->isDebugDirectivesOnly()) 372 return; 373 374 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 375 if (DD->useSectionsAsReferences()) { 376 LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol(); 377 } else { 378 LineTableStartSym = 379 Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID()); 380 } 381 382 // DW_AT_stmt_list is a offset of line number information for this 383 // compile unit in debug_line section. For split dwarf this is 384 // left in the skeleton CU and so not included. 385 // The line table entries are not always emitted in assembly, so it 386 // is not okay to use line_table_start here. 387 addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym, 388 TLOF.getDwarfLineSection()->getBeginSymbol()); 389 } 390 391 void DwarfCompileUnit::applyStmtList(DIE &D) { 392 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 393 addSectionLabel(D, dwarf::DW_AT_stmt_list, LineTableStartSym, 394 TLOF.getDwarfLineSection()->getBeginSymbol()); 395 } 396 397 void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin, 398 const MCSymbol *End) { 399 assert(Begin && "Begin label should not be null!"); 400 assert(End && "End label should not be null!"); 401 assert(Begin->isDefined() && "Invalid starting label"); 402 assert(End->isDefined() && "Invalid end label"); 403 404 addLabelAddress(D, dwarf::DW_AT_low_pc, Begin); 405 if (DD->getDwarfVersion() < 4) 406 addLabelAddress(D, dwarf::DW_AT_high_pc, End); 407 else 408 addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin); 409 } 410 411 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc 412 // and DW_AT_high_pc attributes. If there are global variables in this 413 // scope then create and insert DIEs for these variables. 414 DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) { 415 DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes()); 416 417 SmallVector<RangeSpan, 2> BB_List; 418 // If basic block sections are on, ranges for each basic block section has 419 // to be emitted separately. 420 for (const auto &R : Asm->MBBSectionRanges) 421 BB_List.push_back({R.second.BeginLabel, R.second.EndLabel}); 422 423 attachRangesOrLowHighPC(*SPDie, BB_List); 424 425 if (DD->useAppleExtensionAttributes() && 426 !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim( 427 *DD->getCurrentFunction())) 428 addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr); 429 430 // Only include DW_AT_frame_base in full debug info 431 if (!includeMinimalInlineScopes()) { 432 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); 433 TargetFrameLowering::DwarfFrameBase FrameBase = 434 TFI->getDwarfFrameBase(*Asm->MF); 435 switch (FrameBase.Kind) { 436 case TargetFrameLowering::DwarfFrameBase::Register: { 437 if (Register::isPhysicalRegister(FrameBase.Location.Reg)) { 438 MachineLocation Location(FrameBase.Location.Reg); 439 addAddress(*SPDie, dwarf::DW_AT_frame_base, Location); 440 } 441 break; 442 } 443 case TargetFrameLowering::DwarfFrameBase::CFA: { 444 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 445 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa); 446 addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); 447 break; 448 } 449 case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: { 450 // FIXME: duplicated from Target/WebAssembly/WebAssembly.h 451 // don't want to depend on target specific headers in this code? 452 const unsigned TI_GLOBAL_RELOC = 3; 453 if (FrameBase.Location.WasmLoc.Kind == TI_GLOBAL_RELOC) { 454 // These need to be relocatable. 455 assert(FrameBase.Location.WasmLoc.Index == 0); // Only SP so far. 456 auto SPSym = cast<MCSymbolWasm>( 457 Asm->GetExternalSymbolSymbol("__stack_pointer")); 458 // FIXME: this repeats what WebAssemblyMCInstLower:: 459 // GetExternalSymbolSymbol does, since if there's no code that 460 // refers to this symbol, we have to set it here. 461 SPSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL); 462 SPSym->setGlobalType(wasm::WasmGlobalType{ 463 uint8_t(Asm->getSubtargetInfo().getTargetTriple().getArch() == 464 Triple::wasm64 465 ? wasm::WASM_TYPE_I64 466 : wasm::WASM_TYPE_I32), 467 true}); 468 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 469 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_WASM_location); 470 addSInt(*Loc, dwarf::DW_FORM_sdata, TI_GLOBAL_RELOC); 471 if (!isDwoUnit()) { 472 addLabel(*Loc, dwarf::DW_FORM_data4, SPSym); 473 DD->addArangeLabel(SymbolCU(this, SPSym)); 474 } else { 475 // FIXME: when writing dwo, we need to avoid relocations. Probably 476 // the "right" solution is to treat globals the way func and data 477 // symbols are (with entries in .debug_addr). 478 // For now, since we only ever use index 0, this should work as-is. 479 addUInt(*Loc, dwarf::DW_FORM_data4, FrameBase.Location.WasmLoc.Index); 480 } 481 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); 482 addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc); 483 } else { 484 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 485 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 486 DIExpressionCursor Cursor({}); 487 DwarfExpr.addWasmLocation(FrameBase.Location.WasmLoc.Kind, 488 FrameBase.Location.WasmLoc.Index); 489 DwarfExpr.addExpression(std::move(Cursor)); 490 addBlock(*SPDie, dwarf::DW_AT_frame_base, DwarfExpr.finalize()); 491 } 492 break; 493 } 494 } 495 } 496 497 // Add name to the name table, we do this here because we're guaranteed 498 // to have concrete versions of our DW_TAG_subprogram nodes. 499 DD->addSubprogramNames(*CUNode, SP, *SPDie); 500 501 return *SPDie; 502 } 503 504 // Construct a DIE for this scope. 505 void DwarfCompileUnit::constructScopeDIE( 506 LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) { 507 if (!Scope || !Scope->getScopeNode()) 508 return; 509 510 auto *DS = Scope->getScopeNode(); 511 512 assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && 513 "Only handle inlined subprograms here, use " 514 "constructSubprogramScopeDIE for non-inlined " 515 "subprograms"); 516 517 SmallVector<DIE *, 8> Children; 518 519 // We try to create the scope DIE first, then the children DIEs. This will 520 // avoid creating un-used children then removing them later when we find out 521 // the scope DIE is null. 522 DIE *ScopeDIE; 523 if (Scope->getParent() && isa<DISubprogram>(DS)) { 524 ScopeDIE = constructInlinedScopeDIE(Scope); 525 if (!ScopeDIE) 526 return; 527 // We create children when the scope DIE is not null. 528 createScopeChildrenDIE(Scope, Children); 529 } else { 530 // Early exit when we know the scope DIE is going to be null. 531 if (DD->isLexicalScopeDIENull(Scope)) 532 return; 533 534 bool HasNonScopeChildren = false; 535 536 // We create children here when we know the scope DIE is not going to be 537 // null and the children will be added to the scope DIE. 538 createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren); 539 540 // If there are only other scopes as children, put them directly in the 541 // parent instead, as this scope would serve no purpose. 542 if (!HasNonScopeChildren) { 543 FinalChildren.insert(FinalChildren.end(), 544 std::make_move_iterator(Children.begin()), 545 std::make_move_iterator(Children.end())); 546 return; 547 } 548 ScopeDIE = constructLexicalScopeDIE(Scope); 549 assert(ScopeDIE && "Scope DIE should not be null."); 550 } 551 552 // Add children 553 for (auto &I : Children) 554 ScopeDIE->addChild(std::move(I)); 555 556 FinalChildren.push_back(std::move(ScopeDIE)); 557 } 558 559 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE, 560 SmallVector<RangeSpan, 2> Range) { 561 562 HasRangeLists = true; 563 564 // Add the range list to the set of ranges to be emitted. 565 auto IndexAndList = 566 (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU) 567 ->addRange(*(Skeleton ? Skeleton : this), std::move(Range)); 568 569 uint32_t Index = IndexAndList.first; 570 auto &List = *IndexAndList.second; 571 572 // Under fission, ranges are specified by constant offsets relative to the 573 // CU's DW_AT_GNU_ranges_base. 574 // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under 575 // fission until we support the forms using the .debug_addr section 576 // (DW_RLE_startx_endx etc.). 577 if (DD->getDwarfVersion() >= 5) 578 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index); 579 else { 580 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 581 const MCSymbol *RangeSectionSym = 582 TLOF.getDwarfRangesSection()->getBeginSymbol(); 583 if (isDwoUnit()) 584 addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.Label, 585 RangeSectionSym); 586 else 587 addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.Label, 588 RangeSectionSym); 589 } 590 } 591 592 void DwarfCompileUnit::attachRangesOrLowHighPC( 593 DIE &Die, SmallVector<RangeSpan, 2> Ranges) { 594 assert(!Ranges.empty()); 595 if (!DD->useRangesSection() || 596 (Ranges.size() == 1 && 597 (!DD->alwaysUseRanges() || 598 DD->getSectionLabel(&Ranges.front().Begin->getSection()) == 599 Ranges.front().Begin))) { 600 const RangeSpan &Front = Ranges.front(); 601 const RangeSpan &Back = Ranges.back(); 602 attachLowHighPC(Die, Front.Begin, Back.End); 603 } else 604 addScopeRangeList(Die, std::move(Ranges)); 605 } 606 607 void DwarfCompileUnit::attachRangesOrLowHighPC( 608 DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) { 609 SmallVector<RangeSpan, 2> List; 610 List.reserve(Ranges.size()); 611 for (const InsnRange &R : Ranges) { 612 auto *BeginLabel = DD->getLabelBeforeInsn(R.first); 613 auto *EndLabel = DD->getLabelAfterInsn(R.second); 614 615 const auto *BeginMBB = R.first->getParent(); 616 const auto *EndMBB = R.second->getParent(); 617 618 const auto *MBB = BeginMBB; 619 // Basic block sections allows basic block subsets to be placed in unique 620 // sections. For each section, the begin and end label must be added to the 621 // list. If there is more than one range, debug ranges must be used. 622 // Otherwise, low/high PC can be used. 623 // FIXME: Debug Info Emission depends on block order and this assumes that 624 // the order of blocks will be frozen beyond this point. 625 do { 626 if (MBB->sameSection(EndMBB) || MBB->isEndSection()) { 627 auto MBBSectionRange = Asm->MBBSectionRanges[MBB->getSectionIDNum()]; 628 List.push_back( 629 {MBB->sameSection(BeginMBB) ? BeginLabel 630 : MBBSectionRange.BeginLabel, 631 MBB->sameSection(EndMBB) ? EndLabel : MBBSectionRange.EndLabel}); 632 } 633 if (MBB->sameSection(EndMBB)) 634 break; 635 MBB = MBB->getNextNode(); 636 } while (true); 637 } 638 attachRangesOrLowHighPC(Die, std::move(List)); 639 } 640 641 // This scope represents inlined body of a function. Construct DIE to 642 // represent this concrete inlined copy of the function. 643 DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) { 644 assert(Scope->getScopeNode()); 645 auto *DS = Scope->getScopeNode(); 646 auto *InlinedSP = getDISubprogram(DS); 647 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram 648 // was inlined from another compile unit. 649 DIE *OriginDIE = getAbstractSPDies()[InlinedSP]; 650 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram."); 651 652 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine); 653 addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE); 654 655 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); 656 657 // Add the call site information to the DIE. 658 const DILocation *IA = Scope->getInlinedAt(); 659 addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None, 660 getOrCreateSourceID(IA->getFile())); 661 addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine()); 662 if (IA->getColumn()) 663 addUInt(*ScopeDIE, dwarf::DW_AT_call_column, None, IA->getColumn()); 664 if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4) 665 addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None, 666 IA->getDiscriminator()); 667 668 // Add name to the name table, we do this here because we're guaranteed 669 // to have concrete versions of our DW_TAG_inlined_subprogram nodes. 670 DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE); 671 672 return ScopeDIE; 673 } 674 675 // Construct new DW_TAG_lexical_block for this scope and attach 676 // DW_AT_low_pc/DW_AT_high_pc labels. 677 DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) { 678 if (DD->isLexicalScopeDIENull(Scope)) 679 return nullptr; 680 681 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block); 682 if (Scope->isAbstractScope()) 683 return ScopeDIE; 684 685 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges()); 686 687 return ScopeDIE; 688 } 689 690 /// constructVariableDIE - Construct a DIE for the given DbgVariable. 691 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) { 692 auto D = constructVariableDIEImpl(DV, Abstract); 693 DV.setDIE(*D); 694 return D; 695 } 696 697 DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL, 698 const LexicalScope &Scope) { 699 auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag()); 700 insertDIE(DL.getLabel(), LabelDie); 701 DL.setDIE(*LabelDie); 702 703 if (Scope.isAbstractScope()) 704 applyLabelAttributes(DL, *LabelDie); 705 706 return LabelDie; 707 } 708 709 DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV, 710 bool Abstract) { 711 // Define variable debug information entry. 712 auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag()); 713 insertDIE(DV.getVariable(), VariableDie); 714 715 if (Abstract) { 716 applyVariableAttributes(DV, *VariableDie); 717 return VariableDie; 718 } 719 720 // Add variable address. 721 722 unsigned Index = DV.getDebugLocListIndex(); 723 if (Index != ~0U) { 724 addLocationList(*VariableDie, dwarf::DW_AT_location, Index); 725 auto TagOffset = DV.getDebugLocListTagOffset(); 726 if (TagOffset) 727 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, 728 *TagOffset); 729 return VariableDie; 730 } 731 732 // Check if variable has a single location description. 733 if (auto *DVal = DV.getValueLoc()) { 734 if (!DVal->isVariadic()) { 735 const DbgValueLocEntry *Entry = DVal->getLocEntries().begin(); 736 if (Entry->isLocation()) { 737 addVariableAddress(DV, *VariableDie, Entry->getLoc()); 738 } else if (Entry->isInt()) { 739 auto *Expr = DV.getSingleExpression(); 740 if (Expr && Expr->getNumElements()) { 741 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 742 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 743 // If there is an expression, emit raw unsigned bytes. 744 DwarfExpr.addFragmentOffset(Expr); 745 DwarfExpr.addUnsignedConstant(Entry->getInt()); 746 DwarfExpr.addExpression(Expr); 747 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); 748 if (DwarfExpr.TagOffset) 749 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, 750 dwarf::DW_FORM_data1, *DwarfExpr.TagOffset); 751 } else 752 addConstantValue(*VariableDie, Entry->getInt(), DV.getType()); 753 } else if (Entry->isConstantFP()) { 754 addConstantFPValue(*VariableDie, Entry->getConstantFP()); 755 } else if (Entry->isConstantInt()) { 756 addConstantValue(*VariableDie, Entry->getConstantInt(), DV.getType()); 757 } else if (Entry->isTargetIndexLocation()) { 758 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 759 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 760 const DIBasicType *BT = dyn_cast<DIBasicType>( 761 static_cast<const Metadata *>(DV.getVariable()->getType())); 762 DwarfDebug::emitDebugLocValue(*Asm, BT, *DVal, DwarfExpr); 763 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); 764 } 765 return VariableDie; 766 } 767 // If any of the location entries are registers with the value 0, then the 768 // location is undefined. 769 if (any_of(DVal->getLocEntries(), [](const DbgValueLocEntry &Entry) { 770 return Entry.isLocation() && !Entry.getLoc().getReg(); 771 })) 772 return VariableDie; 773 const DIExpression *Expr = DV.getSingleExpression(); 774 assert(Expr && "Variadic Debug Value must have an Expression."); 775 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 776 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 777 DwarfExpr.addFragmentOffset(Expr); 778 DIExpressionCursor Cursor(Expr); 779 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); 780 781 auto AddEntry = [&](const DbgValueLocEntry &Entry, 782 DIExpressionCursor &Cursor) { 783 if (Entry.isLocation()) { 784 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, 785 Entry.getLoc().getReg())) 786 return false; 787 } else if (Entry.isInt()) { 788 // If there is an expression, emit raw unsigned bytes. 789 DwarfExpr.addUnsignedConstant(Entry.getInt()); 790 } else if (Entry.isConstantFP()) { 791 APInt RawBytes = Entry.getConstantFP()->getValueAPF().bitcastToAPInt(); 792 DwarfExpr.addUnsignedConstant(RawBytes); 793 } else if (Entry.isConstantInt()) { 794 APInt RawBytes = Entry.getConstantInt()->getValue(); 795 DwarfExpr.addUnsignedConstant(RawBytes); 796 } else if (Entry.isTargetIndexLocation()) { 797 TargetIndexLocation Loc = Entry.getTargetIndexLocation(); 798 // TODO TargetIndexLocation is a target-independent. Currently only the 799 // WebAssembly-specific encoding is supported. 800 assert(Asm->TM.getTargetTriple().isWasm()); 801 DwarfExpr.addWasmLocation(Loc.Index, static_cast<uint64_t>(Loc.Offset)); 802 } else { 803 llvm_unreachable("Unsupported Entry type."); 804 } 805 return true; 806 }; 807 808 DwarfExpr.addExpression( 809 std::move(Cursor), 810 [&](unsigned Idx, DIExpressionCursor &Cursor) -> bool { 811 return AddEntry(DVal->getLocEntries()[Idx], Cursor); 812 }); 813 814 // Now attach the location information to the DIE. 815 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); 816 if (DwarfExpr.TagOffset) 817 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, 818 *DwarfExpr.TagOffset); 819 820 return VariableDie; 821 } 822 823 // .. else use frame index. 824 if (!DV.hasFrameIndexExprs()) 825 return VariableDie; 826 827 Optional<unsigned> NVPTXAddressSpace; 828 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 829 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 830 for (auto &Fragment : DV.getFrameIndexExprs()) { 831 Register FrameReg; 832 const DIExpression *Expr = Fragment.Expr; 833 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); 834 StackOffset Offset = 835 TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg); 836 DwarfExpr.addFragmentOffset(Expr); 837 838 auto *TRI = Asm->MF->getSubtarget().getRegisterInfo(); 839 SmallVector<uint64_t, 8> Ops; 840 TRI->getOffsetOpcodes(Offset, Ops); 841 842 // According to 843 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf 844 // cuda-gdb requires DW_AT_address_class for all variables to be able to 845 // correctly interpret address space of the variable address. 846 // Decode DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef 847 // sequence for the NVPTX + gdb target. 848 unsigned LocalNVPTXAddressSpace; 849 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { 850 const DIExpression *NewExpr = 851 DIExpression::extractAddressClass(Expr, LocalNVPTXAddressSpace); 852 if (NewExpr != Expr) { 853 Expr = NewExpr; 854 NVPTXAddressSpace = LocalNVPTXAddressSpace; 855 } 856 } 857 if (Expr) 858 Ops.append(Expr->elements_begin(), Expr->elements_end()); 859 DIExpressionCursor Cursor(Ops); 860 DwarfExpr.setMemoryLocationKind(); 861 if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol()) 862 addOpAddress(*Loc, FrameSymbol); 863 else 864 DwarfExpr.addMachineRegExpression( 865 *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg); 866 DwarfExpr.addExpression(std::move(Cursor)); 867 } 868 if (Asm->TM.getTargetTriple().isNVPTX() && DD->tuneForGDB()) { 869 // According to 870 // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf 871 // cuda-gdb requires DW_AT_address_class for all variables to be able to 872 // correctly interpret address space of the variable address. 873 const unsigned NVPTX_ADDR_local_space = 6; 874 addUInt(*VariableDie, dwarf::DW_AT_address_class, dwarf::DW_FORM_data1, 875 NVPTXAddressSpace ? *NVPTXAddressSpace : NVPTX_ADDR_local_space); 876 } 877 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); 878 if (DwarfExpr.TagOffset) 879 addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, 880 *DwarfExpr.TagOffset); 881 882 return VariableDie; 883 } 884 885 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, 886 const LexicalScope &Scope, 887 DIE *&ObjectPointer) { 888 auto Var = constructVariableDIE(DV, Scope.isAbstractScope()); 889 if (DV.isObjectPointer()) 890 ObjectPointer = Var; 891 return Var; 892 } 893 894 /// Return all DIVariables that appear in count: expressions. 895 static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) { 896 SmallVector<const DIVariable *, 2> Result; 897 auto *Array = dyn_cast<DICompositeType>(Var->getType()); 898 if (!Array || Array->getTag() != dwarf::DW_TAG_array_type) 899 return Result; 900 if (auto *DLVar = Array->getDataLocation()) 901 Result.push_back(DLVar); 902 if (auto *AsVar = Array->getAssociated()) 903 Result.push_back(AsVar); 904 if (auto *AlVar = Array->getAllocated()) 905 Result.push_back(AlVar); 906 for (auto *El : Array->getElements()) { 907 if (auto *Subrange = dyn_cast<DISubrange>(El)) { 908 if (auto Count = Subrange->getCount()) 909 if (auto *Dependency = Count.dyn_cast<DIVariable *>()) 910 Result.push_back(Dependency); 911 if (auto LB = Subrange->getLowerBound()) 912 if (auto *Dependency = LB.dyn_cast<DIVariable *>()) 913 Result.push_back(Dependency); 914 if (auto UB = Subrange->getUpperBound()) 915 if (auto *Dependency = UB.dyn_cast<DIVariable *>()) 916 Result.push_back(Dependency); 917 if (auto ST = Subrange->getStride()) 918 if (auto *Dependency = ST.dyn_cast<DIVariable *>()) 919 Result.push_back(Dependency); 920 } else if (auto *GenericSubrange = dyn_cast<DIGenericSubrange>(El)) { 921 if (auto Count = GenericSubrange->getCount()) 922 if (auto *Dependency = Count.dyn_cast<DIVariable *>()) 923 Result.push_back(Dependency); 924 if (auto LB = GenericSubrange->getLowerBound()) 925 if (auto *Dependency = LB.dyn_cast<DIVariable *>()) 926 Result.push_back(Dependency); 927 if (auto UB = GenericSubrange->getUpperBound()) 928 if (auto *Dependency = UB.dyn_cast<DIVariable *>()) 929 Result.push_back(Dependency); 930 if (auto ST = GenericSubrange->getStride()) 931 if (auto *Dependency = ST.dyn_cast<DIVariable *>()) 932 Result.push_back(Dependency); 933 } 934 } 935 return Result; 936 } 937 938 /// Sort local variables so that variables appearing inside of helper 939 /// expressions come first. 940 static SmallVector<DbgVariable *, 8> 941 sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) { 942 SmallVector<DbgVariable *, 8> Result; 943 SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList; 944 // Map back from a DIVariable to its containing DbgVariable. 945 SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar; 946 // Set of DbgVariables in Result. 947 SmallDenseSet<DbgVariable *, 8> Visited; 948 // For cycle detection. 949 SmallDenseSet<DbgVariable *, 8> Visiting; 950 951 // Initialize the worklist and the DIVariable lookup table. 952 for (auto Var : reverse(Input)) { 953 DbgVar.insert({Var->getVariable(), Var}); 954 WorkList.push_back({Var, 0}); 955 } 956 957 // Perform a stable topological sort by doing a DFS. 958 while (!WorkList.empty()) { 959 auto Item = WorkList.back(); 960 DbgVariable *Var = Item.getPointer(); 961 bool visitedAllDependencies = Item.getInt(); 962 WorkList.pop_back(); 963 964 // Dependency is in a different lexical scope or a global. 965 if (!Var) 966 continue; 967 968 // Already handled. 969 if (Visited.count(Var)) 970 continue; 971 972 // Add to Result if all dependencies are visited. 973 if (visitedAllDependencies) { 974 Visited.insert(Var); 975 Result.push_back(Var); 976 continue; 977 } 978 979 // Detect cycles. 980 auto Res = Visiting.insert(Var); 981 if (!Res.second) { 982 assert(false && "dependency cycle in local variables"); 983 return Result; 984 } 985 986 // Push dependencies and this node onto the worklist, so that this node is 987 // visited again after all of its dependencies are handled. 988 WorkList.push_back({Var, 1}); 989 for (auto *Dependency : dependencies(Var)) { 990 auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency); 991 WorkList.push_back({DbgVar[Dep], 0}); 992 } 993 } 994 return Result; 995 } 996 997 DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope, 998 SmallVectorImpl<DIE *> &Children, 999 bool *HasNonScopeChildren) { 1000 assert(Children.empty()); 1001 DIE *ObjectPointer = nullptr; 1002 1003 // Emit function arguments (order is significant). 1004 auto Vars = DU->getScopeVariables().lookup(Scope); 1005 for (auto &DV : Vars.Args) 1006 Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer)); 1007 1008 // Emit local variables. 1009 auto Locals = sortLocalVars(Vars.Locals); 1010 for (DbgVariable *DV : Locals) 1011 Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer)); 1012 1013 // Skip imported directives in gmlt-like data. 1014 if (!includeMinimalInlineScopes()) { 1015 // There is no need to emit empty lexical block DIE. 1016 for (const auto *IE : ImportedEntities[Scope->getScopeNode()]) 1017 Children.push_back( 1018 constructImportedEntityDIE(cast<DIImportedEntity>(IE))); 1019 } 1020 1021 if (HasNonScopeChildren) 1022 *HasNonScopeChildren = !Children.empty(); 1023 1024 for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope)) 1025 Children.push_back(constructLabelDIE(*DL, *Scope)); 1026 1027 for (LexicalScope *LS : Scope->getChildren()) 1028 constructScopeDIE(LS, Children); 1029 1030 return ObjectPointer; 1031 } 1032 1033 DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, 1034 LexicalScope *Scope) { 1035 DIE &ScopeDIE = updateSubprogramScopeDIE(Sub); 1036 1037 if (Scope) { 1038 assert(!Scope->getInlinedAt()); 1039 assert(!Scope->isAbstractScope()); 1040 // Collect lexical scope children first. 1041 // ObjectPointer might be a local (non-argument) local variable if it's a 1042 // block's synthetic this pointer. 1043 if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE)) 1044 addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer); 1045 } 1046 1047 // If this is a variadic function, add an unspecified parameter. 1048 DITypeRefArray FnArgs = Sub->getType()->getTypeArray(); 1049 1050 // If we have a single element of null, it is a function that returns void. 1051 // If we have more than one elements and the last one is null, it is a 1052 // variadic function. 1053 if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] && 1054 !includeMinimalInlineScopes()) 1055 ScopeDIE.addChild( 1056 DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters)); 1057 1058 return ScopeDIE; 1059 } 1060 1061 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope, 1062 DIE &ScopeDIE) { 1063 // We create children when the scope DIE is not null. 1064 SmallVector<DIE *, 8> Children; 1065 DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children); 1066 1067 // Add children 1068 for (auto &I : Children) 1069 ScopeDIE.addChild(std::move(I)); 1070 1071 return ObjectPointer; 1072 } 1073 1074 void DwarfCompileUnit::constructAbstractSubprogramScopeDIE( 1075 LexicalScope *Scope) { 1076 DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()]; 1077 if (AbsDef) 1078 return; 1079 1080 auto *SP = cast<DISubprogram>(Scope->getScopeNode()); 1081 1082 DIE *ContextDIE; 1083 DwarfCompileUnit *ContextCU = this; 1084 1085 if (includeMinimalInlineScopes()) 1086 ContextDIE = &getUnitDie(); 1087 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with 1088 // the important distinction that the debug node is not associated with the 1089 // DIE (since the debug node will be associated with the concrete DIE, if 1090 // any). It could be refactored to some common utility function. 1091 else if (auto *SPDecl = SP->getDeclaration()) { 1092 ContextDIE = &getUnitDie(); 1093 getOrCreateSubprogramDIE(SPDecl); 1094 } else { 1095 ContextDIE = getOrCreateContextDIE(SP->getScope()); 1096 // The scope may be shared with a subprogram that has already been 1097 // constructed in another CU, in which case we need to construct this 1098 // subprogram in the same CU. 1099 ContextCU = DD->lookupCU(ContextDIE->getUnitDie()); 1100 } 1101 1102 // Passing null as the associated node because the abstract definition 1103 // shouldn't be found by lookup. 1104 AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr); 1105 ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef); 1106 1107 if (!ContextCU->includeMinimalInlineScopes()) 1108 ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined); 1109 if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef)) 1110 ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer); 1111 } 1112 1113 bool DwarfCompileUnit::useGNUAnalogForDwarf5Feature() const { 1114 return DD->getDwarfVersion() == 4 && !DD->tuneForLLDB(); 1115 } 1116 1117 dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const { 1118 if (!useGNUAnalogForDwarf5Feature()) 1119 return Tag; 1120 switch (Tag) { 1121 case dwarf::DW_TAG_call_site: 1122 return dwarf::DW_TAG_GNU_call_site; 1123 case dwarf::DW_TAG_call_site_parameter: 1124 return dwarf::DW_TAG_GNU_call_site_parameter; 1125 default: 1126 llvm_unreachable("DWARF5 tag with no GNU analog"); 1127 } 1128 } 1129 1130 dwarf::Attribute 1131 DwarfCompileUnit::getDwarf5OrGNUAttr(dwarf::Attribute Attr) const { 1132 if (!useGNUAnalogForDwarf5Feature()) 1133 return Attr; 1134 switch (Attr) { 1135 case dwarf::DW_AT_call_all_calls: 1136 return dwarf::DW_AT_GNU_all_call_sites; 1137 case dwarf::DW_AT_call_target: 1138 return dwarf::DW_AT_GNU_call_site_target; 1139 case dwarf::DW_AT_call_origin: 1140 return dwarf::DW_AT_abstract_origin; 1141 case dwarf::DW_AT_call_return_pc: 1142 return dwarf::DW_AT_low_pc; 1143 case dwarf::DW_AT_call_value: 1144 return dwarf::DW_AT_GNU_call_site_value; 1145 case dwarf::DW_AT_call_tail_call: 1146 return dwarf::DW_AT_GNU_tail_call; 1147 default: 1148 llvm_unreachable("DWARF5 attribute with no GNU analog"); 1149 } 1150 } 1151 1152 dwarf::LocationAtom 1153 DwarfCompileUnit::getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const { 1154 if (!useGNUAnalogForDwarf5Feature()) 1155 return Loc; 1156 switch (Loc) { 1157 case dwarf::DW_OP_entry_value: 1158 return dwarf::DW_OP_GNU_entry_value; 1159 default: 1160 llvm_unreachable("DWARF5 location atom with no GNU analog"); 1161 } 1162 } 1163 1164 DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE, 1165 DIE *CalleeDIE, 1166 bool IsTail, 1167 const MCSymbol *PCAddr, 1168 const MCSymbol *CallAddr, 1169 unsigned CallReg) { 1170 // Insert a call site entry DIE within ScopeDIE. 1171 DIE &CallSiteDIE = createAndAddDIE(getDwarf5OrGNUTag(dwarf::DW_TAG_call_site), 1172 ScopeDIE, nullptr); 1173 1174 if (CallReg) { 1175 // Indirect call. 1176 addAddress(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_target), 1177 MachineLocation(CallReg)); 1178 } else { 1179 assert(CalleeDIE && "No DIE for call site entry origin"); 1180 addDIEEntry(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_origin), 1181 *CalleeDIE); 1182 } 1183 1184 if (IsTail) { 1185 // Attach DW_AT_call_tail_call to tail calls for standards compliance. 1186 addFlag(CallSiteDIE, getDwarf5OrGNUAttr(dwarf::DW_AT_call_tail_call)); 1187 1188 // Attach the address of the branch instruction to allow the debugger to 1189 // show where the tail call occurred. This attribute has no GNU analog. 1190 // 1191 // GDB works backwards from non-standard usage of DW_AT_low_pc (in DWARF4 1192 // mode -- equivalently, in DWARF5 mode, DW_AT_call_return_pc) at tail-call 1193 // site entries to figure out the PC of tail-calling branch instructions. 1194 // This means it doesn't need the compiler to emit DW_AT_call_pc, so we 1195 // don't emit it here. 1196 // 1197 // There's no need to tie non-GDB debuggers to this non-standardness, as it 1198 // adds unnecessary complexity to the debugger. For non-GDB debuggers, emit 1199 // the standard DW_AT_call_pc info. 1200 if (!useGNUAnalogForDwarf5Feature()) 1201 addLabelAddress(CallSiteDIE, dwarf::DW_AT_call_pc, CallAddr); 1202 } 1203 1204 // Attach the return PC to allow the debugger to disambiguate call paths 1205 // from one function to another. 1206 // 1207 // The return PC is only really needed when the call /isn't/ a tail call, but 1208 // GDB expects it in DWARF4 mode, even for tail calls (see the comment above 1209 // the DW_AT_call_pc emission logic for an explanation). 1210 if (!IsTail || useGNUAnalogForDwarf5Feature()) { 1211 assert(PCAddr && "Missing return PC information for a call"); 1212 addLabelAddress(CallSiteDIE, 1213 getDwarf5OrGNUAttr(dwarf::DW_AT_call_return_pc), PCAddr); 1214 } 1215 1216 return CallSiteDIE; 1217 } 1218 1219 void DwarfCompileUnit::constructCallSiteParmEntryDIEs( 1220 DIE &CallSiteDIE, SmallVector<DbgCallSiteParam, 4> &Params) { 1221 for (const auto &Param : Params) { 1222 unsigned Register = Param.getRegister(); 1223 auto CallSiteDieParam = 1224 DIE::get(DIEValueAllocator, 1225 getDwarf5OrGNUTag(dwarf::DW_TAG_call_site_parameter)); 1226 insertDIE(CallSiteDieParam); 1227 addAddress(*CallSiteDieParam, dwarf::DW_AT_location, 1228 MachineLocation(Register)); 1229 1230 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 1231 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 1232 DwarfExpr.setCallSiteParamValueFlag(); 1233 1234 DwarfDebug::emitDebugLocValue(*Asm, nullptr, Param.getValue(), DwarfExpr); 1235 1236 addBlock(*CallSiteDieParam, getDwarf5OrGNUAttr(dwarf::DW_AT_call_value), 1237 DwarfExpr.finalize()); 1238 1239 CallSiteDIE.addChild(CallSiteDieParam); 1240 } 1241 } 1242 1243 DIE *DwarfCompileUnit::constructImportedEntityDIE( 1244 const DIImportedEntity *Module) { 1245 DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag()); 1246 insertDIE(Module, IMDie); 1247 DIE *EntityDie; 1248 auto *Entity = Module->getEntity(); 1249 if (auto *NS = dyn_cast<DINamespace>(Entity)) 1250 EntityDie = getOrCreateNameSpace(NS); 1251 else if (auto *M = dyn_cast<DIModule>(Entity)) 1252 EntityDie = getOrCreateModule(M); 1253 else if (auto *SP = dyn_cast<DISubprogram>(Entity)) 1254 EntityDie = getOrCreateSubprogramDIE(SP); 1255 else if (auto *T = dyn_cast<DIType>(Entity)) 1256 EntityDie = getOrCreateTypeDIE(T); 1257 else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity)) 1258 EntityDie = getOrCreateGlobalVariableDIE(GV, {}); 1259 else 1260 EntityDie = getDIE(Entity); 1261 assert(EntityDie); 1262 addSourceLine(*IMDie, Module->getLine(), Module->getFile()); 1263 addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie); 1264 StringRef Name = Module->getName(); 1265 if (!Name.empty()) 1266 addString(*IMDie, dwarf::DW_AT_name, Name); 1267 1268 return IMDie; 1269 } 1270 1271 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) { 1272 DIE *D = getDIE(SP); 1273 if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) { 1274 if (D) 1275 // If this subprogram has an abstract definition, reference that 1276 addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE); 1277 } else { 1278 assert(D || includeMinimalInlineScopes()); 1279 if (D) 1280 // And attach the attributes 1281 applySubprogramAttributesToDefinition(SP, *D); 1282 } 1283 } 1284 1285 void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) { 1286 DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity()); 1287 1288 auto *Die = Entity->getDIE(); 1289 /// Label may be used to generate DW_AT_low_pc, so put it outside 1290 /// if/else block. 1291 const DbgLabel *Label = nullptr; 1292 if (AbsEntity && AbsEntity->getDIE()) { 1293 addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE()); 1294 Label = dyn_cast<const DbgLabel>(Entity); 1295 } else { 1296 if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity)) 1297 applyVariableAttributes(*Var, *Die); 1298 else if ((Label = dyn_cast<const DbgLabel>(Entity))) 1299 applyLabelAttributes(*Label, *Die); 1300 else 1301 llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel."); 1302 } 1303 1304 if (Label) 1305 if (const auto *Sym = Label->getSymbol()) 1306 addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym); 1307 } 1308 1309 DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) { 1310 auto &AbstractEntities = getAbstractEntities(); 1311 auto I = AbstractEntities.find(Node); 1312 if (I != AbstractEntities.end()) 1313 return I->second.get(); 1314 return nullptr; 1315 } 1316 1317 void DwarfCompileUnit::createAbstractEntity(const DINode *Node, 1318 LexicalScope *Scope) { 1319 assert(Scope && Scope->isAbstractScope()); 1320 auto &Entity = getAbstractEntities()[Node]; 1321 if (isa<const DILocalVariable>(Node)) { 1322 Entity = std::make_unique<DbgVariable>( 1323 cast<const DILocalVariable>(Node), nullptr /* IA */);; 1324 DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get())); 1325 } else if (isa<const DILabel>(Node)) { 1326 Entity = std::make_unique<DbgLabel>( 1327 cast<const DILabel>(Node), nullptr /* IA */); 1328 DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get())); 1329 } 1330 } 1331 1332 void DwarfCompileUnit::emitHeader(bool UseOffsets) { 1333 // Don't bother labeling the .dwo unit, as its offset isn't used. 1334 if (!Skeleton && !DD->useSectionsAsReferences()) { 1335 LabelBegin = Asm->createTempSymbol("cu_begin"); 1336 Asm->OutStreamer->emitLabel(LabelBegin); 1337 } 1338 1339 dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile 1340 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton 1341 : dwarf::DW_UT_compile; 1342 DwarfUnit::emitCommonHeader(UseOffsets, UT); 1343 if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile) 1344 Asm->emitInt64(getDWOId()); 1345 } 1346 1347 bool DwarfCompileUnit::hasDwarfPubSections() const { 1348 switch (CUNode->getNameTableKind()) { 1349 case DICompileUnit::DebugNameTableKind::None: 1350 return false; 1351 // Opting in to GNU Pubnames/types overrides the default to ensure these are 1352 // generated for things like Gold's gdb_index generation. 1353 case DICompileUnit::DebugNameTableKind::GNU: 1354 return true; 1355 case DICompileUnit::DebugNameTableKind::Default: 1356 return DD->tuneForGDB() && !includeMinimalInlineScopes() && 1357 !CUNode->isDebugDirectivesOnly() && 1358 DD->getAccelTableKind() != AccelTableKind::Apple && 1359 DD->getDwarfVersion() < 5; 1360 } 1361 llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum"); 1362 } 1363 1364 /// addGlobalName - Add a new global name to the compile unit. 1365 void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die, 1366 const DIScope *Context) { 1367 if (!hasDwarfPubSections()) 1368 return; 1369 std::string FullName = getParentContextString(Context) + Name.str(); 1370 GlobalNames[FullName] = &Die; 1371 } 1372 1373 void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name, 1374 const DIScope *Context) { 1375 if (!hasDwarfPubSections()) 1376 return; 1377 std::string FullName = getParentContextString(Context) + Name.str(); 1378 // Insert, allowing the entry to remain as-is if it's already present 1379 // This way the CU-level type DIE is preferred over the "can't describe this 1380 // type as a unit offset because it's not really in the CU at all, it's only 1381 // in a type unit" 1382 GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie())); 1383 } 1384 1385 /// Add a new global type to the unit. 1386 void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die, 1387 const DIScope *Context) { 1388 if (!hasDwarfPubSections()) 1389 return; 1390 std::string FullName = getParentContextString(Context) + Ty->getName().str(); 1391 GlobalTypes[FullName] = &Die; 1392 } 1393 1394 void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty, 1395 const DIScope *Context) { 1396 if (!hasDwarfPubSections()) 1397 return; 1398 std::string FullName = getParentContextString(Context) + Ty->getName().str(); 1399 // Insert, allowing the entry to remain as-is if it's already present 1400 // This way the CU-level type DIE is preferred over the "can't describe this 1401 // type as a unit offset because it's not really in the CU at all, it's only 1402 // in a type unit" 1403 GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie())); 1404 } 1405 1406 void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die, 1407 MachineLocation Location) { 1408 if (DV.hasComplexAddress()) 1409 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); 1410 else 1411 addAddress(Die, dwarf::DW_AT_location, Location); 1412 } 1413 1414 /// Add an address attribute to a die based on the location provided. 1415 void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute, 1416 const MachineLocation &Location) { 1417 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 1418 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 1419 if (Location.isIndirect()) 1420 DwarfExpr.setMemoryLocationKind(); 1421 1422 DIExpressionCursor Cursor({}); 1423 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); 1424 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) 1425 return; 1426 DwarfExpr.addExpression(std::move(Cursor)); 1427 1428 // Now attach the location information to the DIE. 1429 addBlock(Die, Attribute, DwarfExpr.finalize()); 1430 1431 if (DwarfExpr.TagOffset) 1432 addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, 1433 *DwarfExpr.TagOffset); 1434 } 1435 1436 /// Start with the address based on the location provided, and generate the 1437 /// DWARF information necessary to find the actual variable given the extra 1438 /// address information encoded in the DbgVariable, starting from the starting 1439 /// location. Add the DWARF information to the die. 1440 void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die, 1441 dwarf::Attribute Attribute, 1442 const MachineLocation &Location) { 1443 DIELoc *Loc = new (DIEValueAllocator) DIELoc; 1444 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 1445 const DIExpression *DIExpr = DV.getSingleExpression(); 1446 DwarfExpr.addFragmentOffset(DIExpr); 1447 DwarfExpr.setLocation(Location, DIExpr); 1448 1449 DIExpressionCursor Cursor(DIExpr); 1450 1451 if (DIExpr->isEntryValue()) 1452 DwarfExpr.beginEntryValueExpression(Cursor); 1453 1454 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo(); 1455 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg())) 1456 return; 1457 DwarfExpr.addExpression(std::move(Cursor)); 1458 1459 // Now attach the location information to the DIE. 1460 addBlock(Die, Attribute, DwarfExpr.finalize()); 1461 1462 if (DwarfExpr.TagOffset) 1463 addUInt(Die, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1, 1464 *DwarfExpr.TagOffset); 1465 } 1466 1467 /// Add a Dwarf loclistptr attribute data and value. 1468 void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, 1469 unsigned Index) { 1470 dwarf::Form Form = (DD->getDwarfVersion() >= 5) 1471 ? dwarf::DW_FORM_loclistx 1472 : DD->getDwarfSectionOffsetForm(); 1473 addAttribute(Die, Attribute, Form, DIELocList(Index)); 1474 } 1475 1476 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var, 1477 DIE &VariableDie) { 1478 StringRef Name = Var.getName(); 1479 if (!Name.empty()) 1480 addString(VariableDie, dwarf::DW_AT_name, Name); 1481 const auto *DIVar = Var.getVariable(); 1482 if (DIVar) 1483 if (uint32_t AlignInBytes = DIVar->getAlignInBytes()) 1484 addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, 1485 AlignInBytes); 1486 1487 addSourceLine(VariableDie, DIVar); 1488 addType(VariableDie, Var.getType()); 1489 if (Var.isArtificial()) 1490 addFlag(VariableDie, dwarf::DW_AT_artificial); 1491 } 1492 1493 void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label, 1494 DIE &LabelDie) { 1495 StringRef Name = Label.getName(); 1496 if (!Name.empty()) 1497 addString(LabelDie, dwarf::DW_AT_name, Name); 1498 const auto *DILabel = Label.getLabel(); 1499 addSourceLine(LabelDie, DILabel); 1500 } 1501 1502 /// Add a Dwarf expression attribute data and value. 1503 void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form, 1504 const MCExpr *Expr) { 1505 addAttribute(Die, (dwarf::Attribute)0, Form, DIEExpr(Expr)); 1506 } 1507 1508 void DwarfCompileUnit::applySubprogramAttributesToDefinition( 1509 const DISubprogram *SP, DIE &SPDie) { 1510 auto *SPDecl = SP->getDeclaration(); 1511 auto *Context = SPDecl ? SPDecl->getScope() : SP->getScope(); 1512 applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes()); 1513 addGlobalName(SP->getName(), SPDie, Context); 1514 } 1515 1516 bool DwarfCompileUnit::isDwoUnit() const { 1517 return DD->useSplitDwarf() && Skeleton; 1518 } 1519 1520 void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) { 1521 constructTypeDIE(D, CTy); 1522 } 1523 1524 bool DwarfCompileUnit::includeMinimalInlineScopes() const { 1525 return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly || 1526 (DD->useSplitDwarf() && !Skeleton); 1527 } 1528 1529 void DwarfCompileUnit::addAddrTableBase() { 1530 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 1531 MCSymbol *Label = DD->getAddressPool().getLabel(); 1532 addSectionLabel(getUnitDie(), 1533 DD->getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base 1534 : dwarf::DW_AT_GNU_addr_base, 1535 Label, TLOF.getDwarfAddrSection()->getBeginSymbol()); 1536 } 1537 1538 void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) { 1539 addAttribute(Die, (dwarf::Attribute)0, dwarf::DW_FORM_udata, 1540 new (DIEValueAllocator) DIEBaseTypeRef(this, Idx)); 1541 } 1542 1543 void DwarfCompileUnit::createBaseTypeDIEs() { 1544 // Insert the base_type DIEs directly after the CU so that their offsets will 1545 // fit in the fixed size ULEB128 used inside the location expressions. 1546 // Maintain order by iterating backwards and inserting to the front of CU 1547 // child list. 1548 for (auto &Btr : reverse(ExprRefedBaseTypes)) { 1549 DIE &Die = getUnitDie().addChildFront( 1550 DIE::get(DIEValueAllocator, dwarf::DW_TAG_base_type)); 1551 SmallString<32> Str; 1552 addString(Die, dwarf::DW_AT_name, 1553 Twine(dwarf::AttributeEncodingString(Btr.Encoding) + 1554 "_" + Twine(Btr.BitSize)).toStringRef(Str)); 1555 addUInt(Die, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Btr.Encoding); 1556 addUInt(Die, dwarf::DW_AT_byte_size, None, Btr.BitSize / 8); 1557 1558 Btr.Die = &Die; 1559 } 1560 } 1561