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