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