Bug Summary

File:lib/CodeGen/AsmPrinter/DwarfUnit.cpp
Warning:line 507, column 36
Called C++ object pointer is null

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 DwarfUnit.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~svn337204/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn337204/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/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/7.3.0/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-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn337204/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-17-043059-5239-1 -x c++ /build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
1//===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and 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 "DwarfUnit.h"
15#include "AddressPool.h"
16#include "DwarfCompileUnit.h"
17#include "DwarfDebug.h"
18#include "DwarfExpression.h"
19#include "llvm/ADT/APFloat.h"
20#include "llvm/ADT/APInt.h"
21#include "llvm/ADT/None.h"
22#include "llvm/ADT/StringExtras.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/CodeGen/MachineFunction.h"
25#include "llvm/CodeGen/MachineOperand.h"
26#include "llvm/CodeGen/TargetRegisterInfo.h"
27#include "llvm/CodeGen/TargetSubtargetInfo.h"
28#include "llvm/IR/Constants.h"
29#include "llvm/IR/DataLayout.h"
30#include "llvm/IR/GlobalValue.h"
31#include "llvm/IR/Metadata.h"
32#include "llvm/MC/MCAsmInfo.h"
33#include "llvm/MC/MCContext.h"
34#include "llvm/MC/MCDwarf.h"
35#include "llvm/MC/MCSection.h"
36#include "llvm/MC/MCStreamer.h"
37#include "llvm/MC/MachineLocation.h"
38#include "llvm/Support/Casting.h"
39#include "llvm/Support/CommandLine.h"
40#include "llvm/Target/TargetLoweringObjectFile.h"
41#include <cassert>
42#include <cstdint>
43#include <string>
44#include <utility>
45
46using namespace llvm;
47
48#define DEBUG_TYPE"dwarfdebug" "dwarfdebug"
49
50static cl::opt<bool>
51GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
52 cl::desc("Generate DWARF4 type units."),
53 cl::init(false));
54
55DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
56 DIELoc &DIE)
57 : DwarfExpression(AP.getDwarfVersion()), AP(AP), DU(DU),
58 DIE(DIE) {}
59
60void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
61 DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
62}
63
64void DIEDwarfExpression::emitSigned(int64_t Value) {
65 DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
66}
67
68void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
69 DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
70}
71
72bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
73 unsigned MachineReg) {
74 return MachineReg == TRI.getFrameRegister(*AP.MF);
75}
76
77DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
78 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
79 : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
80 CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
81}
82
83DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
84 DwarfDebug *DW, DwarfFile *DWU,
85 MCDwarfDwoLineTable *SplitLineTable)
86 : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
87 SplitLineTable(SplitLineTable) {
88}
89
90DwarfUnit::~DwarfUnit() {
91 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
92 DIEBlocks[j]->~DIEBlock();
93 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
94 DIELocs[j]->~DIELoc();
95}
96
97int64_t DwarfUnit::getDefaultLowerBound() const {
98 switch (getLanguage()) {
99 default:
100 break;
101
102 // The languages below have valid values in all DWARF versions.
103 case dwarf::DW_LANG_C:
104 case dwarf::DW_LANG_C89:
105 case dwarf::DW_LANG_C_plus_plus:
106 return 0;
107
108 case dwarf::DW_LANG_Fortran77:
109 case dwarf::DW_LANG_Fortran90:
110 return 1;
111
112 // The languages below have valid values only if the DWARF version >= 3.
113 case dwarf::DW_LANG_C99:
114 case dwarf::DW_LANG_ObjC:
115 case dwarf::DW_LANG_ObjC_plus_plus:
116 if (DD->getDwarfVersion() >= 3)
117 return 0;
118 break;
119
120 case dwarf::DW_LANG_Fortran95:
121 if (DD->getDwarfVersion() >= 3)
122 return 1;
123 break;
124
125 // Starting with DWARF v4, all defined languages have valid values.
126 case dwarf::DW_LANG_D:
127 case dwarf::DW_LANG_Java:
128 case dwarf::DW_LANG_Python:
129 case dwarf::DW_LANG_UPC:
130 if (DD->getDwarfVersion() >= 4)
131 return 0;
132 break;
133
134 case dwarf::DW_LANG_Ada83:
135 case dwarf::DW_LANG_Ada95:
136 case dwarf::DW_LANG_Cobol74:
137 case dwarf::DW_LANG_Cobol85:
138 case dwarf::DW_LANG_Modula2:
139 case dwarf::DW_LANG_Pascal83:
140 case dwarf::DW_LANG_PLI:
141 if (DD->getDwarfVersion() >= 4)
142 return 1;
143 break;
144
145 // The languages below are new in DWARF v5.
146 case dwarf::DW_LANG_BLISS:
147 case dwarf::DW_LANG_C11:
148 case dwarf::DW_LANG_C_plus_plus_03:
149 case dwarf::DW_LANG_C_plus_plus_11:
150 case dwarf::DW_LANG_C_plus_plus_14:
151 case dwarf::DW_LANG_Dylan:
152 case dwarf::DW_LANG_Go:
153 case dwarf::DW_LANG_Haskell:
154 case dwarf::DW_LANG_OCaml:
155 case dwarf::DW_LANG_OpenCL:
156 case dwarf::DW_LANG_RenderScript:
157 case dwarf::DW_LANG_Rust:
158 case dwarf::DW_LANG_Swift:
159 if (DD->getDwarfVersion() >= 5)
160 return 0;
161 break;
162
163 case dwarf::DW_LANG_Fortran03:
164 case dwarf::DW_LANG_Fortran08:
165 case dwarf::DW_LANG_Julia:
166 case dwarf::DW_LANG_Modula3:
167 if (DD->getDwarfVersion() >= 5)
168 return 1;
169 break;
170 }
171
172 return -1;
173}
174
175/// Check whether the DIE for this MDNode can be shared across CUs.
176bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const {
177 // When the MDNode can be part of the type system, the DIE can be shared
178 // across CUs.
179 // Combining type units and cross-CU DIE sharing is lower value (since
180 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
181 // level already) but may be implementable for some value in projects
182 // building multiple independent libraries with LTO and then linking those
183 // together.
184 if (isDwoUnit() && !DD->shareAcrossDWOCUs())
185 return false;
186 return (isa<DIType>(D) ||
187 (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
188 !GenerateDwarfTypeUnits;
189}
190
191DIE *DwarfUnit::getDIE(const DINode *D) const {
192 if (isShareableAcrossCUs(D))
193 return DU->getDIE(D);
194 return MDNodeToDieMap.lookup(D);
195}
196
197void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
198 if (isShareableAcrossCUs(Desc)) {
199 DU->insertDIE(Desc, D);
200 return;
201 }
202 MDNodeToDieMap.insert(std::make_pair(Desc, D));
203}
204
205void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
206 if (DD->getDwarfVersion() >= 4)
207 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
208 DIEInteger(1));
209 else
210 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
211 DIEInteger(1));
212}
213
214void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
215 Optional<dwarf::Form> Form, uint64_t Integer) {
216 if (!Form)
217 Form = DIEInteger::BestForm(false, Integer);
218 assert(Form != dwarf::DW_FORM_implicit_const &&(static_cast <bool> (Form != dwarf::DW_FORM_implicit_const
&& "DW_FORM_implicit_const is used only for signed integers"
) ? void (0) : __assert_fail ("Form != dwarf::DW_FORM_implicit_const && \"DW_FORM_implicit_const is used only for signed integers\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 219, __extension__ __PRETTY_FUNCTION__))
219 "DW_FORM_implicit_const is used only for signed integers")(static_cast <bool> (Form != dwarf::DW_FORM_implicit_const
&& "DW_FORM_implicit_const is used only for signed integers"
) ? void (0) : __assert_fail ("Form != dwarf::DW_FORM_implicit_const && \"DW_FORM_implicit_const is used only for signed integers\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 219, __extension__ __PRETTY_FUNCTION__))
;
220 Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
221}
222
223void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
224 uint64_t Integer) {
225 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
226}
227
228void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
229 Optional<dwarf::Form> Form, int64_t Integer) {
230 if (!Form)
231 Form = DIEInteger::BestForm(true, Integer);
232 Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
233}
234
235void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
236 int64_t Integer) {
237 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
238}
239
240void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
241 StringRef String) {
242 if (DD->useInlineStrings()) {
243 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
244 new (DIEValueAllocator)
245 DIEInlineString(String, DIEValueAllocator));
246 return;
247 }
248 auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
249 dwarf::Form IxForm =
250 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
251 // For DWARF v5 and beyond, use the smallest strx? form possible.
252 if (useSegmentedStringOffsetsTable()) {
253 IxForm = dwarf::DW_FORM_strx1;
254 unsigned Index = StringPoolEntry.getIndex();
255 if (Index > 0xffffff)
256 IxForm = dwarf::DW_FORM_strx4;
257 else if (Index > 0xffff)
258 IxForm = dwarf::DW_FORM_strx3;
259 else if (Index > 0xff)
260 IxForm = dwarf::DW_FORM_strx2;
261 }
262 Die.addValue(DIEValueAllocator, Attribute, IxForm,
263 DIEString(StringPoolEntry));
264}
265
266DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
267 dwarf::Attribute Attribute,
268 dwarf::Form Form,
269 const MCSymbol *Label) {
270 return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
271}
272
273void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
274 addLabel(Die, (dwarf::Attribute)0, Form, Label);
275}
276
277void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
278 uint64_t Integer) {
279 if (DD->getDwarfVersion() >= 4)
280 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
281 else
282 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
283}
284
285MD5::MD5Result *DwarfUnit::getMD5AsBytes(const DIFile *File) const {
286 assert(File)(static_cast <bool> (File) ? void (0) : __assert_fail (
"File", "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 286, __extension__ __PRETTY_FUNCTION__))
;
287 if (DD->getDwarfVersion() < 5)
288 return nullptr;
289 Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
290 if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
291 return nullptr;
292
293 // Convert the string checksum to an MD5Result for the streamer.
294 // The verifier validates the checksum so we assume it's okay.
295 // An MD5 checksum is 16 bytes.
296 std::string ChecksumString = fromHex(Checksum->Value);
297 void *CKMem = Asm->OutStreamer->getContext().allocate(16, 1);
298 memcpy(CKMem, ChecksumString.data(), 16);
299 return reinterpret_cast<MD5::MD5Result *>(CKMem);
300}
301
302unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
303 if (!SplitLineTable)
304 return getCU().getOrCreateSourceID(File);
305 if (!UsedLineTable) {
306 UsedLineTable = true;
307 // This is a split type unit that needs a line table.
308 addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
309 }
310 return SplitLineTable->getFile(File->getDirectory(), File->getFilename(),
311 getMD5AsBytes(File), File->getSource());
312}
313
314void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
315 if (!DD->useSplitDwarf()) {
316 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
317 addLabel(Die, dwarf::DW_FORM_udata, Sym);
318 } else {
319 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
320 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
321 DD->getAddressPool().getIndex(Sym));
322 }
323}
324
325void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
326 const MCSymbol *Hi, const MCSymbol *Lo) {
327 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
328 new (DIEValueAllocator) DIEDelta(Hi, Lo));
329}
330
331void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
332 addDIEEntry(Die, Attribute, DIEEntry(Entry));
333}
334
335void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
336 // Flag the type unit reference as a declaration so that if it contains
337 // members (implicit special members, static data member definitions, member
338 // declarations for definitions in this CU, etc) consumers don't get confused
339 // and think this is a full definition.
340 addFlag(Die, dwarf::DW_AT_declaration);
341
342 Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
343 dwarf::DW_FORM_ref_sig8, DIEInteger(Signature));
344}
345
346void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
347 DIEEntry Entry) {
348 const DIEUnit *CU = Die.getUnit();
349 const DIEUnit *EntryCU = Entry.getEntry().getUnit();
350 if (!CU)
351 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
352 CU = getUnitDie().getUnit();
353 if (!EntryCU)
354 EntryCU = getUnitDie().getUnit();
355 Die.addValue(DIEValueAllocator, Attribute,
356 EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
357 Entry);
358}
359
360DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
361 DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
362 if (N)
363 insertDIE(N, &Die);
364 return Die;
365}
366
367void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
368 Loc->ComputeSize(Asm);
369 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
370 Die.addValue(DIEValueAllocator, Attribute,
371 Loc->BestForm(DD->getDwarfVersion()), Loc);
372}
373
374void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
375 DIEBlock *Block) {
376 Block->ComputeSize(Asm);
377 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
378 Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
379}
380
381void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
382 if (Line == 0)
383 return;
384
385 unsigned FileID = getOrCreateSourceID(File);
386 assert(FileID && "Invalid file id")(static_cast <bool> (FileID && "Invalid file id"
) ? void (0) : __assert_fail ("FileID && \"Invalid file id\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 386, __extension__ __PRETTY_FUNCTION__))
;
387 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
388 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
389}
390
391void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
392 assert(V)(static_cast <bool> (V) ? void (0) : __assert_fail ("V"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 392, __extension__ __PRETTY_FUNCTION__))
;
393
394 addSourceLine(Die, V->getLine(), V->getFile());
395}
396
397void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
398 assert(G)(static_cast <bool> (G) ? void (0) : __assert_fail ("G"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 398, __extension__ __PRETTY_FUNCTION__))
;
399
400 addSourceLine(Die, G->getLine(), G->getFile());
401}
402
403void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
404 assert(SP)(static_cast <bool> (SP) ? void (0) : __assert_fail ("SP"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 404, __extension__ __PRETTY_FUNCTION__))
;
405
406 addSourceLine(Die, SP->getLine(), SP->getFile());
407}
408
409void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
410 assert(Ty)(static_cast <bool> (Ty) ? void (0) : __assert_fail ("Ty"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 410, __extension__ __PRETTY_FUNCTION__))
;
411
412 addSourceLine(Die, Ty->getLine(), Ty->getFile());
413}
414
415void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
416 assert(Ty)(static_cast <bool> (Ty) ? void (0) : __assert_fail ("Ty"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 416, __extension__ __PRETTY_FUNCTION__))
;
417
418 addSourceLine(Die, Ty->getLine(), Ty->getFile());
419}
420
421/* Byref variables, in Blocks, are declared by the programmer as "SomeType
422 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
423 gives the variable VarName either the struct, or a pointer to the struct, as
424 its type. This is necessary for various behind-the-scenes things the
425 compiler needs to do with by-reference variables in Blocks.
426
427 However, as far as the original *programmer* is concerned, the variable
428 should still have type 'SomeType', as originally declared.
429
430 The function getBlockByrefType dives into the __Block_byref_x_VarName
431 struct to find the original type of the variable, which is then assigned to
432 the variable's Debug Information Entry as its real type. So far, so good.
433 However now the debugger will expect the variable VarName to have the type
434 SomeType. So we need the location attribute for the variable to be an
435 expression that explains to the debugger how to navigate through the
436 pointers and struct to find the actual variable of type SomeType.
437
438 The following function does just that. We start by getting
439 the "normal" location for the variable. This will be the location
440 of either the struct __Block_byref_x_VarName or the pointer to the
441 struct __Block_byref_x_VarName.
442
443 The struct will look something like:
444
445 struct __Block_byref_x_VarName {
446 ... <various fields>
447 struct __Block_byref_x_VarName *forwarding;
448 ... <various other fields>
449 SomeType VarName;
450 ... <maybe more fields>
451 };
452
453 If we are given the struct directly (as our starting point) we
454 need to tell the debugger to:
455
456 1). Add the offset of the forwarding field.
457
458 2). Follow that pointer to get the real __Block_byref_x_VarName
459 struct to use (the real one may have been copied onto the heap).
460
461 3). Add the offset for the field VarName, to find the actual variable.
462
463 If we started with a pointer to the struct, then we need to
464 dereference that pointer first, before the other steps.
465 Translating this into DWARF ops, we will need to append the following
466 to the current location description for the variable:
467
468 DW_OP_deref -- optional, if we start with a pointer
469 DW_OP_plus_uconst <forward_fld_offset>
470 DW_OP_deref
471 DW_OP_plus_uconst <varName_fld_offset>
472
473 That is what this function does. */
474
475void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
476 dwarf::Attribute Attribute,
477 const MachineLocation &Location) {
478 const DIType *Ty = DV.getType();
479 const DIType *TmpTy = Ty;
480 uint16_t Tag = Ty->getTag();
481 bool isPointer = false;
482
483 StringRef varName = DV.getName();
484
485 if (Tag == dwarf::DW_TAG_pointer_type) {
1
Assuming 'Tag' is not equal to DW_TAG_pointer_type
2
Taking false branch
486 auto *DTy = cast<DIDerivedType>(Ty);
487 TmpTy = resolve(DTy->getBaseType());
488 isPointer = true;
489 }
490
491 // Find the __forwarding field and the variable field in the __Block_byref
492 // struct.
493 DINodeArray Fields = cast<DICompositeType>(TmpTy)->getElements();
494 const DIDerivedType *varField = nullptr;
495 const DIDerivedType *forwardingField = nullptr;
3
'forwardingField' initialized to a null pointer value
496
497 for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
4
Assuming 'i' is >= 'N'
5
Loop condition is false. Execution continues on line 507
498 auto *DT = cast<DIDerivedType>(Fields[i]);
499 StringRef fieldName = DT->getName();
500 if (fieldName == "__forwarding")
501 forwardingField = DT;
502 else if (fieldName == varName)
503 varField = DT;
504 }
505
506 // Get the offsets for the forwarding field and the variable field.
507 unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
6
Called C++ object pointer is null
508 unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
509
510 // Decode the original location, and use that as the start of the byref
511 // variable's location.
512 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
513 DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
514 if (Location.isIndirect())
515 DwarfExpr.setMemoryLocationKind();
516
517 SmallVector<uint64_t, 6> Ops;
518 // If we started with a pointer to the __Block_byref... struct, then
519 // the first thing we need to do is dereference the pointer (DW_OP_deref).
520 if (isPointer)
521 Ops.push_back(dwarf::DW_OP_deref);
522
523 // Next add the offset for the '__forwarding' field:
524 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
525 // adding the offset if it's 0.
526 if (forwardingFieldOffset > 0) {
527 Ops.push_back(dwarf::DW_OP_plus_uconst);
528 Ops.push_back(forwardingFieldOffset);
529 }
530
531 // Now dereference the __forwarding field to get to the real __Block_byref
532 // struct: DW_OP_deref.
533 Ops.push_back(dwarf::DW_OP_deref);
534
535 // Now that we've got the real __Block_byref... struct, add the offset
536 // for the variable's field to get to the location of the actual variable:
537 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
538 if (varFieldOffset > 0) {
539 Ops.push_back(dwarf::DW_OP_plus_uconst);
540 Ops.push_back(varFieldOffset);
541 }
542
543 DIExpressionCursor Cursor(Ops);
544 const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
545 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
546 return;
547 DwarfExpr.addExpression(std::move(Cursor));
548
549 // Now attach the location information to the DIE.
550 addBlock(Die, Attribute, DwarfExpr.finalize());
551}
552
553/// Return true if type encoding is unsigned.
554static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
555 if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
556 // FIXME: Enums without a fixed underlying type have unknown signedness
557 // here, leading to incorrectly emitted constants.
558 if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
559 return false;
560
561 // (Pieces of) aggregate types that get hacked apart by SROA may be
562 // represented by a constant. Encode them as unsigned bytes.
563 return true;
564 }
565
566 if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
567 dwarf::Tag T = (dwarf::Tag)Ty->getTag();
568 // Encode pointer constants as unsigned bytes. This is used at least for
569 // null pointer constant emission.
570 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
571 // here, but accept them for now due to a bug in SROA producing bogus
572 // dbg.values.
573 if (T == dwarf::DW_TAG_pointer_type ||
574 T == dwarf::DW_TAG_ptr_to_member_type ||
575 T == dwarf::DW_TAG_reference_type ||
576 T == dwarf::DW_TAG_rvalue_reference_type)
577 return true;
578 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||(static_cast <bool> (T == dwarf::DW_TAG_typedef || T ==
dwarf::DW_TAG_const_type || T == dwarf::DW_TAG_volatile_type
|| T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type
) ? void (0) : __assert_fail ("T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || T == dwarf::DW_TAG_volatile_type || T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 580, __extension__ __PRETTY_FUNCTION__))
579 T == dwarf::DW_TAG_volatile_type ||(static_cast <bool> (T == dwarf::DW_TAG_typedef || T ==
dwarf::DW_TAG_const_type || T == dwarf::DW_TAG_volatile_type
|| T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type
) ? void (0) : __assert_fail ("T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || T == dwarf::DW_TAG_volatile_type || T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 580, __extension__ __PRETTY_FUNCTION__))
580 T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type)(static_cast <bool> (T == dwarf::DW_TAG_typedef || T ==
dwarf::DW_TAG_const_type || T == dwarf::DW_TAG_volatile_type
|| T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type
) ? void (0) : __assert_fail ("T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || T == dwarf::DW_TAG_volatile_type || T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type"
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 580, __extension__ __PRETTY_FUNCTION__))
;
581 DITypeRef Deriv = DTy->getBaseType();
582 assert(Deriv && "Expected valid base type")(static_cast <bool> (Deriv && "Expected valid base type"
) ? void (0) : __assert_fail ("Deriv && \"Expected valid base type\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 582, __extension__ __PRETTY_FUNCTION__))
;
583 return isUnsignedDIType(DD, DD->resolve(Deriv));
584 }
585
586 auto *BTy = cast<DIBasicType>(Ty);
587 unsigned Encoding = BTy->getEncoding();
588 assert((Encoding == dwarf::DW_ATE_unsigned ||(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
589 Encoding == dwarf::DW_ATE_unsigned_char ||(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
590 Encoding == dwarf::DW_ATE_signed ||(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
591 Encoding == dwarf::DW_ATE_signed_char ||(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
592 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
593 Encoding == dwarf::DW_ATE_boolean ||(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
594 (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
595 Ty->getName() == "decltype(nullptr)")) &&(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
596 "Unsupported encoding")(static_cast <bool> ((Encoding == dwarf::DW_ATE_unsigned
|| Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf
::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding
== dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding
== dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type
&& Ty->getName() == "decltype(nullptr)")) &&
"Unsupported encoding") ? void (0) : __assert_fail ("(Encoding == dwarf::DW_ATE_unsigned || Encoding == dwarf::DW_ATE_unsigned_char || Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char || Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || (Ty->getTag() == dwarf::DW_TAG_unspecified_type && Ty->getName() == \"decltype(nullptr)\")) && \"Unsupported encoding\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 596, __extension__ __PRETTY_FUNCTION__))
;
597 return Encoding == dwarf::DW_ATE_unsigned ||
598 Encoding == dwarf::DW_ATE_unsigned_char ||
599 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
600 Ty->getTag() == dwarf::DW_TAG_unspecified_type;
601}
602
603void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
604 assert(MO.isFPImm() && "Invalid machine operand!")(static_cast <bool> (MO.isFPImm() && "Invalid machine operand!"
) ? void (0) : __assert_fail ("MO.isFPImm() && \"Invalid machine operand!\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 604, __extension__ __PRETTY_FUNCTION__))
;
605 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
606 APFloat FPImm = MO.getFPImm()->getValueAPF();
607
608 // Get the raw data form of the floating point.
609 const APInt FltVal = FPImm.bitcastToAPInt();
610 const char *FltPtr = (const char *)FltVal.getRawData();
611
612 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
613 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
614 int Incr = (LittleEndian ? 1 : -1);
615 int Start = (LittleEndian ? 0 : NumBytes - 1);
616 int Stop = (LittleEndian ? NumBytes : -1);
617
618 // Output the constant to DWARF one byte at a time.
619 for (; Start != Stop; Start += Incr)
620 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
621
622 addBlock(Die, dwarf::DW_AT_const_value, Block);
623}
624
625void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
626 // Pass this down to addConstantValue as an unsigned bag of bits.
627 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
628}
629
630void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
631 const DIType *Ty) {
632 addConstantValue(Die, CI->getValue(), Ty);
633}
634
635void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
636 const DIType *Ty) {
637 assert(MO.isImm() && "Invalid machine operand!")(static_cast <bool> (MO.isImm() && "Invalid machine operand!"
) ? void (0) : __assert_fail ("MO.isImm() && \"Invalid machine operand!\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 637, __extension__ __PRETTY_FUNCTION__))
;
638
639 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
640}
641
642void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
643 // FIXME: This is a bit conservative/simple - it emits negative values always
644 // sign extended to 64 bits rather than minimizing the number of bytes.
645 addUInt(Die, dwarf::DW_AT_const_value,
646 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
647}
648
649void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
650 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
651}
652
653void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
654 unsigned CIBitWidth = Val.getBitWidth();
655 if (CIBitWidth <= 64) {
656 addConstantValue(Die, Unsigned,
657 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
658 return;
659 }
660
661 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
662
663 // Get the raw data form of the large APInt.
664 const uint64_t *Ptr64 = Val.getRawData();
665
666 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
667 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
668
669 // Output the constant to DWARF one byte at a time.
670 for (int i = 0; i < NumBytes; i++) {
671 uint8_t c;
672 if (LittleEndian)
673 c = Ptr64[i / 8] >> (8 * (i & 7));
674 else
675 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
676 addUInt(*Block, dwarf::DW_FORM_data1, c);
677 }
678
679 addBlock(Die, dwarf::DW_AT_const_value, Block);
680}
681
682void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
683 if (!LinkageName.empty())
684 addString(Die,
685 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
686 : dwarf::DW_AT_MIPS_linkage_name,
687 GlobalValue::dropLLVMManglingEscape(LinkageName));
688}
689
690void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
691 // Add template parameters.
692 for (const auto *Element : TParams) {
693 if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
694 constructTemplateTypeParameterDIE(Buffer, TTP);
695 else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
696 constructTemplateValueParameterDIE(Buffer, TVP);
697 }
698}
699
700/// Add thrown types.
701void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
702 for (const auto *Ty : ThrownTypes) {
703 DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
704 addType(TT, cast<DIType>(Ty));
705 }
706}
707
708DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
709 if (!Context || isa<DIFile>(Context))
710 return &getUnitDie();
711 if (auto *T = dyn_cast<DIType>(Context))
712 return getOrCreateTypeDIE(T);
713 if (auto *NS = dyn_cast<DINamespace>(Context))
714 return getOrCreateNameSpace(NS);
715 if (auto *SP = dyn_cast<DISubprogram>(Context))
716 return getOrCreateSubprogramDIE(SP);
717 if (auto *M = dyn_cast<DIModule>(Context))
718 return getOrCreateModule(M);
719 return getDIE(Context);
720}
721
722DIE *DwarfTypeUnit::createTypeDIE(const DICompositeType *Ty) {
723 auto *Context = resolve(Ty->getScope());
724 DIE *ContextDIE = getOrCreateContextDIE(Context);
725
726 if (DIE *TyDIE = getDIE(Ty))
727 return TyDIE;
728
729 // Create new type.
730 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
731
732 constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
733
734 updateAcceleratorTables(Context, Ty, TyDIE);
735 return &TyDIE;
736}
737
738DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
739 if (!TyNode)
740 return nullptr;
741
742 auto *Ty = cast<DIType>(TyNode);
743
744 // DW_TAG_restrict_type is not supported in DWARF2
745 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
746 return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
747
748 // DW_TAG_atomic_type is not supported in DWARF < 5
749 if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
750 return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
751
752 // Construct the context before querying for the existence of the DIE in case
753 // such construction creates the DIE.
754 auto *Context = resolve(Ty->getScope());
755 DIE *ContextDIE = getOrCreateContextDIE(Context);
756 assert(ContextDIE)(static_cast <bool> (ContextDIE) ? void (0) : __assert_fail
("ContextDIE", "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 756, __extension__ __PRETTY_FUNCTION__))
;
757
758 if (DIE *TyDIE = getDIE(Ty))
759 return TyDIE;
760
761 // Create new type.
762 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
763
764 updateAcceleratorTables(Context, Ty, TyDIE);
765
766 if (auto *BT = dyn_cast<DIBasicType>(Ty))
767 constructTypeDIE(TyDIE, BT);
768 else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
769 constructTypeDIE(TyDIE, STy);
770 else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
771 if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
772 if (MDString *TypeId = CTy->getRawIdentifier()) {
773 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
774 // Skip updating the accelerator tables since this is not the full type.
775 return &TyDIE;
776 }
777 constructTypeDIE(TyDIE, CTy);
778 } else {
779 constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
780 }
781
782 return &TyDIE;
783}
784
785void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
786 const DIType *Ty, const DIE &TyDIE) {
787 if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
788 bool IsImplementation = false;
789 if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
790 // A runtime language of 0 actually means C/C++ and that any
791 // non-negative value is some version of Objective-C/C++.
792 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
793 }
794 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
795 DD->addAccelType(Ty->getName(), TyDIE, Flags);
796
797 if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
798 isa<DINamespace>(Context))
799 addGlobalType(Ty, TyDIE, Context);
800 }
801}
802
803void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
804 dwarf::Attribute Attribute) {
805 assert(Ty && "Trying to add a type that doesn't exist?")(static_cast <bool> (Ty && "Trying to add a type that doesn't exist?"
) ? void (0) : __assert_fail ("Ty && \"Trying to add a type that doesn't exist?\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 805, __extension__ __PRETTY_FUNCTION__))
;
806 addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
807}
808
809std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
810 if (!Context)
811 return "";
812
813 // FIXME: Decide whether to implement this for non-C++ languages.
814 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
815 return "";
816
817 std::string CS;
818 SmallVector<const DIScope *, 1> Parents;
819 while (!isa<DICompileUnit>(Context)) {
820 Parents.push_back(Context);
821 if (Context->getScope())
822 Context = resolve(Context->getScope());
823 else
824 // Structure, etc types will have a NULL context if they're at the top
825 // level.
826 break;
827 }
828
829 // Reverse iterate over our list to go from the outermost construct to the
830 // innermost.
831 for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
832 StringRef Name = Ctx->getName();
833 if (Name.empty() && isa<DINamespace>(Ctx))
834 Name = "(anonymous namespace)";
835 if (!Name.empty()) {
836 CS += Name;
837 CS += "::";
838 }
839 }
840 return CS;
841}
842
843void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
844 // Get core information.
845 StringRef Name = BTy->getName();
846 // Add name if not anonymous or intermediate type.
847 if (!Name.empty())
848 addString(Buffer, dwarf::DW_AT_name, Name);
849
850 // An unspecified type only has a name attribute.
851 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
852 return;
853
854 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
855 BTy->getEncoding());
856
857 uint64_t Size = BTy->getSizeInBits() >> 3;
858 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
859}
860
861void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
862 // Get core information.
863 StringRef Name = DTy->getName();
864 uint64_t Size = DTy->getSizeInBits() >> 3;
865 uint16_t Tag = Buffer.getTag();
866
867 // Map to main type, void will not have a type.
868 const DIType *FromTy = resolve(DTy->getBaseType());
869 if (FromTy)
870 addType(Buffer, FromTy);
871
872 // Add name if not anonymous or intermediate type.
873 if (!Name.empty())
874 addString(Buffer, dwarf::DW_AT_name, Name);
875
876 // Add size if non-zero (derived types might be zero-sized.)
877 if (Size && Tag != dwarf::DW_TAG_pointer_type
878 && Tag != dwarf::DW_TAG_ptr_to_member_type
879 && Tag != dwarf::DW_TAG_reference_type
880 && Tag != dwarf::DW_TAG_rvalue_reference_type)
881 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
882
883 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
884 addDIEEntry(
885 Buffer, dwarf::DW_AT_containing_type,
886 *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
887 // Add source line info if available and TyDesc is not a forward declaration.
888 if (!DTy->isForwardDecl())
889 addSourceLine(Buffer, DTy);
890
891 // If DWARF address space value is other than None, add it for pointer and
892 // reference types as DW_AT_address_class.
893 if (DTy->getDWARFAddressSpace() && (Tag == dwarf::DW_TAG_pointer_type ||
894 Tag == dwarf::DW_TAG_reference_type))
895 addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
896 DTy->getDWARFAddressSpace().getValue());
897}
898
899void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
900 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
901 const DIType *Ty = resolve(Args[i]);
902 if (!Ty) {
903 assert(i == N-1 && "Unspecified parameter must be the last argument")(static_cast <bool> (i == N-1 && "Unspecified parameter must be the last argument"
) ? void (0) : __assert_fail ("i == N-1 && \"Unspecified parameter must be the last argument\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 903, __extension__ __PRETTY_FUNCTION__))
;
904 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
905 } else {
906 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
907 addType(Arg, Ty);
908 if (Ty->isArtificial())
909 addFlag(Arg, dwarf::DW_AT_artificial);
910 }
911 }
912}
913
914void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
915 // Add return type. A void return won't have a type.
916 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
917 if (Elements.size())
918 if (auto RTy = resolve(Elements[0]))
919 addType(Buffer, RTy);
920
921 bool isPrototyped = true;
922 if (Elements.size() == 2 && !Elements[1])
923 isPrototyped = false;
924
925 constructSubprogramArguments(Buffer, Elements);
926
927 // Add prototype flag if we're dealing with a C language and the function has
928 // been prototyped.
929 uint16_t Language = getLanguage();
930 if (isPrototyped &&
931 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
932 Language == dwarf::DW_LANG_ObjC))
933 addFlag(Buffer, dwarf::DW_AT_prototyped);
934
935 // Add a DW_AT_calling_convention if this has an explicit convention.
936 if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
937 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
938 CTy->getCC());
939
940 if (CTy->isLValueReference())
941 addFlag(Buffer, dwarf::DW_AT_reference);
942
943 if (CTy->isRValueReference())
944 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
945}
946
947void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
948 // Add name if not anonymous or intermediate type.
949 StringRef Name = CTy->getName();
950
951 uint64_t Size = CTy->getSizeInBits() >> 3;
952 uint16_t Tag = Buffer.getTag();
953
954 switch (Tag) {
955 case dwarf::DW_TAG_array_type:
956 constructArrayTypeDIE(Buffer, CTy);
957 break;
958 case dwarf::DW_TAG_enumeration_type:
959 constructEnumTypeDIE(Buffer, CTy);
960 break;
961 case dwarf::DW_TAG_variant_part:
962 case dwarf::DW_TAG_structure_type:
963 case dwarf::DW_TAG_union_type:
964 case dwarf::DW_TAG_class_type: {
965 // Emit the discriminator for a variant part.
966 DIDerivedType *Discriminator = nullptr;
967 if (Tag == dwarf::DW_TAG_variant_part) {
968 Discriminator = CTy->getDiscriminator();
969 if (Discriminator) {
970 // DWARF says:
971 // If the variant part has a discriminant, the discriminant is
972 // represented by a separate debugging information entry which is
973 // a child of the variant part entry.
974 DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
975 addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
976 }
977 }
978
979 // Add elements to structure type.
980 DINodeArray Elements = CTy->getElements();
981 for (const auto *Element : Elements) {
982 if (!Element)
983 continue;
984 if (auto *SP = dyn_cast<DISubprogram>(Element))
985 getOrCreateSubprogramDIE(SP);
986 else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
987 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
988 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
989 addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
990 } else if (DDTy->isStaticMember()) {
991 getOrCreateStaticMemberDIE(DDTy);
992 } else if (Tag == dwarf::DW_TAG_variant_part) {
993 // When emitting a variant part, wrap each member in
994 // DW_TAG_variant.
995 DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
996 if (const ConstantInt *CI =
997 dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
998 if (isUnsignedDIType(DD, resolve(Discriminator->getBaseType())))
999 addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
1000 else
1001 addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
1002 }
1003 constructMemberDIE(Variant, DDTy);
1004 } else {
1005 constructMemberDIE(Buffer, DDTy);
1006 }
1007 } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
1008 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
1009 StringRef PropertyName = Property->getName();
1010 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1011 if (Property->getType())
1012 addType(ElemDie, resolve(Property->getType()));
1013 addSourceLine(ElemDie, Property);
1014 StringRef GetterName = Property->getGetterName();
1015 if (!GetterName.empty())
1016 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1017 StringRef SetterName = Property->getSetterName();
1018 if (!SetterName.empty())
1019 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1020 if (unsigned PropertyAttributes = Property->getAttributes())
1021 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1022 PropertyAttributes);
1023 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
1024 if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
1025 DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
1026 constructTypeDIE(VariantPart, Composite);
1027 }
1028 }
1029 }
1030
1031 if (CTy->isAppleBlockExtension())
1032 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1033
1034 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1035 // inside C++ composite types to point to the base class with the vtable.
1036 // Rust uses DW_AT_containing_type to link a vtable to the type
1037 // for which it was created.
1038 if (auto *ContainingType = resolve(CTy->getVTableHolder()))
1039 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1040 *getOrCreateTypeDIE(ContainingType));
1041
1042 if (CTy->isObjcClassComplete())
1043 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1044
1045 // Add template parameters to a class, structure or union types.
1046 // FIXME: The support isn't in the metadata for this yet.
1047 if (Tag == dwarf::DW_TAG_class_type ||
1048 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1049 addTemplateParams(Buffer, CTy->getTemplateParams());
1050
1051 // Add the type's non-standard calling convention.
1052 uint8_t CC = 0;
1053 if (CTy->isTypePassByValue())
1054 CC = dwarf::DW_CC_pass_by_value;
1055 else if (CTy->isTypePassByReference())
1056 CC = dwarf::DW_CC_pass_by_reference;
1057 if (CC)
1058 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
1059 CC);
1060 break;
1061 }
1062 default:
1063 break;
1064 }
1065
1066 // Add name if not anonymous or intermediate type.
1067 if (!Name.empty())
1068 addString(Buffer, dwarf::DW_AT_name, Name);
1069
1070 if (Tag == dwarf::DW_TAG_enumeration_type ||
1071 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1072 Tag == dwarf::DW_TAG_union_type) {
1073 // Add size if non-zero (derived types might be zero-sized.)
1074 // TODO: Do we care about size for enum forward declarations?
1075 if (Size)
1076 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1077 else if (!CTy->isForwardDecl())
1078 // Add zero size if it is not a forward declaration.
1079 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1080
1081 // If we're a forward decl, say so.
1082 if (CTy->isForwardDecl())
1083 addFlag(Buffer, dwarf::DW_AT_declaration);
1084
1085 // Add source line info if available.
1086 if (!CTy->isForwardDecl())
1087 addSourceLine(Buffer, CTy);
1088
1089 // No harm in adding the runtime language to the declaration.
1090 unsigned RLang = CTy->getRuntimeLang();
1091 if (RLang)
1092 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1093 RLang);
1094
1095 // Add align info if available.
1096 if (uint32_t AlignInBytes = CTy->getAlignInBytes())
1097 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1098 AlignInBytes);
1099 }
1100}
1101
1102void DwarfUnit::constructTemplateTypeParameterDIE(
1103 DIE &Buffer, const DITemplateTypeParameter *TP) {
1104 DIE &ParamDIE =
1105 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1106 // Add the type if it exists, it could be void and therefore no type.
1107 if (TP->getType())
1108 addType(ParamDIE, resolve(TP->getType()));
1109 if (!TP->getName().empty())
1110 addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1111}
1112
1113void DwarfUnit::constructTemplateValueParameterDIE(
1114 DIE &Buffer, const DITemplateValueParameter *VP) {
1115 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1116
1117 // Add the type if there is one, template template and template parameter
1118 // packs will not have a type.
1119 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1120 addType(ParamDIE, resolve(VP->getType()));
1121 if (!VP->getName().empty())
1122 addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1123 if (Metadata *Val = VP->getValue()) {
1124 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1125 addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1126 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1127 // We cannot describe the location of dllimport'd entities: the
1128 // computation of their address requires loads from the IAT.
1129 if (!GV->hasDLLImportStorageClass()) {
1130 // For declaration non-type template parameters (such as global values
1131 // and functions)
1132 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1133 addOpAddress(*Loc, Asm->getSymbol(GV));
1134 // Emit DW_OP_stack_value to use the address as the immediate value of
1135 // the parameter, rather than a pointer to it.
1136 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1137 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1138 }
1139 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1140 assert(isa<MDString>(Val))(static_cast <bool> (isa<MDString>(Val)) ? void (
0) : __assert_fail ("isa<MDString>(Val)", "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1140, __extension__ __PRETTY_FUNCTION__))
;
1141 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1142 cast<MDString>(Val)->getString());
1143 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1144 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1145 }
1146 }
1147}
1148
1149DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1150 // Construct the context before querying for the existence of the DIE in case
1151 // such construction creates the DIE.
1152 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1153
1154 if (DIE *NDie = getDIE(NS))
1155 return NDie;
1156 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1157
1158 StringRef Name = NS->getName();
1159 if (!Name.empty())
1160 addString(NDie, dwarf::DW_AT_name, NS->getName());
1161 else
1162 Name = "(anonymous namespace)";
1163 DD->addAccelNamespace(Name, NDie);
1164 addGlobalName(Name, NDie, NS->getScope());
1165 if (NS->getExportSymbols())
1166 addFlag(NDie, dwarf::DW_AT_export_symbols);
1167 return &NDie;
1168}
1169
1170DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1171 // Construct the context before querying for the existence of the DIE in case
1172 // such construction creates the DIE.
1173 DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1174
1175 if (DIE *MDie = getDIE(M))
1176 return MDie;
1177 DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1178
1179 if (!M->getName().empty()) {
1180 addString(MDie, dwarf::DW_AT_name, M->getName());
1181 addGlobalName(M->getName(), MDie, M->getScope());
1182 }
1183 if (!M->getConfigurationMacros().empty())
1184 addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1185 M->getConfigurationMacros());
1186 if (!M->getIncludePath().empty())
1187 addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1188 if (!M->getISysRoot().empty())
1189 addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1190
1191 return &MDie;
1192}
1193
1194DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1195 // Construct the context before querying for the existence of the DIE in case
1196 // such construction creates the DIE (as is the case for member function
1197 // declarations).
1198 DIE *ContextDIE =
1199 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1200
1201 if (DIE *SPDie = getDIE(SP))
1202 return SPDie;
1203
1204 if (auto *SPDecl = SP->getDeclaration()) {
1205 if (!Minimal) {
1206 // Add subprogram definitions to the CU die directly.
1207 ContextDIE = &getUnitDie();
1208 // Build the decl now to ensure it precedes the definition.
1209 getOrCreateSubprogramDIE(SPDecl);
1210 }
1211 }
1212
1213 // DW_TAG_inlined_subroutine may refer to this DIE.
1214 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1215
1216 // Stop here and fill this in later, depending on whether or not this
1217 // subprogram turns out to have inlined instances or not.
1218 if (SP->isDefinition())
1219 return &SPDie;
1220
1221 applySubprogramAttributes(SP, SPDie);
1222 return &SPDie;
1223}
1224
1225bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1226 DIE &SPDie) {
1227 DIE *DeclDie = nullptr;
1228 StringRef DeclLinkageName;
1229 if (auto *SPDecl = SP->getDeclaration()) {
1230 DeclDie = getDIE(SPDecl);
1231 assert(DeclDie && "This DIE should've already been constructed when the "(static_cast <bool> (DeclDie && "This DIE should've already been constructed when the "
"definition DIE was created in " "getOrCreateSubprogramDIE")
? void (0) : __assert_fail ("DeclDie && \"This DIE should've already been constructed when the \" \"definition DIE was created in \" \"getOrCreateSubprogramDIE\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1233, __extension__ __PRETTY_FUNCTION__))
1232 "definition DIE was created in "(static_cast <bool> (DeclDie && "This DIE should've already been constructed when the "
"definition DIE was created in " "getOrCreateSubprogramDIE")
? void (0) : __assert_fail ("DeclDie && \"This DIE should've already been constructed when the \" \"definition DIE was created in \" \"getOrCreateSubprogramDIE\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1233, __extension__ __PRETTY_FUNCTION__))
1233 "getOrCreateSubprogramDIE")(static_cast <bool> (DeclDie && "This DIE should've already been constructed when the "
"definition DIE was created in " "getOrCreateSubprogramDIE")
? void (0) : __assert_fail ("DeclDie && \"This DIE should've already been constructed when the \" \"definition DIE was created in \" \"getOrCreateSubprogramDIE\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1233, __extension__ __PRETTY_FUNCTION__))
;
1234 // Look at the Decl's linkage name only if we emitted it.
1235 if (DD->useAllLinkageNames())
1236 DeclLinkageName = SPDecl->getLinkageName();
1237 unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1238 unsigned DefID = getOrCreateSourceID(SP->getFile());
1239 if (DeclID != DefID)
1240 addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1241
1242 if (SP->getLine() != SPDecl->getLine())
1243 addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1244 }
1245
1246 // Add function template parameters.
1247 addTemplateParams(SPDie, SP->getTemplateParams());
1248
1249 // Add the linkage name if we have one and it isn't in the Decl.
1250 StringRef LinkageName = SP->getLinkageName();
1251 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||(static_cast <bool> (((LinkageName.empty() || DeclLinkageName
.empty()) || LinkageName == DeclLinkageName) && "decl has a linkage name and it is different"
) ? void (0) : __assert_fail ("((LinkageName.empty() || DeclLinkageName.empty()) || LinkageName == DeclLinkageName) && \"decl has a linkage name and it is different\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1253, __extension__ __PRETTY_FUNCTION__))
1252 LinkageName == DeclLinkageName) &&(static_cast <bool> (((LinkageName.empty() || DeclLinkageName
.empty()) || LinkageName == DeclLinkageName) && "decl has a linkage name and it is different"
) ? void (0) : __assert_fail ("((LinkageName.empty() || DeclLinkageName.empty()) || LinkageName == DeclLinkageName) && \"decl has a linkage name and it is different\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1253, __extension__ __PRETTY_FUNCTION__))
1253 "decl has a linkage name and it is different")(static_cast <bool> (((LinkageName.empty() || DeclLinkageName
.empty()) || LinkageName == DeclLinkageName) && "decl has a linkage name and it is different"
) ? void (0) : __assert_fail ("((LinkageName.empty() || DeclLinkageName.empty()) || LinkageName == DeclLinkageName) && \"decl has a linkage name and it is different\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1253, __extension__ __PRETTY_FUNCTION__))
;
1254 if (DeclLinkageName.empty() &&
1255 // Always emit it for abstract subprograms.
1256 (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1257 addLinkageName(SPDie, LinkageName);
1258
1259 if (!DeclDie)
1260 return false;
1261
1262 // Refer to the function declaration where all the other attributes will be
1263 // found.
1264 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1265 return true;
1266}
1267
1268void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1269 bool SkipSPAttributes) {
1270 // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1271 // and its source location.
1272 bool SkipSPSourceLocation = SkipSPAttributes &&
1273 !CUNode->getDebugInfoForProfiling();
1274 if (!SkipSPSourceLocation)
1275 if (applySubprogramDefinitionAttributes(SP, SPDie))
1276 return;
1277
1278 // Constructors and operators for anonymous aggregates do not have names.
1279 if (!SP->getName().empty())
1280 addString(SPDie, dwarf::DW_AT_name, SP->getName());
1281
1282 if (!SkipSPSourceLocation)
1283 addSourceLine(SPDie, SP);
1284
1285 // Skip the rest of the attributes under -gmlt to save space.
1286 if (SkipSPAttributes)
1287 return;
1288
1289 // Add the prototype if we have a prototype and we have a C like
1290 // language.
1291 uint16_t Language = getLanguage();
1292 if (SP->isPrototyped() &&
1293 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1294 Language == dwarf::DW_LANG_ObjC))
1295 addFlag(SPDie, dwarf::DW_AT_prototyped);
1296
1297 unsigned CC = 0;
1298 DITypeRefArray Args;
1299 if (const DISubroutineType *SPTy = SP->getType()) {
1300 Args = SPTy->getTypeArray();
1301 CC = SPTy->getCC();
1302 }
1303
1304 // Add a DW_AT_calling_convention if this has an explicit convention.
1305 if (CC && CC != dwarf::DW_CC_normal)
1306 addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1307
1308 // Add a return type. If this is a type like a C/C++ void type we don't add a
1309 // return type.
1310 if (Args.size())
1311 if (auto Ty = resolve(Args[0]))
1312 addType(SPDie, Ty);
1313
1314 unsigned VK = SP->getVirtuality();
1315 if (VK) {
1316 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1317 if (SP->getVirtualIndex() != -1u) {
1318 DIELoc *Block = getDIELoc();
1319 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1320 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1321 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1322 }
1323 ContainingTypeMap.insert(
1324 std::make_pair(&SPDie, resolve(SP->getContainingType())));
1325 }
1326
1327 if (!SP->isDefinition()) {
1328 addFlag(SPDie, dwarf::DW_AT_declaration);
1329
1330 // Add arguments. Do not add arguments for subprogram definition. They will
1331 // be handled while processing variables.
1332 constructSubprogramArguments(SPDie, Args);
1333 }
1334
1335 addThrownTypes(SPDie, SP->getThrownTypes());
1336
1337 if (SP->isArtificial())
1338 addFlag(SPDie, dwarf::DW_AT_artificial);
1339
1340 if (!SP->isLocalToUnit())
1341 addFlag(SPDie, dwarf::DW_AT_external);
1342
1343 if (DD->useAppleExtensionAttributes()) {
1344 if (SP->isOptimized())
1345 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1346
1347 if (unsigned isa = Asm->getISAEncoding())
1348 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1349 }
1350
1351 if (SP->isLValueReference())
1352 addFlag(SPDie, dwarf::DW_AT_reference);
1353
1354 if (SP->isRValueReference())
1355 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1356
1357 if (SP->isNoReturn())
1358 addFlag(SPDie, dwarf::DW_AT_noreturn);
1359
1360 if (SP->isProtected())
1361 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1362 dwarf::DW_ACCESS_protected);
1363 else if (SP->isPrivate())
1364 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1365 dwarf::DW_ACCESS_private);
1366 else if (SP->isPublic())
1367 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1368 dwarf::DW_ACCESS_public);
1369
1370 if (SP->isExplicit())
1371 addFlag(SPDie, dwarf::DW_AT_explicit);
1372
1373 if (SP->isMainSubprogram())
1374 addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1375}
1376
1377void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1378 DIE *IndexTy) {
1379 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1380 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1381
1382 // The LowerBound value defines the lower bounds which is typically zero for
1383 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1384 // Count == -1 then the array is unbounded and we do not emit
1385 // DW_AT_lower_bound and DW_AT_count attributes.
1386 int64_t LowerBound = SR->getLowerBound();
1387 int64_t DefaultLowerBound = getDefaultLowerBound();
1388 int64_t Count = -1;
1389 if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
1390 Count = CI->getSExtValue();
1391
1392 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1393 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1394
1395 if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
1396 if (auto *CountVarDIE = getDIE(CV))
1397 addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE);
1398 } else if (Count != -1)
1399 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1400}
1401
1402DIE *DwarfUnit::getIndexTyDie() {
1403 if (IndexTyDie)
1404 return IndexTyDie;
1405 // Construct an integer type to use for indexes.
1406 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1407 StringRef Name = "__ARRAY_SIZE_TYPE__";
1408 addString(*IndexTyDie, dwarf::DW_AT_name, Name);
1409 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1410 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1411 dwarf::DW_ATE_unsigned);
1412 DD->addAccelType(Name, *IndexTyDie, /*Flags*/ 0);
1413 return IndexTyDie;
1414}
1415
1416/// Returns true if the vector's size differs from the sum of sizes of elements
1417/// the user specified. This can occur if the vector has been rounded up to
1418/// fit memory alignment constraints.
1419static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1420 assert(CTy && CTy->isVector() && "Composite type is not a vector")(static_cast <bool> (CTy && CTy->isVector() &&
"Composite type is not a vector") ? void (0) : __assert_fail
("CTy && CTy->isVector() && \"Composite type is not a vector\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__))
;
1421 const uint64_t ActualSize = CTy->getSizeInBits();
1422
1423 // Obtain the size of each element in the vector.
1424 DIType *BaseTy = CTy->getBaseType().resolve();
1425 assert(BaseTy && "Unknown vector element type.")(static_cast <bool> (BaseTy && "Unknown vector element type."
) ? void (0) : __assert_fail ("BaseTy && \"Unknown vector element type.\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1425, __extension__ __PRETTY_FUNCTION__))
;
1426 const uint64_t ElementSize = BaseTy->getSizeInBits();
1427
1428 // Locate the number of elements in the vector.
1429 const DINodeArray Elements = CTy->getElements();
1430 assert(Elements.size() == 1 &&(static_cast <bool> (Elements.size() == 1 && Elements
[0]->getTag() == dwarf::DW_TAG_subrange_type && "Invalid vector element array, expected one element of type subrange"
) ? void (0) : __assert_fail ("Elements.size() == 1 && Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && \"Invalid vector element array, expected one element of type subrange\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1432, __extension__ __PRETTY_FUNCTION__))
1431 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&(static_cast <bool> (Elements.size() == 1 && Elements
[0]->getTag() == dwarf::DW_TAG_subrange_type && "Invalid vector element array, expected one element of type subrange"
) ? void (0) : __assert_fail ("Elements.size() == 1 && Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && \"Invalid vector element array, expected one element of type subrange\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1432, __extension__ __PRETTY_FUNCTION__))
1432 "Invalid vector element array, expected one element of type subrange")(static_cast <bool> (Elements.size() == 1 && Elements
[0]->getTag() == dwarf::DW_TAG_subrange_type && "Invalid vector element array, expected one element of type subrange"
) ? void (0) : __assert_fail ("Elements.size() == 1 && Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && \"Invalid vector element array, expected one element of type subrange\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1432, __extension__ __PRETTY_FUNCTION__))
;
1433 const auto Subrange = cast<DISubrange>(Elements[0]);
1434 const auto CI = Subrange->getCount().get<ConstantInt *>();
1435 const int32_t NumVecElements = CI->getSExtValue();
1436
1437 // Ensure we found the element count and that the actual size is wide
1438 // enough to contain the requested size.
1439 assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size")(static_cast <bool> (ActualSize >= (NumVecElements *
ElementSize) && "Invalid vector size") ? void (0) : __assert_fail
("ActualSize >= (NumVecElements * ElementSize) && \"Invalid vector size\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1439, __extension__ __PRETTY_FUNCTION__))
;
1440 return ActualSize != (NumVecElements * ElementSize);
1441}
1442
1443void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1444 if (CTy->isVector()) {
1445 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1446 if (hasVectorBeenPadded(CTy))
1447 addUInt(Buffer, dwarf::DW_AT_byte_size, None,
1448 CTy->getSizeInBits() / CHAR_BIT8);
1449 }
1450
1451 // Emit the element type.
1452 addType(Buffer, resolve(CTy->getBaseType()));
1453
1454 // Get an anonymous type for index type.
1455 // FIXME: This type should be passed down from the front end
1456 // as different languages may have different sizes for indexes.
1457 DIE *IdxTy = getIndexTyDie();
1458
1459 // Add subranges to array type.
1460 DINodeArray Elements = CTy->getElements();
1461 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1462 // FIXME: Should this really be such a loose cast?
1463 if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1464 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1465 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1466 }
1467}
1468
1469void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1470 const DIType *DTy = resolve(CTy->getBaseType());
1471 bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
1472 if (DTy) {
1473 if (DD->getDwarfVersion() >= 3)
1474 addType(Buffer, DTy);
1475 if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum))
1476 addFlag(Buffer, dwarf::DW_AT_enum_class);
1477 }
1478
1479 DINodeArray Elements = CTy->getElements();
1480
1481 // Add enumerators to enumeration type.
1482 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1483 auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1484 if (Enum) {
1485 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1486 StringRef Name = Enum->getName();
1487 addString(Enumerator, dwarf::DW_AT_name, Name);
1488 auto Value = static_cast<uint64_t>(Enum->getValue());
1489 addConstantValue(Enumerator, IsUnsigned, Value);
1490 }
1491 }
1492}
1493
1494void DwarfUnit::constructContainingTypeDIEs() {
1495 for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1496 CI != CE; ++CI) {
1497 DIE &SPDie = *CI->first;
1498 const DINode *D = CI->second;
1499 if (!D)
1500 continue;
1501 DIE *NDie = getDIE(D);
1502 if (!NDie)
1503 continue;
1504 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1505 }
1506}
1507
1508DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1509 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1510 StringRef Name = DT->getName();
1511 if (!Name.empty())
1512 addString(MemberDie, dwarf::DW_AT_name, Name);
1513
1514 if (DIType *Resolved = resolve(DT->getBaseType()))
1515 addType(MemberDie, Resolved);
1516
1517 addSourceLine(MemberDie, DT);
1518
1519 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1520
1521 // For C++, virtual base classes are not at fixed offset. Use following
1522 // expression to extract appropriate offset from vtable.
1523 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1524
1525 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1526 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1527 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1528 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1529 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1530 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1531 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1532 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1533
1534 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1535 } else {
1536 uint64_t Size = DT->getSizeInBits();
1537 uint64_t FieldSize = DD->getBaseTypeSize(DT);
1538 uint32_t AlignInBytes = DT->getAlignInBytes();
1539 uint64_t OffsetInBytes;
1540
1541 bool IsBitfield = FieldSize && Size != FieldSize;
1542 if (IsBitfield) {
1543 // Handle bitfield, assume bytes are 8 bits.
1544 if (DD->useDWARF2Bitfields())
1545 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1546 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1547
1548 uint64_t Offset = DT->getOffsetInBits();
1549 // We can't use DT->getAlignInBits() here: AlignInBits for member type
1550 // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1551 // which can't be done with bitfields. Thus we use FieldSize here.
1552 uint32_t AlignInBits = FieldSize;
1553 uint32_t AlignMask = ~(AlignInBits - 1);
1554 // The bits from the start of the storage unit to the start of the field.
1555 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1556 // The byte offset of the field's aligned storage unit inside the struct.
1557 OffsetInBytes = (Offset - StartBitOffset) / 8;
1558
1559 if (DD->useDWARF2Bitfields()) {
1560 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1561 uint64_t FieldOffset = (HiMark - FieldSize);
1562 Offset -= FieldOffset;
1563
1564 // Maybe we need to work from the other end.
1565 if (Asm->getDataLayout().isLittleEndian())
1566 Offset = FieldSize - (Offset + Size);
1567
1568 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1569 OffsetInBytes = FieldOffset >> 3;
1570 } else {
1571 addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1572 }
1573 } else {
1574 // This is not a bitfield.
1575 OffsetInBytes = DT->getOffsetInBits() / 8;
1576 if (AlignInBytes)
1577 addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1578 AlignInBytes);
1579 }
1580
1581 if (DD->getDwarfVersion() <= 2) {
1582 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1583 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1584 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1585 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1586 } else if (!IsBitfield || DD->useDWARF2Bitfields())
1587 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1588 OffsetInBytes);
1589 }
1590
1591 if (DT->isProtected())
1592 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1593 dwarf::DW_ACCESS_protected);
1594 else if (DT->isPrivate())
1595 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1596 dwarf::DW_ACCESS_private);
1597 // Otherwise C++ member and base classes are considered public.
1598 else if (DT->isPublic())
1599 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1600 dwarf::DW_ACCESS_public);
1601 if (DT->isVirtual())
1602 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1603 dwarf::DW_VIRTUALITY_virtual);
1604
1605 // Objective-C properties.
1606 if (DINode *PNode = DT->getObjCProperty())
1607 if (DIE *PDie = getDIE(PNode))
1608 MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1609 dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1610
1611 if (DT->isArtificial())
1612 addFlag(MemberDie, dwarf::DW_AT_artificial);
1613
1614 return MemberDie;
1615}
1616
1617DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1618 if (!DT)
1619 return nullptr;
1620
1621 // Construct the context before querying for the existence of the DIE in case
1622 // such construction creates the DIE.
1623 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1624 assert(dwarf::isType(ContextDIE->getTag()) &&(static_cast <bool> (dwarf::isType(ContextDIE->getTag
()) && "Static member should belong to a type.") ? void
(0) : __assert_fail ("dwarf::isType(ContextDIE->getTag()) && \"Static member should belong to a type.\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1625, __extension__ __PRETTY_FUNCTION__))
1625 "Static member should belong to a type.")(static_cast <bool> (dwarf::isType(ContextDIE->getTag
()) && "Static member should belong to a type.") ? void
(0) : __assert_fail ("dwarf::isType(ContextDIE->getTag()) && \"Static member should belong to a type.\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1625, __extension__ __PRETTY_FUNCTION__))
;
1626
1627 if (DIE *StaticMemberDIE = getDIE(DT))
1628 return StaticMemberDIE;
1629
1630 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1631
1632 const DIType *Ty = resolve(DT->getBaseType());
1633
1634 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1635 addType(StaticMemberDIE, Ty);
1636 addSourceLine(StaticMemberDIE, DT);
1637 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1638 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1639
1640 // FIXME: We could omit private if the parent is a class_type, and
1641 // public if the parent is something else.
1642 if (DT->isProtected())
1643 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1644 dwarf::DW_ACCESS_protected);
1645 else if (DT->isPrivate())
1646 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1647 dwarf::DW_ACCESS_private);
1648 else if (DT->isPublic())
1649 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1650 dwarf::DW_ACCESS_public);
1651
1652 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1653 addConstantValue(StaticMemberDIE, CI, Ty);
1654 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1655 addConstantFPValue(StaticMemberDIE, CFP);
1656
1657 if (uint32_t AlignInBytes = DT->getAlignInBytes())
1658 addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1659 AlignInBytes);
1660
1661 return &StaticMemberDIE;
1662}
1663
1664void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
1665 // Emit size of content not including length itself
1666 Asm->OutStreamer->AddComment("Length of Unit");
1667 Asm->emitInt32(getHeaderSize() + getUnitDie().getSize());
1668
1669 Asm->OutStreamer->AddComment("DWARF version number");
1670 unsigned Version = DD->getDwarfVersion();
1671 Asm->emitInt16(Version);
1672
1673 // DWARF v5 reorders the address size and adds a unit type.
1674 if (Version >= 5) {
1675 Asm->OutStreamer->AddComment("DWARF Unit Type");
1676 Asm->emitInt8(UT);
1677 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1678 Asm->emitInt8(Asm->MAI->getCodePointerSize());
1679 }
1680
1681 // We share one abbreviations table across all units so it's always at the
1682 // start of the section. Use a relocatable offset where needed to ensure
1683 // linking doesn't invalidate that offset.
1684 Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1685 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1686 if (UseOffsets)
1687 Asm->emitInt32(0);
1688 else
1689 Asm->emitDwarfSymbolReference(
1690 TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1691
1692 if (Version <= 4) {
1693 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1694 Asm->emitInt8(Asm->MAI->getCodePointerSize());
1695 }
1696}
1697
1698void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1699 DwarfUnit::emitCommonHeader(UseOffsets,
1700 DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1701 : dwarf::DW_UT_type);
1702 Asm->OutStreamer->AddComment("Type Signature");
1703 Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1704 Asm->OutStreamer->AddComment("Type DIE Offset");
1705 // In a skeleton type unit there is no type DIE so emit a zero offset.
1706 Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1707 sizeof(Ty->getOffset()));
1708}
1709
1710DIE::value_iterator
1711DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
1712 const MCSymbol *Hi, const MCSymbol *Lo) {
1713 return Die.addValue(DIEValueAllocator, Attribute,
1714 DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1715 : dwarf::DW_FORM_data4,
1716 new (DIEValueAllocator) DIEDelta(Hi, Lo));
1717}
1718
1719DIE::value_iterator
1720DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
1721 const MCSymbol *Label, const MCSymbol *Sec) {
1722 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1723 return addLabel(Die, Attribute,
1724 DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1725 : dwarf::DW_FORM_data4,
1726 Label);
1727 return addSectionDelta(Die, Attribute, Label, Sec);
1728}
1729
1730bool DwarfTypeUnit::isDwoUnit() const {
1731 // Since there are no skeleton type units, all type units are dwo type units
1732 // when split DWARF is being used.
1733 return DD->useSplitDwarf();
1734}
1735
1736void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
1737 const DIScope *Context) {
1738 getCU().addGlobalNameForTypeUnit(Name, Context);
1739}
1740
1741void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1742 const DIScope *Context) {
1743 getCU().addGlobalTypeUnitType(Ty, Context);
1744}
1745
1746const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1747 if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1748 return nullptr;
1749 if (isDwoUnit())
1750 return nullptr;
1751 return getSection()->getBeginSymbol();
1752}
1753
1754void DwarfUnit::addStringOffsetsStart() {
1755 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1756 addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1757 DU->getStringOffsetsStartSym(),
1758 TLOF.getDwarfStrOffSection()->getBeginSymbol());
1759}
1760
1761void DwarfUnit::addRnglistsBase() {
1762 assert(DD->getDwarfVersion() >= 5 &&(static_cast <bool> (DD->getDwarfVersion() >= 5 &&
"DW_AT_rnglists_base requires DWARF version 5 or later") ? void
(0) : __assert_fail ("DD->getDwarfVersion() >= 5 && \"DW_AT_rnglists_base requires DWARF version 5 or later\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1763, __extension__ __PRETTY_FUNCTION__))
1763 "DW_AT_rnglists_base requires DWARF version 5 or later")(static_cast <bool> (DD->getDwarfVersion() >= 5 &&
"DW_AT_rnglists_base requires DWARF version 5 or later") ? void
(0) : __assert_fail ("DD->getDwarfVersion() >= 5 && \"DW_AT_rnglists_base requires DWARF version 5 or later\""
, "/build/llvm-toolchain-snapshot-7~svn337204/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1763, __extension__ __PRETTY_FUNCTION__))
;
1764 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1765 addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
1766 DU->getRnglistsTableBaseSym(),
1767 TLOF.getDwarfRnglistsSection()->getBeginSymbol());
1768}