Bug Summary

File:lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
Warning:line 952, column 22
Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DwarfCompileUnit.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/lib/CodeGen/AsmPrinter -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp -faddrsig
1//===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Units ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for constructing a dwarf compile unit.
11//
12//===----------------------------------------------------------------------===//
13
14#include "DwarfCompileUnit.h"
15#include "AddressPool.h"
16#include "DwarfDebug.h"
17#include "DwarfExpression.h"
18#include "DwarfUnit.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/BinaryFormat/Dwarf.h"
24#include "llvm/CodeGen/AsmPrinter.h"
25#include "llvm/CodeGen/DIE.h"
26#include "llvm/CodeGen/LexicalScopes.h"
27#include "llvm/CodeGen/MachineFunction.h"
28#include "llvm/CodeGen/MachineInstr.h"
29#include "llvm/CodeGen/MachineOperand.h"
30#include "llvm/CodeGen/TargetFrameLowering.h"
31#include "llvm/CodeGen/TargetRegisterInfo.h"
32#include "llvm/CodeGen/TargetSubtargetInfo.h"
33#include "llvm/IR/DataLayout.h"
34#include "llvm/IR/DebugInfo.h"
35#include "llvm/IR/DebugInfoMetadata.h"
36#include "llvm/IR/GlobalVariable.h"
37#include "llvm/MC/MCSection.h"
38#include "llvm/MC/MCStreamer.h"
39#include "llvm/MC/MCSymbol.h"
40#include "llvm/MC/MachineLocation.h"
41#include "llvm/Support/Casting.h"
42#include "llvm/Target/TargetLoweringObjectFile.h"
43#include "llvm/Target/TargetMachine.h"
44#include "llvm/Target/TargetOptions.h"
45#include <algorithm>
46#include <cassert>
47#include <cstdint>
48#include <iterator>
49#include <memory>
50#include <string>
51#include <utility>
52
53using namespace llvm;
54
55DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
56 AsmPrinter *A, DwarfDebug *DW,
57 DwarfFile *DWU)
58 : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) {
59 insertDIE(Node, &getUnitDie());
60 MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
61}
62
63/// addLabelAddress - Add a dwarf label attribute data and value using
64/// DW_FORM_addr or DW_FORM_GNU_addr_index.
65void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
66 const MCSymbol *Label) {
67 // Don't use the address pool in non-fission or in the skeleton unit itself.
68 // FIXME: Once GDB supports this, it's probably worthwhile using the address
69 // pool from the skeleton - maybe even in non-fission (possibly fewer
70 // relocations by sharing them in the pool, but we have other ideas about how
71 // to reduce the number of relocations as well/instead).
72 if (!DD->useSplitDwarf() || !Skeleton)
73 return addLocalLabelAddress(Die, Attribute, Label);
74
75 if (Label)
76 DD->addArangeLabel(SymbolCU(this, Label));
77
78 unsigned idx = DD->getAddressPool().getIndex(Label);
79 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_GNU_addr_index,
80 DIEInteger(idx));
81}
82
83void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
84 dwarf::Attribute Attribute,
85 const MCSymbol *Label) {
86 if (Label)
87 DD->addArangeLabel(SymbolCU(this, Label));
88
89 if (Label)
90 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
91 DIELabel(Label));
92 else
93 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
94 DIEInteger(0));
95}
96
97unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
98 // If we print assembly, we can't separate .file entries according to
99 // compile units. Thus all files will belong to the default compile unit.
100
101 // FIXME: add a better feature test than hasRawTextSupport. Even better,
102 // extend .file to support this.
103 unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
104 if (!File)
105 return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID);
106 return Asm->OutStreamer->EmitDwarfFileDirective(
107 0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
108 File->getSource(), CUID);
109}
110
111DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
112 const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
113 // Check for pre-existence.
114 if (DIE *Die = getDIE(GV))
115 return Die;
116
117 assert(GV)(static_cast <bool> (GV) ? void (0) : __assert_fail ("GV"
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 117, __extension__ __PRETTY_FUNCTION__))
;
118
119 auto *GVContext = GV->getScope();
120 auto *GTy = DD->resolve(GV->getType());
121
122 // Construct the context before querying for the existence of the DIE in
123 // case such construction creates the DIE.
124 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
125
126 // Add to map.
127 DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
128 DIScope *DeclContext;
129 if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
130 DeclContext = resolve(SDMDecl->getScope());
131 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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 131, __extension__ __PRETTY_FUNCTION__))
;
132 assert(GV->isDefinition())(static_cast <bool> (GV->isDefinition()) ? void (0) :
__assert_fail ("GV->isDefinition()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 132, __extension__ __PRETTY_FUNCTION__))
;
133 // We need the declaration DIE that is in the static member's class.
134 DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
135 addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
136 // If the global variable's type is different from the one in the class
137 // member type, assume that it's more specific and also emit it.
138 if (GTy != DD->resolve(SDMDecl->getBaseType()))
139 addType(*VariableDIE, GTy);
140 } else {
141 DeclContext = GV->getScope();
142 // Add name and type.
143 addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
144 addType(*VariableDIE, GTy);
145
146 // Add scoping info.
147 if (!GV->isLocalToUnit())
148 addFlag(*VariableDIE, dwarf::DW_AT_external);
149
150 // Add line number info.
151 addSourceLine(*VariableDIE, GV);
152 }
153
154 if (!GV->isDefinition())
155 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
156 else
157 addGlobalName(GV->getName(), *VariableDIE, DeclContext);
158
159 if (uint32_t AlignInBytes = GV->getAlignInBytes())
160 addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
161 AlignInBytes);
162
163 // Add location.
164 bool addToAccelTable = false;
165 DIELoc *Loc = nullptr;
166 std::unique_ptr<DIEDwarfExpression> DwarfExpr;
167 for (const auto &GE : GlobalExprs) {
168 const GlobalVariable *Global = GE.Var;
169 const DIExpression *Expr = GE.Expr;
170
171 // For compatibility with DWARF 3 and earlier,
172 // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
173 // DW_AT_const_value(X).
174 if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
175 addToAccelTable = true;
176 addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
177 break;
178 }
179
180 // We cannot describe the location of dllimport'd variables: the
181 // computation of their address requires loads from the IAT.
182 if (Global && Global->hasDLLImportStorageClass())
183 continue;
184
185 // Nothing to describe without address or constant.
186 if (!Global && (!Expr || !Expr->isConstant()))
187 continue;
188
189 if (!Loc) {
190 addToAccelTable = true;
191 Loc = new (DIEValueAllocator) DIELoc;
192 DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
193 }
194
195 if (Expr)
196 DwarfExpr->addFragmentOffset(Expr);
197
198 if (Global) {
199 const MCSymbol *Sym = Asm->getSymbol(Global);
200 if (Global->isThreadLocal()) {
201 if (Asm->TM.useEmulatedTLS()) {
202 // TODO: add debug info for emulated thread local mode.
203 } else {
204 // FIXME: Make this work with -gsplit-dwarf.
205 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
206 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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 207, __extension__ __PRETTY_FUNCTION__))
207 "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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 207, __extension__ __PRETTY_FUNCTION__))
;
208 // Based on GCC's support for TLS:
209 if (!DD->useSplitDwarf()) {
210 // 1) Start with a constNu of the appropriate pointer size
211 addUInt(*Loc, dwarf::DW_FORM_data1,
212 PointerSize == 4 ? dwarf::DW_OP_const4u
213 : dwarf::DW_OP_const8u);
214 // 2) containing the (relocated) offset of the TLS variable
215 // within the module's TLS block.
216 addExpr(*Loc, dwarf::DW_FORM_udata,
217 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
218 } else {
219 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
220 addUInt(*Loc, dwarf::DW_FORM_udata,
221 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
222 }
223 // 3) followed by an OP to make the debugger do a TLS lookup.
224 addUInt(*Loc, dwarf::DW_FORM_data1,
225 DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
226 : dwarf::DW_OP_form_tls_address);
227 }
228 } else {
229 DD->addArangeLabel(SymbolCU(this, Sym));
230 addOpAddress(*Loc, Sym);
231 }
232 }
233 // Global variables attached to symbols are memory locations.
234 // It would be better if this were unconditional, but malformed input that
235 // mixes non-fragments and fragments for the same variable is too expensive
236 // to detect in the verifier.
237 if (DwarfExpr->isUnknownLocation())
238 DwarfExpr->setMemoryLocationKind();
239 DwarfExpr->addExpression(Expr);
240 }
241 if (Loc)
242 addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
243
244 if (DD->useAllLinkageNames())
245 addLinkageName(*VariableDIE, GV->getLinkageName());
246
247 if (addToAccelTable) {
248 DD->addAccelName(GV->getName(), *VariableDIE);
249
250 // If the linkage name is different than the name, go ahead and output
251 // that as well into the name table.
252 if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
253 DD->useAllLinkageNames())
254 DD->addAccelName(GV->getLinkageName(), *VariableDIE);
255 }
256
257 return VariableDIE;
258}
259
260void DwarfCompileUnit::addRange(RangeSpan Range) {
261 bool SameAsPrevCU = this == DD->getPrevCU();
262 DD->setPrevCU(this);
263 // If we have no current ranges just add the range and return, otherwise,
264 // check the current section and CU against the previous section and CU we
265 // emitted into and the subprogram was contained within. If these are the
266 // same then extend our current range, otherwise add this as a new range.
267 if (CURanges.empty() || !SameAsPrevCU ||
268 (&CURanges.back().getEnd()->getSection() !=
269 &Range.getEnd()->getSection())) {
270 CURanges.push_back(Range);
271 return;
272 }
273
274 CURanges.back().setEnd(Range.getEnd());
275}
276
277void DwarfCompileUnit::initStmtList() {
278 // Define start line table label for each Compile Unit.
279 MCSymbol *LineTableStartSym;
280 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
281 if (DD->useSectionsAsReferences()) {
282 LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
283 } else {
284 LineTableStartSym =
285 Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
286 }
287
288 // DW_AT_stmt_list is a offset of line number information for this
289 // compile unit in debug_line section. For split dwarf this is
290 // left in the skeleton CU and so not included.
291 // The line table entries are not always emitted in assembly, so it
292 // is not okay to use line_table_start here.
293 StmtListValue =
294 addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
295 TLOF.getDwarfLineSection()->getBeginSymbol());
296}
297
298void DwarfCompileUnit::applyStmtList(DIE &D) {
299 D.addValue(DIEValueAllocator, *StmtListValue);
300}
301
302void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
303 const MCSymbol *End) {
304 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!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 304, __extension__ __PRETTY_FUNCTION__))
;
305 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!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 305, __extension__ __PRETTY_FUNCTION__))
;
306 assert(Begin->isDefined() && "Invalid starting label")(static_cast <bool> (Begin->isDefined() && "Invalid starting label"
) ? void (0) : __assert_fail ("Begin->isDefined() && \"Invalid starting label\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 306, __extension__ __PRETTY_FUNCTION__))
;
307 assert(End->isDefined() && "Invalid end label")(static_cast <bool> (End->isDefined() && "Invalid end label"
) ? void (0) : __assert_fail ("End->isDefined() && \"Invalid end label\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 307, __extension__ __PRETTY_FUNCTION__))
;
308
309 addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
310 if (DD->getDwarfVersion() < 4)
311 addLabelAddress(D, dwarf::DW_AT_high_pc, End);
312 else
313 addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
314}
315
316// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
317// and DW_AT_high_pc attributes. If there are global variables in this
318// scope then create and insert DIEs for these variables.
319DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
320 DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
321
322 attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
323 if (DD->useAppleExtensionAttributes() &&
2
Assuming the condition is false
324 !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
325 *DD->getCurrentFunction()))
326 addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
327
328 // Only include DW_AT_frame_base in full debug info
329 if (!includeMinimalInlineScopes()) {
3
Taking true branch
330 if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) {
4
Taking false branch
331 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
332 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
333 addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
334 } else {
335 const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
336 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
337 if (RI->isPhysicalRegister(Location.getReg()))
5
Taking true branch
338 addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
6
Calling 'DwarfCompileUnit::addAddress'
339 }
340 }
341
342 // Add name to the name table, we do this here because we're guaranteed
343 // to have concrete versions of our DW_TAG_subprogram nodes.
344 DD->addSubprogramNames(SP, *SPDie);
345
346 return *SPDie;
347}
348
349// Construct a DIE for this scope.
350void DwarfCompileUnit::constructScopeDIE(
351 LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
352 if (!Scope || !Scope->getScopeNode())
353 return;
354
355 auto *DS = Scope->getScopeNode();
356
357 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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 360, __extension__ __PRETTY_FUNCTION__))
358 "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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 360, __extension__ __PRETTY_FUNCTION__))
359 "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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 360, __extension__ __PRETTY_FUNCTION__))
360 "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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 360, __extension__ __PRETTY_FUNCTION__))
;
361
362 SmallVector<DIE *, 8> Children;
363
364 // We try to create the scope DIE first, then the children DIEs. This will
365 // avoid creating un-used children then removing them later when we find out
366 // the scope DIE is null.
367 DIE *ScopeDIE;
368 if (Scope->getParent() && isa<DISubprogram>(DS)) {
369 ScopeDIE = constructInlinedScopeDIE(Scope);
370 if (!ScopeDIE)
371 return;
372 // We create children when the scope DIE is not null.
373 createScopeChildrenDIE(Scope, Children);
374 } else {
375 // Early exit when we know the scope DIE is going to be null.
376 if (DD->isLexicalScopeDIENull(Scope))
377 return;
378
379 bool HasNonScopeChildren = false;
380
381 // We create children here when we know the scope DIE is not going to be
382 // null and the children will be added to the scope DIE.
383 createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
384
385 // If there are only other scopes as children, put them directly in the
386 // parent instead, as this scope would serve no purpose.
387 if (!HasNonScopeChildren) {
388 FinalChildren.insert(FinalChildren.end(),
389 std::make_move_iterator(Children.begin()),
390 std::make_move_iterator(Children.end()));
391 return;
392 }
393 ScopeDIE = constructLexicalScopeDIE(Scope);
394 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.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 394, __extension__ __PRETTY_FUNCTION__))
;
395 }
396
397 // Add children
398 for (auto &I : Children)
399 ScopeDIE->addChild(std::move(I));
400
401 FinalChildren.push_back(std::move(ScopeDIE));
402}
403
404void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
405 SmallVector<RangeSpan, 2> Range) {
406 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
407
408 // Emit the offset into .debug_ranges or .debug_rnglists as a relocatable
409 // label. emitDIE() will handle emitting it appropriately.
410 const MCSymbol *RangeSectionSym =
411 DD->getDwarfVersion() >= 5
412 ? TLOF.getDwarfRnglistsSection()->getBeginSymbol()
413 : TLOF.getDwarfRangesSection()->getBeginSymbol();
414
415 RangeSpanList List(Asm->createTempSymbol("debug_ranges"), std::move(Range));
416
417 // Under fission, ranges are specified by constant offsets relative to the
418 // CU's DW_AT_GNU_ranges_base.
419 // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
420 // fission until we support the forms using the .debug_addr section
421 // (DW_RLE_startx_endx etc.).
422 if (isDwoUnit()) {
423 if (DD->getDwarfVersion() < 5)
424 addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
425 RangeSectionSym);
426 } else {
427 addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
428 RangeSectionSym);
429 }
430
431 // Add the range list to the set of ranges to be emitted.
432 (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
433}
434
435void DwarfCompileUnit::attachRangesOrLowHighPC(
436 DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
437 if (Ranges.size() == 1 || !DD->useRangesSection()) {
438 const RangeSpan &Front = Ranges.front();
439 const RangeSpan &Back = Ranges.back();
440 attachLowHighPC(Die, Front.getStart(), Back.getEnd());
441 } else
442 addScopeRangeList(Die, std::move(Ranges));
443}
444
445void DwarfCompileUnit::attachRangesOrLowHighPC(
446 DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
447 SmallVector<RangeSpan, 2> List;
448 List.reserve(Ranges.size());
449 for (const InsnRange &R : Ranges)
450 List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
451 DD->getLabelAfterInsn(R.second)));
452 attachRangesOrLowHighPC(Die, std::move(List));
453}
454
455// This scope represents inlined body of a function. Construct DIE to
456// represent this concrete inlined copy of the function.
457DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
458 assert(Scope->getScopeNode())(static_cast <bool> (Scope->getScopeNode()) ? void (
0) : __assert_fail ("Scope->getScopeNode()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 458, __extension__ __PRETTY_FUNCTION__))
;
459 auto *DS = Scope->getScopeNode();
460 auto *InlinedSP = getDISubprogram(DS);
461 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
462 // was inlined from another compile unit.
463 DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
464 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.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 464, __extension__ __PRETTY_FUNCTION__))
;
465
466 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
467 addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
468
469 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
470
471 // Add the call site information to the DIE.
472 const DILocation *IA = Scope->getInlinedAt();
473 addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
474 getOrCreateSourceID(IA->getFile()));
475 addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
476 if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
477 addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
478 IA->getDiscriminator());
479
480 // Add name to the name table, we do this here because we're guaranteed
481 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
482 DD->addSubprogramNames(InlinedSP, *ScopeDIE);
483
484 return ScopeDIE;
485}
486
487// Construct new DW_TAG_lexical_block for this scope and attach
488// DW_AT_low_pc/DW_AT_high_pc labels.
489DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
490 if (DD->isLexicalScopeDIENull(Scope))
491 return nullptr;
492
493 auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
494 if (Scope->isAbstractScope())
495 return ScopeDIE;
496
497 attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
498
499 return ScopeDIE;
500}
501
502/// constructVariableDIE - Construct a DIE for the given DbgVariable.
503DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
504 auto D = constructVariableDIEImpl(DV, Abstract);
505 DV.setDIE(*D);
506 return D;
507}
508
509DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
510 bool Abstract) {
511 // Define variable debug information entry.
512 auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
513 insertDIE(DV.getVariable(), VariableDie);
514
515 if (Abstract) {
516 applyVariableAttributes(DV, *VariableDie);
517 return VariableDie;
518 }
519
520 // Add variable address.
521
522 unsigned Offset = DV.getDebugLocListIndex();
523 if (Offset != ~0U) {
524 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
525 return VariableDie;
526 }
527
528 // Check if variable is described by a DBG_VALUE instruction.
529 if (const MachineInstr *DVInsn = DV.getMInsn()) {
530 assert(DVInsn->getNumOperands() == 4)(static_cast <bool> (DVInsn->getNumOperands() == 4) ?
void (0) : __assert_fail ("DVInsn->getNumOperands() == 4"
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 530, __extension__ __PRETTY_FUNCTION__))
;
531 if (DVInsn->getOperand(0).isReg()) {
532 auto RegOp = DVInsn->getOperand(0);
533 auto Op1 = DVInsn->getOperand(1);
534 // If the second operand is an immediate, this is an indirect value.
535 assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset")(static_cast <bool> ((!Op1.isImm() || (Op1.getImm() == 0
)) && "unexpected offset") ? void (0) : __assert_fail
("(!Op1.isImm() || (Op1.getImm() == 0)) && \"unexpected offset\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 535, __extension__ __PRETTY_FUNCTION__))
;
536 MachineLocation Location(RegOp.getReg(), Op1.isImm());
537 addVariableAddress(DV, *VariableDie, Location);
538 } else if (DVInsn->getOperand(0).isImm()) {
539 // This variable is described by a single constant.
540 // Check whether it has a DIExpression.
541 auto *Expr = DV.getSingleExpression();
542 if (Expr && Expr->getNumElements()) {
543 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
544 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
545 // If there is an expression, emit raw unsigned bytes.
546 DwarfExpr.addFragmentOffset(Expr);
547 DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm());
548 DwarfExpr.addExpression(Expr);
549 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
550 } else
551 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
552 } else if (DVInsn->getOperand(0).isFPImm())
553 addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
554 else if (DVInsn->getOperand(0).isCImm())
555 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
556 DV.getType());
557
558 return VariableDie;
559 }
560
561 // .. else use frame index.
562 if (!DV.hasFrameIndexExprs())
563 return VariableDie;
564
565 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
566 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
567 for (auto &Fragment : DV.getFrameIndexExprs()) {
568 unsigned FrameReg = 0;
569 const DIExpression *Expr = Fragment.Expr;
570 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
571 int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
572 DwarfExpr.addFragmentOffset(Expr);
573 SmallVector<uint64_t, 8> Ops;
574 Ops.push_back(dwarf::DW_OP_plus_uconst);
575 Ops.push_back(Offset);
576 Ops.append(Expr->elements_begin(), Expr->elements_end());
577 DIExpressionCursor Cursor(Ops);
578 DwarfExpr.setMemoryLocationKind();
579 if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol())
580 addOpAddress(*Loc, FrameSymbol);
581 else
582 DwarfExpr.addMachineRegExpression(
583 *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
584 DwarfExpr.addExpression(std::move(Cursor));
585 }
586 addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
587
588 return VariableDie;
589}
590
591DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
592 const LexicalScope &Scope,
593 DIE *&ObjectPointer) {
594 auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
595 if (DV.isObjectPointer())
596 ObjectPointer = Var;
597 return Var;
598}
599
600/// Return all DIVariables that appear in count: expressions.
601static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
602 SmallVector<const DIVariable *, 2> Result;
603 auto *Array = dyn_cast<DICompositeType>(Var->getType());
604 if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
605 return Result;
606 for (auto *El : Array->getElements()) {
607 if (auto *Subrange = dyn_cast<DISubrange>(El)) {
608 auto Count = Subrange->getCount();
609 if (auto *Dependency = Count.dyn_cast<DIVariable *>())
610 Result.push_back(Dependency);
611 }
612 }
613 return Result;
614}
615
616/// Sort local variables so that variables appearing inside of helper
617/// expressions come first.
618static SmallVector<DbgVariable *, 8>
619sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
620 SmallVector<DbgVariable *, 8> Result;
621 SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
622 // Map back from a DIVariable to its containing DbgVariable.
623 SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
624 // Set of DbgVariables in Result.
625 SmallDenseSet<DbgVariable *, 8> Visited;
626 // For cycle detection.
627 SmallDenseSet<DbgVariable *, 8> Visiting;
628
629 // Initialize the worklist and the DIVariable lookup table.
630 for (auto Var : reverse(Input)) {
631 DbgVar.insert({Var->getVariable(), Var});
632 WorkList.push_back({Var, 0});
633 }
634
635 // Perform a stable topological sort by doing a DFS.
636 while (!WorkList.empty()) {
637 auto Item = WorkList.back();
638 DbgVariable *Var = Item.getPointer();
639 bool visitedAllDependencies = Item.getInt();
640 WorkList.pop_back();
641
642 // Dependency is in a different lexical scope or a global.
643 if (!Var)
644 continue;
645
646 // Already handled.
647 if (Visited.count(Var))
648 continue;
649
650 // Add to Result if all dependencies are visited.
651 if (visitedAllDependencies) {
652 Visited.insert(Var);
653 Result.push_back(Var);
654 continue;
655 }
656
657 // Detect cycles.
658 auto Res = Visiting.insert(Var);
659 if (!Res.second) {
660 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\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 660, __extension__ __PRETTY_FUNCTION__))
;
661 return Result;
662 }
663
664 // Push dependencies and this node onto the worklist, so that this node is
665 // visited again after all of its dependencies are handled.
666 WorkList.push_back({Var, 1});
667 for (auto *Dependency : dependencies(Var)) {
668 auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
669 WorkList.push_back({DbgVar[Dep], 0});
670 }
671 }
672 return Result;
673}
674
675DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
676 SmallVectorImpl<DIE *> &Children,
677 bool *HasNonScopeChildren) {
678 assert(Children.empty())(static_cast <bool> (Children.empty()) ? void (0) : __assert_fail
("Children.empty()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 678, __extension__ __PRETTY_FUNCTION__))
;
679 DIE *ObjectPointer = nullptr;
680
681 // Emit function arguments (order is significant).
682 auto Vars = DU->getScopeVariables().lookup(Scope);
683 for (auto &DV : Vars.Args)
684 Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
685
686 // Emit local variables.
687 auto Locals = sortLocalVars(Vars.Locals);
688 for (DbgVariable *DV : Locals)
689 Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
690
691 // Skip imported directives in gmlt-like data.
692 if (!includeMinimalInlineScopes()) {
693 // There is no need to emit empty lexical block DIE.
694 for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
695 Children.push_back(
696 constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
697 }
698
699 if (HasNonScopeChildren)
700 *HasNonScopeChildren = !Children.empty();
701
702 for (LexicalScope *LS : Scope->getChildren())
703 constructScopeDIE(LS, Children);
704
705 return ObjectPointer;
706}
707
708void DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) {
709 DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
1
Calling 'DwarfCompileUnit::updateSubprogramScopeDIE'
710
711 if (Scope) {
712 assert(!Scope->getInlinedAt())(static_cast <bool> (!Scope->getInlinedAt()) ? void (
0) : __assert_fail ("!Scope->getInlinedAt()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 712, __extension__ __PRETTY_FUNCTION__))
;
713 assert(!Scope->isAbstractScope())(static_cast <bool> (!Scope->isAbstractScope()) ? void
(0) : __assert_fail ("!Scope->isAbstractScope()", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 713, __extension__ __PRETTY_FUNCTION__))
;
714 // Collect lexical scope children first.
715 // ObjectPointer might be a local (non-argument) local variable if it's a
716 // block's synthetic this pointer.
717 if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
718 addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
719 }
720
721 // If this is a variadic function, add an unspecified parameter.
722 DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
723
724 // If we have a single element of null, it is a function that returns void.
725 // If we have more than one elements and the last one is null, it is a
726 // variadic function.
727 if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
728 !includeMinimalInlineScopes())
729 ScopeDIE.addChild(
730 DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
731}
732
733DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
734 DIE &ScopeDIE) {
735 // We create children when the scope DIE is not null.
736 SmallVector<DIE *, 8> Children;
737 DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
738
739 // Add children
740 for (auto &I : Children)
741 ScopeDIE.addChild(std::move(I));
742
743 return ObjectPointer;
744}
745
746void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
747 LexicalScope *Scope) {
748 DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
749 if (AbsDef)
750 return;
751
752 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
753
754 DIE *ContextDIE;
755 DwarfCompileUnit *ContextCU = this;
756
757 if (includeMinimalInlineScopes())
758 ContextDIE = &getUnitDie();
759 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
760 // the important distinction that the debug node is not associated with the
761 // DIE (since the debug node will be associated with the concrete DIE, if
762 // any). It could be refactored to some common utility function.
763 else if (auto *SPDecl = SP->getDeclaration()) {
764 ContextDIE = &getUnitDie();
765 getOrCreateSubprogramDIE(SPDecl);
766 } else {
767 ContextDIE = getOrCreateContextDIE(resolve(SP->getScope()));
768 // The scope may be shared with a subprogram that has already been
769 // constructed in another CU, in which case we need to construct this
770 // subprogram in the same CU.
771 ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
772 }
773
774 // Passing null as the associated node because the abstract definition
775 // shouldn't be found by lookup.
776 AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
777 ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
778
779 if (!ContextCU->includeMinimalInlineScopes())
780 ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
781 if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
782 ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
783}
784
785DIE *DwarfCompileUnit::constructImportedEntityDIE(
786 const DIImportedEntity *Module) {
787 DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
788 insertDIE(Module, IMDie);
789 DIE *EntityDie;
790 auto *Entity = resolve(Module->getEntity());
791 if (auto *NS = dyn_cast<DINamespace>(Entity))
792 EntityDie = getOrCreateNameSpace(NS);
793 else if (auto *M = dyn_cast<DIModule>(Entity))
794 EntityDie = getOrCreateModule(M);
795 else if (auto *SP = dyn_cast<DISubprogram>(Entity))
796 EntityDie = getOrCreateSubprogramDIE(SP);
797 else if (auto *T = dyn_cast<DIType>(Entity))
798 EntityDie = getOrCreateTypeDIE(T);
799 else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
800 EntityDie = getOrCreateGlobalVariableDIE(GV, {});
801 else
802 EntityDie = getDIE(Entity);
803 assert(EntityDie)(static_cast <bool> (EntityDie) ? void (0) : __assert_fail
("EntityDie", "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 803, __extension__ __PRETTY_FUNCTION__))
;
804 addSourceLine(*IMDie, Module->getLine(), Module->getFile());
805 addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
806 StringRef Name = Module->getName();
807 if (!Name.empty())
808 addString(*IMDie, dwarf::DW_AT_name, Name);
809
810 return IMDie;
811}
812
813void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
814 DIE *D = getDIE(SP);
815 if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
816 if (D)
817 // If this subprogram has an abstract definition, reference that
818 addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
819 } else {
820 assert(D || includeMinimalInlineScopes())(static_cast <bool> (D || includeMinimalInlineScopes())
? void (0) : __assert_fail ("D || includeMinimalInlineScopes()"
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 820, __extension__ __PRETTY_FUNCTION__))
;
821 if (D)
822 // And attach the attributes
823 applySubprogramAttributesToDefinition(SP, *D);
824 }
825}
826
827void DwarfCompileUnit::finishVariableDefinition(const DbgVariable &Var) {
828 DbgVariable *AbsVar = getExistingAbstractVariable(
829 InlinedVariable(Var.getVariable(), Var.getInlinedAt()));
830 auto *VariableDie = Var.getDIE();
831 if (AbsVar && AbsVar->getDIE()) {
832 addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
833 *AbsVar->getDIE());
834 } else
835 applyVariableAttributes(Var, *VariableDie);
836}
837
838DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(InlinedVariable IV) {
839 const DILocalVariable *Cleansed;
840 return getExistingAbstractVariable(IV, Cleansed);
841}
842
843// Find abstract variable, if any, associated with Var.
844DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(
845 InlinedVariable IV, const DILocalVariable *&Cleansed) {
846 // More then one inlined variable corresponds to one abstract variable.
847 Cleansed = IV.first;
848 auto &AbstractVariables = getAbstractVariables();
849 auto I = AbstractVariables.find(Cleansed);
850 if (I != AbstractVariables.end())
851 return I->second.get();
852 return nullptr;
853}
854
855void DwarfCompileUnit::createAbstractVariable(const DILocalVariable *Var,
856 LexicalScope *Scope) {
857 assert(Scope && Scope->isAbstractScope())(static_cast <bool> (Scope && Scope->isAbstractScope
()) ? void (0) : __assert_fail ("Scope && Scope->isAbstractScope()"
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 857, __extension__ __PRETTY_FUNCTION__))
;
858 auto AbsDbgVariable = llvm::make_unique<DbgVariable>(Var, /* IA */ nullptr);
859 DU->addScopeVariable(Scope, AbsDbgVariable.get());
860 getAbstractVariables()[Var] = std::move(AbsDbgVariable);
861}
862
863void DwarfCompileUnit::emitHeader(bool UseOffsets) {
864 // Don't bother labeling the .dwo unit, as its offset isn't used.
865 if (!Skeleton && !DD->useSectionsAsReferences()) {
866 LabelBegin = Asm->createTempSymbol("cu_begin");
867 Asm->OutStreamer->EmitLabel(LabelBegin);
868 }
869
870 dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
871 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
872 : dwarf::DW_UT_compile;
873 DwarfUnit::emitCommonHeader(UseOffsets, UT);
874 if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
875 Asm->emitInt64(getDWOId());
876}
877
878bool DwarfCompileUnit::hasDwarfPubSections() const {
879 // Opting in to GNU Pubnames/types overrides the default to ensure these are
880 // generated for things like Gold's gdb_index generation.
881 if (CUNode->getGnuPubnames())
882 return true;
883
884 return DD->tuneForGDB() && DD->usePubSections() &&
885 !includeMinimalInlineScopes();
886}
887
888/// addGlobalName - Add a new global name to the compile unit.
889void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
890 const DIScope *Context) {
891 if (!hasDwarfPubSections())
892 return;
893 std::string FullName = getParentContextString(Context) + Name.str();
894 GlobalNames[FullName] = &Die;
895}
896
897void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
898 const DIScope *Context) {
899 if (!hasDwarfPubSections())
900 return;
901 std::string FullName = getParentContextString(Context) + Name.str();
902 // Insert, allowing the entry to remain as-is if it's already present
903 // This way the CU-level type DIE is preferred over the "can't describe this
904 // type as a unit offset because it's not really in the CU at all, it's only
905 // in a type unit"
906 GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
907}
908
909/// Add a new global type to the unit.
910void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
911 const DIScope *Context) {
912 if (!hasDwarfPubSections())
913 return;
914 std::string FullName = getParentContextString(Context) + Ty->getName().str();
915 GlobalTypes[FullName] = &Die;
916}
917
918void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
919 const DIScope *Context) {
920 if (!hasDwarfPubSections())
921 return;
922 std::string FullName = getParentContextString(Context) + Ty->getName().str();
923 // Insert, allowing the entry to remain as-is if it's already present
924 // This way the CU-level type DIE is preferred over the "can't describe this
925 // type as a unit offset because it's not really in the CU at all, it's only
926 // in a type unit"
927 GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
928}
929
930/// addVariableAddress - Add DW_AT_location attribute for a
931/// DbgVariable based on provided MachineLocation.
932void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
933 MachineLocation Location) {
934 // addBlockByrefAddress is obsolete and will be removed soon.
935 // The clang frontend always generates block byref variables with a
936 // complex expression that encodes exactly what addBlockByrefAddress
937 // would do.
938 assert((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&(static_cast <bool> ((!DV.isBlockByrefVariable() || DV.
hasComplexAddress()) && "block byref variable without a complex expression"
) ? void (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 939, __extension__ __PRETTY_FUNCTION__))
939 "block byref variable without a complex expression")(static_cast <bool> ((!DV.isBlockByrefVariable() || DV.
hasComplexAddress()) && "block byref variable without a complex expression"
) ? void (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\""
, "/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 939, __extension__ __PRETTY_FUNCTION__))
;
940 if (DV.hasComplexAddress())
941 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
942 else if (DV.isBlockByrefVariable())
943 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
944 else
945 addAddress(Die, dwarf::DW_AT_location, Location);
946}
947
948/// Add an address attribute to a die based on the location provided.
949void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
950 const MachineLocation &Location) {
951 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
7
'Loc' initialized to a null pointer value
952 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
8
Forming reference to null pointer
953 if (Location.isIndirect())
954 DwarfExpr.setMemoryLocationKind();
955
956 DIExpressionCursor Cursor({});
957 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
958 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
959 return;
960 DwarfExpr.addExpression(std::move(Cursor));
961
962 // Now attach the location information to the DIE.
963 addBlock(Die, Attribute, DwarfExpr.finalize());
964}
965
966/// Start with the address based on the location provided, and generate the
967/// DWARF information necessary to find the actual variable given the extra
968/// address information encoded in the DbgVariable, starting from the starting
969/// location. Add the DWARF information to the die.
970void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
971 dwarf::Attribute Attribute,
972 const MachineLocation &Location) {
973 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
974 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
975 const DIExpression *DIExpr = DV.getSingleExpression();
976 DwarfExpr.addFragmentOffset(DIExpr);
977 if (Location.isIndirect())
978 DwarfExpr.setMemoryLocationKind();
979
980 DIExpressionCursor Cursor(DIExpr);
981 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
982 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
983 return;
984 DwarfExpr.addExpression(std::move(Cursor));
985
986 // Now attach the location information to the DIE.
987 addBlock(Die, Attribute, DwarfExpr.finalize());
988}
989
990/// Add a Dwarf loclistptr attribute data and value.
991void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
992 unsigned Index) {
993 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
994 : dwarf::DW_FORM_data4;
995 Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
996}
997
998void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
999 DIE &VariableDie) {
1000 StringRef Name = Var.getName();
1001 if (!Name.empty())
1002 addString(VariableDie, dwarf::DW_AT_name, Name);
1003 const auto *DIVar = Var.getVariable();
1004 if (DIVar)
1005 if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
1006 addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1007 AlignInBytes);
1008
1009 addSourceLine(VariableDie, DIVar);
1010 addType(VariableDie, Var.getType());
1011 if (Var.isArtificial())
1012 addFlag(VariableDie, dwarf::DW_AT_artificial);
1013}
1014
1015/// Add a Dwarf expression attribute data and value.
1016void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
1017 const MCExpr *Expr) {
1018 Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
1019}
1020
1021void DwarfCompileUnit::applySubprogramAttributesToDefinition(
1022 const DISubprogram *SP, DIE &SPDie) {
1023 auto *SPDecl = SP->getDeclaration();
1024 auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
1025 applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
1026 addGlobalName(SP->getName(), SPDie, Context);
1027}
1028
1029bool DwarfCompileUnit::isDwoUnit() const {
1030 return DD->useSplitDwarf() && Skeleton;
1031}
1032
1033bool DwarfCompileUnit::includeMinimalInlineScopes() const {
1034 return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
1035 (DD->useSplitDwarf() && !Skeleton);
1036}