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~svn329677/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/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/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~svn329677/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-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1408 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1409 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1410 dwarf::DW_ATE_unsigned);
1411 return IndexTyDie;
1412}
1413
1414/// Returns true if the vector's size differs from the sum of sizes of elements
1415/// the user specified. This can occur if the vector has been rounded up to
1416/// fit memory alignment constraints.
1417static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1418 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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1418, __extension__ __PRETTY_FUNCTION__))
;
1419 const uint64_t ActualSize = CTy->getSizeInBits();
1420
1421 // Obtain the size of each element in the vector.
1422 DIType *BaseTy = CTy->getBaseType().resolve();
1423 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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1423, __extension__ __PRETTY_FUNCTION__))
;
1424 const uint64_t ElementSize = BaseTy->getSizeInBits();
1425
1426 // Locate the number of elements in the vector.
1427 const DINodeArray Elements = CTy->getElements();
1428 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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1430, __extension__ __PRETTY_FUNCTION__))
1429 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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1430, __extension__ __PRETTY_FUNCTION__))
1430 "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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1430, __extension__ __PRETTY_FUNCTION__))
;
1431 const auto Subrange = cast<DISubrange>(Elements[0]);
1432 const auto CI = Subrange->getCount().get<ConstantInt *>();
1433 const int32_t NumVecElements = CI->getSExtValue();
1434
1435 // Ensure we found the element count and that the actual size is wide
1436 // enough to contain the requested size.
1437 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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1437, __extension__ __PRETTY_FUNCTION__))
;
1438 return ActualSize != (NumVecElements * ElementSize);
1439}
1440
1441void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1442 if (CTy->isVector()) {
1443 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1444 if (hasVectorBeenPadded(CTy))
1445 addUInt(Buffer, dwarf::DW_AT_byte_size, None,
1446 CTy->getSizeInBits() / CHAR_BIT8);
1447 }
1448
1449 // Emit the element type.
1450 addType(Buffer, resolve(CTy->getBaseType()));
1451
1452 // Get an anonymous type for index type.
1453 // FIXME: This type should be passed down from the front end
1454 // as different languages may have different sizes for indexes.
1455 DIE *IdxTy = getIndexTyDie();
1456
1457 // Add subranges to array type.
1458 DINodeArray Elements = CTy->getElements();
1459 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1460 // FIXME: Should this really be such a loose cast?
1461 if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1462 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1463 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1464 }
1465}
1466
1467void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1468 const DIType *DTy = resolve(CTy->getBaseType());
1469 bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
1470 if (DTy) {
1471 if (DD->getDwarfVersion() >= 3)
1472 addType(Buffer, DTy);
1473 if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum))
1474 addFlag(Buffer, dwarf::DW_AT_enum_class);
1475 }
1476
1477 DINodeArray Elements = CTy->getElements();
1478
1479 // Add enumerators to enumeration type.
1480 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1481 auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1482 if (Enum) {
1483 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1484 StringRef Name = Enum->getName();
1485 addString(Enumerator, dwarf::DW_AT_name, Name);
1486 auto Value = static_cast<uint64_t>(Enum->getValue());
1487 addConstantValue(Enumerator, IsUnsigned, Value);
1488 }
1489 }
1490}
1491
1492void DwarfUnit::constructContainingTypeDIEs() {
1493 for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1494 CI != CE; ++CI) {
1495 DIE &SPDie = *CI->first;
1496 const DINode *D = CI->second;
1497 if (!D)
1498 continue;
1499 DIE *NDie = getDIE(D);
1500 if (!NDie)
1501 continue;
1502 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1503 }
1504}
1505
1506DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1507 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1508 StringRef Name = DT->getName();
1509 if (!Name.empty())
1510 addString(MemberDie, dwarf::DW_AT_name, Name);
1511
1512 if (DIType *Resolved = resolve(DT->getBaseType()))
1513 addType(MemberDie, Resolved);
1514
1515 addSourceLine(MemberDie, DT);
1516
1517 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1518
1519 // For C++, virtual base classes are not at fixed offset. Use following
1520 // expression to extract appropriate offset from vtable.
1521 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1522
1523 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1524 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1525 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1526 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1527 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1528 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1529 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1530 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1531
1532 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1533 } else {
1534 uint64_t Size = DT->getSizeInBits();
1535 uint64_t FieldSize = DD->getBaseTypeSize(DT);
1536 uint32_t AlignInBytes = DT->getAlignInBytes();
1537 uint64_t OffsetInBytes;
1538
1539 bool IsBitfield = FieldSize && Size != FieldSize;
1540 if (IsBitfield) {
1541 // Handle bitfield, assume bytes are 8 bits.
1542 if (DD->useDWARF2Bitfields())
1543 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1544 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1545
1546 uint64_t Offset = DT->getOffsetInBits();
1547 // We can't use DT->getAlignInBits() here: AlignInBits for member type
1548 // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1549 // which can't be done with bitfields. Thus we use FieldSize here.
1550 uint32_t AlignInBits = FieldSize;
1551 uint32_t AlignMask = ~(AlignInBits - 1);
1552 // The bits from the start of the storage unit to the start of the field.
1553 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1554 // The byte offset of the field's aligned storage unit inside the struct.
1555 OffsetInBytes = (Offset - StartBitOffset) / 8;
1556
1557 if (DD->useDWARF2Bitfields()) {
1558 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1559 uint64_t FieldOffset = (HiMark - FieldSize);
1560 Offset -= FieldOffset;
1561
1562 // Maybe we need to work from the other end.
1563 if (Asm->getDataLayout().isLittleEndian())
1564 Offset = FieldSize - (Offset + Size);
1565
1566 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1567 OffsetInBytes = FieldOffset >> 3;
1568 } else {
1569 addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1570 }
1571 } else {
1572 // This is not a bitfield.
1573 OffsetInBytes = DT->getOffsetInBits() / 8;
1574 if (AlignInBytes)
1575 addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1576 AlignInBytes);
1577 }
1578
1579 if (DD->getDwarfVersion() <= 2) {
1580 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1581 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1582 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1583 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1584 } else if (!IsBitfield || DD->useDWARF2Bitfields())
1585 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1586 OffsetInBytes);
1587 }
1588
1589 if (DT->isProtected())
1590 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1591 dwarf::DW_ACCESS_protected);
1592 else if (DT->isPrivate())
1593 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1594 dwarf::DW_ACCESS_private);
1595 // Otherwise C++ member and base classes are considered public.
1596 else if (DT->isPublic())
1597 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1598 dwarf::DW_ACCESS_public);
1599 if (DT->isVirtual())
1600 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1601 dwarf::DW_VIRTUALITY_virtual);
1602
1603 // Objective-C properties.
1604 if (DINode *PNode = DT->getObjCProperty())
1605 if (DIE *PDie = getDIE(PNode))
1606 MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1607 dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1608
1609 if (DT->isArtificial())
1610 addFlag(MemberDie, dwarf::DW_AT_artificial);
1611
1612 return MemberDie;
1613}
1614
1615DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1616 if (!DT)
1617 return nullptr;
1618
1619 // Construct the context before querying for the existence of the DIE in case
1620 // such construction creates the DIE.
1621 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1622 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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1623, __extension__ __PRETTY_FUNCTION__))
1623 "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~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp"
, 1623, __extension__ __PRETTY_FUNCTION__))
;
1624
1625 if (DIE *StaticMemberDIE = getDIE(DT))
1626 return StaticMemberDIE;
1627
1628 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1629
1630 const DIType *Ty = resolve(DT->getBaseType());
1631
1632 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1633 addType(StaticMemberDIE, Ty);
1634 addSourceLine(StaticMemberDIE, DT);
1635 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1636 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1637
1638 // FIXME: We could omit private if the parent is a class_type, and
1639 // public if the parent is something else.
1640 if (DT->isProtected())
1641 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1642 dwarf::DW_ACCESS_protected);
1643 else if (DT->isPrivate())
1644 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1645 dwarf::DW_ACCESS_private);
1646 else if (DT->isPublic())
1647 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1648 dwarf::DW_ACCESS_public);
1649
1650 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1651 addConstantValue(StaticMemberDIE, CI, Ty);
1652 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1653 addConstantFPValue(StaticMemberDIE, CFP);
1654
1655 if (uint32_t AlignInBytes = DT->getAlignInBytes())
1656 addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1657 AlignInBytes);
1658
1659 return &StaticMemberDIE;
1660}
1661
1662void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
1663 // Emit size of content not including length itself
1664 Asm->OutStreamer->AddComment("Length of Unit");
1665 Asm->emitInt32(getHeaderSize() + getUnitDie().getSize());
1666
1667 Asm->OutStreamer->AddComment("DWARF version number");
1668 unsigned Version = DD->getDwarfVersion();
1669 Asm->emitInt16(Version);
1670
1671 // DWARF v5 reorders the address size and adds a unit type.
1672 if (Version >= 5) {
1673 Asm->OutStreamer->AddComment("DWARF Unit Type");
1674 Asm->emitInt8(UT);
1675 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1676 Asm->emitInt8(Asm->MAI->getCodePointerSize());
1677 }
1678
1679 // We share one abbreviations table across all units so it's always at the
1680 // start of the section. Use a relocatable offset where needed to ensure
1681 // linking doesn't invalidate that offset.
1682 Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1683 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1684 if (UseOffsets)
1685 Asm->emitInt32(0);
1686 else
1687 Asm->emitDwarfSymbolReference(
1688 TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1689
1690 if (Version <= 4) {
1691 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1692 Asm->emitInt8(Asm->MAI->getCodePointerSize());
1693 }
1694}
1695
1696void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1697 DwarfUnit::emitCommonHeader(UseOffsets,
1698 DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1699 : dwarf::DW_UT_type);
1700 Asm->OutStreamer->AddComment("Type Signature");
1701 Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1702 Asm->OutStreamer->AddComment("Type DIE Offset");
1703 // In a skeleton type unit there is no type DIE so emit a zero offset.
1704 Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1705 sizeof(Ty->getOffset()));
1706}
1707
1708DIE::value_iterator
1709DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
1710 const MCSymbol *Hi, const MCSymbol *Lo) {
1711 return Die.addValue(DIEValueAllocator, Attribute,
1712 DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1713 : dwarf::DW_FORM_data4,
1714 new (DIEValueAllocator) DIEDelta(Hi, Lo));
1715}
1716
1717DIE::value_iterator
1718DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
1719 const MCSymbol *Label, const MCSymbol *Sec) {
1720 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1721 return addLabel(Die, Attribute,
1722 DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1723 : dwarf::DW_FORM_data4,
1724 Label);
1725 return addSectionDelta(Die, Attribute, Label, Sec);
1726}
1727
1728bool DwarfTypeUnit::isDwoUnit() const {
1729 // Since there are no skeleton type units, all type units are dwo type units
1730 // when split DWARF is being used.
1731 return DD->useSplitDwarf();
1732}
1733
1734void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
1735 const DIScope *Context) {
1736 getCU().addGlobalNameForTypeUnit(Name, Context);
1737}
1738
1739void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1740 const DIScope *Context) {
1741 getCU().addGlobalTypeUnitType(Ty, Context);
1742}
1743
1744const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1745 if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1746 return nullptr;
1747 if (isDwoUnit())
1748 return nullptr;
1749 return getSection()->getBeginSymbol();
1750}
1751
1752void DwarfUnit::addStringOffsetsStart() {
1753 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1754 addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1755 DU->getStringOffsetsStartSym(),
1756 TLOF.getDwarfStrOffSection()->getBeginSymbol());
1757}