llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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