Bug Summary

File:build/llvm-toolchain-snapshot-16~++20221003111214+1fa2019828ca/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
Warning:line 80, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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