Bug Summary

File:lib/CodeGen/AsmPrinter/DwarfUnit.cpp
Warning:line 641, column 5
Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name 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~svn325118/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn325118/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn325118/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn325118/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~svn325118/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-02-14-150435-17243-1 -x c++ /build/llvm-toolchain-snapshot-7~svn325118/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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

/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h

1//===- lib/CodeGen/DIE.h - DWARF Info Entries -------------------*- C++ -*-===//
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// Data structures for DWARF info entries.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
15#define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
16
17#include "llvm/ADT/FoldingSet.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/ADT/PointerUnion.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/BinaryFormat/Dwarf.h"
25#include "llvm/CodeGen/DwarfStringPoolEntry.h"
26#include "llvm/Support/AlignOf.h"
27#include "llvm/Support/Allocator.h"
28#include <cassert>
29#include <cstddef>
30#include <cstdint>
31#include <iterator>
32#include <new>
33#include <type_traits>
34#include <utility>
35#include <vector>
36
37namespace llvm {
38
39class AsmPrinter;
40class DIE;
41class DIEUnit;
42class MCExpr;
43class MCSection;
44class MCSymbol;
45class raw_ostream;
46
47//===--------------------------------------------------------------------===//
48/// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.
49class DIEAbbrevData {
50 /// Dwarf attribute code.
51 dwarf::Attribute Attribute;
52
53 /// Dwarf form code.
54 dwarf::Form Form;
55
56 /// Dwarf attribute value for DW_FORM_implicit_const
57 int64_t Value = 0;
58
59public:
60 DIEAbbrevData(dwarf::Attribute A, dwarf::Form F)
61 : Attribute(A), Form(F) {}
62 DIEAbbrevData(dwarf::Attribute A, int64_t V)
63 : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}
64
65 /// Accessors.
66 /// @{
67 dwarf::Attribute getAttribute() const { return Attribute; }
68 dwarf::Form getForm() const { return Form; }
69 int64_t getValue() const { return Value; }
70 /// @}
71
72 /// Used to gather unique data for the abbreviation folding set.
73 void Profile(FoldingSetNodeID &ID) const;
74};
75
76//===--------------------------------------------------------------------===//
77/// Dwarf abbreviation, describes the organization of a debug information
78/// object.
79class DIEAbbrev : public FoldingSetNode {
80 /// Unique number for node.
81 unsigned Number;
82
83 /// Dwarf tag code.
84 dwarf::Tag Tag;
85
86 /// Whether or not this node has children.
87 ///
88 /// This cheats a bit in all of the uses since the values in the standard
89 /// are 0 and 1 for no children and children respectively.
90 bool Children;
91
92 /// Raw data bytes for abbreviation.
93 SmallVector<DIEAbbrevData, 12> Data;
94
95public:
96 DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}
97
98 /// Accessors.
99 /// @{
100 dwarf::Tag getTag() const { return Tag; }
101 unsigned getNumber() const { return Number; }
102 bool hasChildren() const { return Children; }
103 const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
104 void setChildrenFlag(bool hasChild) { Children = hasChild; }
105 void setNumber(unsigned N) { Number = N; }
106 /// @}
107
108 /// Adds another set of attribute information to the abbreviation.
109 void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
110 Data.push_back(DIEAbbrevData(Attribute, Form));
111 }
112
113 /// Adds attribute with DW_FORM_implicit_const value
114 void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
115 Data.push_back(DIEAbbrevData(Attribute, Value));
116 }
117
118 /// Used to gather unique data for the abbreviation folding set.
119 void Profile(FoldingSetNodeID &ID) const;
120
121 /// Print the abbreviation using the specified asm printer.
122 void Emit(const AsmPrinter *AP) const;
123
124 void print(raw_ostream &O) const;
125 void dump() const;
126};
127
128//===--------------------------------------------------------------------===//
129/// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
130///
131/// This class will unique the DIE abbreviations for a llvm::DIE object and
132/// assign a unique abbreviation number to each unique DIEAbbrev object it
133/// finds. The resulting collection of DIEAbbrev objects can then be emitted
134/// into the .debug_abbrev section.
135class DIEAbbrevSet {
136 /// The bump allocator to use when creating DIEAbbrev objects in the uniqued
137 /// storage container.
138 BumpPtrAllocator &Alloc;
139 /// \brief FoldingSet that uniques the abbreviations.
140 FoldingSet<DIEAbbrev> AbbreviationsSet;
141 /// A list of all the unique abbreviations in use.
142 std::vector<DIEAbbrev *> Abbreviations;
143
144public:
145 DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {}
146 ~DIEAbbrevSet();
147
148 /// Generate the abbreviation declaration for a DIE and return a pointer to
149 /// the generated abbreviation.
150 ///
151 /// \param Die the debug info entry to generate the abbreviation for.
152 /// \returns A reference to the uniqued abbreviation declaration that is
153 /// owned by this class.
154 DIEAbbrev &uniqueAbbreviation(DIE &Die);
155
156 /// Print all abbreviations using the specified asm printer.
157 void Emit(const AsmPrinter *AP, MCSection *Section) const;
158};
159
160//===--------------------------------------------------------------------===//
161/// An integer value DIE.
162///
163class DIEInteger {
164 uint64_t Integer;
165
166public:
167 explicit DIEInteger(uint64_t I) : Integer(I) {}
168
169 /// Choose the best form for integer.
170 static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
171 if (IsSigned) {
172 const int64_t SignedInt = Int;
173 if ((char)Int == SignedInt)
174 return dwarf::DW_FORM_data1;
175 if ((short)Int == SignedInt)
176 return dwarf::DW_FORM_data2;
177 if ((int)Int == SignedInt)
178 return dwarf::DW_FORM_data4;
179 } else {
180 if ((unsigned char)Int == Int)
181 return dwarf::DW_FORM_data1;
182 if ((unsigned short)Int == Int)
183 return dwarf::DW_FORM_data2;
184 if ((unsigned int)Int == Int)
185 return dwarf::DW_FORM_data4;
186 }
187 return dwarf::DW_FORM_data8;
188 }
189
190 uint64_t getValue() const { return Integer; }
191 void setValue(uint64_t Val) { Integer = Val; }
192
193 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
194 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
195
196 void print(raw_ostream &O) const;
197};
198
199//===--------------------------------------------------------------------===//
200/// An expression DIE.
201class DIEExpr {
202 const MCExpr *Expr;
203
204public:
205 explicit DIEExpr(const MCExpr *E) : Expr(E) {}
206
207 /// Get MCExpr.
208 const MCExpr *getValue() const { return Expr; }
209
210 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
211 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
212
213 void print(raw_ostream &O) const;
214};
215
216//===--------------------------------------------------------------------===//
217/// A label DIE.
218class DIELabel {
219 const MCSymbol *Label;
220
221public:
222 explicit DIELabel(const MCSymbol *L) : Label(L) {}
223
224 /// Get MCSymbol.
225 const MCSymbol *getValue() const { return Label; }
226
227 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
228 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
229
230 void print(raw_ostream &O) const;
231};
232
233//===--------------------------------------------------------------------===//
234/// A simple label difference DIE.
235///
236class DIEDelta {
237 const MCSymbol *LabelHi;
238 const MCSymbol *LabelLo;
239
240public:
241 DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
242
243 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
244 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
245
246 void print(raw_ostream &O) const;
247};
248
249//===--------------------------------------------------------------------===//
250/// A container for string pool string values.
251///
252/// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.
253class DIEString {
254 DwarfStringPoolEntryRef S;
255
256public:
257 DIEString(DwarfStringPoolEntryRef S) : S(S) {}
258
259 /// Grab the string out of the object.
260 StringRef getString() const { return S.getString(); }
261
262 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
263 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
264
265 void print(raw_ostream &O) const;
266};
267
268//===--------------------------------------------------------------------===//
269/// A container for inline string values.
270///
271/// This class is used with the DW_FORM_string form.
272class DIEInlineString {
273 StringRef S;
274
275public:
276 template <typename Allocator>
277 explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}
278
279 ~DIEInlineString() = default;
280
281 /// Grab the string out of the object.
282 StringRef getString() const { return S; }
283
284 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
285 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
286
287 void print(raw_ostream &O) const;
288};
289
290//===--------------------------------------------------------------------===//
291/// A pointer to another debug information entry. An instance of this class can
292/// also be used as a proxy for a debug information entry not yet defined
293/// (ie. types.)
294class DIEEntry {
295 DIE *Entry;
296
297public:
298 DIEEntry() = delete;
299 explicit DIEEntry(DIE &E) : Entry(&E) {}
300
301 DIE &getEntry() const { return *Entry; }
302
303 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
304 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
305
306 void print(raw_ostream &O) const;
307};
308
309//===--------------------------------------------------------------------===//
310/// Represents a pointer to a location list in the debug_loc
311/// section.
312class DIELocList {
313 /// Index into the .debug_loc vector.
314 size_t Index;
315
316public:
317 DIELocList(size_t I) : Index(I) {}
318
319 /// Grab the current index out.
320 size_t getValue() const { return Index; }
321
322 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
323 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
324
325 void print(raw_ostream &O) const;
326};
327
328//===--------------------------------------------------------------------===//
329/// A debug information entry value. Some of these roughly correlate
330/// to DWARF attribute classes.
331class DIEBlock;
332class DIELoc;
333class DIEValue {
334public:
335 enum Type {
336 isNone,
337#define HANDLE_DIEVALUE(T) is##T,
338#include "llvm/CodeGen/DIEValue.def"
339 };
340
341private:
342 /// Type of data stored in the value.
343 Type Ty = isNone;
344 dwarf::Attribute Attribute = (dwarf::Attribute)0;
345 dwarf::Form Form = (dwarf::Form)0;
346
347 /// Storage for the value.
348 ///
349 /// All values that aren't standard layout (or are larger than 8 bytes)
350 /// should be stored by reference instead of by value.
351 using ValTy = AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
352 DIEDelta *, DIEEntry, DIEBlock *,
353 DIELoc *, DIELocList>;
354
355 static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
356 sizeof(ValTy) <= sizeof(void *),
357 "Expected all large types to be stored via pointer");
358
359 /// Underlying stored value.
360 ValTy Val;
361
362 template <class T> void construct(T V) {
363 static_assert(std::is_standard_layout<T>::value ||
364 std::is_pointer<T>::value,
365 "Expected standard layout or pointer");
366 new (reinterpret_cast<void *>(Val.buffer)) T(V);
367 }
368
369 template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
370 template <class T> const T *get() const {
371 return reinterpret_cast<const T *>(Val.buffer);
372 }
373 template <class T> void destruct() { get<T>()->~T(); }
374
375 /// Destroy the underlying value.
376 ///
377 /// This should get optimized down to a no-op. We could skip it if we could
378 /// add a static assert on \a std::is_trivially_copyable(), but we currently
379 /// support versions of GCC that don't understand that.
380 void destroyVal() {
381 switch (Ty) {
382 case isNone:
383 return;
384#define HANDLE_DIEVALUE_SMALL(T) \
385 case is##T: \
386 destruct<DIE##T>(); \
387 return;
388#define HANDLE_DIEVALUE_LARGE(T) \
389 case is##T: \
390 destruct<const DIE##T *>(); \
391 return;
392#include "llvm/CodeGen/DIEValue.def"
393 }
394 }
395
396 /// Copy the underlying value.
397 ///
398 /// This should get optimized down to a simple copy. We need to actually
399 /// construct the value, rather than calling memcpy, to satisfy strict
400 /// aliasing rules.
401 void copyVal(const DIEValue &X) {
402 switch (Ty) {
403 case isNone:
404 return;
405#define HANDLE_DIEVALUE_SMALL(T) \
406 case is##T: \
407 construct<DIE##T>(*X.get<DIE##T>()); \
408 return;
409#define HANDLE_DIEVALUE_LARGE(T) \
410 case is##T: \
411 construct<const DIE##T *>(*X.get<const DIE##T *>()); \
412 return;
413#include "llvm/CodeGen/DIEValue.def"
414 }
415 }
416
417public:
418 DIEValue() = default;
419
420 DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
421 copyVal(X);
422 }
423
424 DIEValue &operator=(const DIEValue &X) {
425 destroyVal();
426 Ty = X.Ty;
427 Attribute = X.Attribute;
428 Form = X.Form;
429 copyVal(X);
430 return *this;
431 }
432
433 ~DIEValue() { destroyVal(); }
434
435#define HANDLE_DIEVALUE_SMALL(T) \
436 DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V) \
437 : Ty(is##T), Attribute(Attribute), Form(Form) { \
438 construct<DIE##T>(V); \
439 }
440#define HANDLE_DIEVALUE_LARGE(T) \
441 DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V) \
442 : Ty(is##T), Attribute(Attribute), Form(Form) { \
443 assert(V && "Expected valid value")(static_cast <bool> (V && "Expected valid value"
) ? void (0) : __assert_fail ("V && \"Expected valid value\""
, "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 443, __extension__ __PRETTY_FUNCTION__))
; \
444 construct<const DIE##T *>(V); \
445 }
446#include "llvm/CodeGen/DIEValue.def"
447
448 /// Accessors.
449 /// @{
450 Type getType() const { return Ty; }
451 dwarf::Attribute getAttribute() const { return Attribute; }
452 dwarf::Form getForm() const { return Form; }
453 explicit operator bool() const { return Ty; }
454 /// @}
455
456#define HANDLE_DIEVALUE_SMALL(T) \
457 const DIE##T &getDIE##T() const { \
458 assert(getType() == is##T && "Expected " #T)(static_cast <bool> (getType() == is##T && "Expected "
#T) ? void (0) : __assert_fail ("getType() == is##T && \"Expected \" #T"
, "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 458, __extension__ __PRETTY_FUNCTION__))
; \
459 return *get<DIE##T>(); \
460 }
461#define HANDLE_DIEVALUE_LARGE(T) \
462 const DIE##T &getDIE##T() const { \
463 assert(getType() == is##T && "Expected " #T)(static_cast <bool> (getType() == is##T && "Expected "
#T) ? void (0) : __assert_fail ("getType() == is##T && \"Expected \" #T"
, "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 463, __extension__ __PRETTY_FUNCTION__))
; \
464 return **get<const DIE##T *>(); \
465 }
466#include "llvm/CodeGen/DIEValue.def"
467
468 /// Emit value via the Dwarf writer.
469 void EmitValue(const AsmPrinter *AP) const;
470
471 /// Return the size of a value in bytes.
472 unsigned SizeOf(const AsmPrinter *AP) const;
473
474 void print(raw_ostream &O) const;
475 void dump() const;
476};
477
478struct IntrusiveBackListNode {
479 PointerIntPair<IntrusiveBackListNode *, 1> Next;
480
481 IntrusiveBackListNode() : Next(this, true) {}
482
483 IntrusiveBackListNode *getNext() const {
484 return Next.getInt() ? nullptr : Next.getPointer();
485 }
486};
487
488struct IntrusiveBackListBase {
489 using Node = IntrusiveBackListNode;
490
491 Node *Last = nullptr;
492
493 bool empty() const { return !Last; }
494
495 void push_back(Node &N) {
496 assert(N.Next.getPointer() == &N && "Expected unlinked node")(static_cast <bool> (N.Next.getPointer() == &N &&
"Expected unlinked node") ? void (0) : __assert_fail ("N.Next.getPointer() == &N && \"Expected unlinked node\""
, "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 496, __extension__ __PRETTY_FUNCTION__))
;
497 assert(N.Next.getInt() == true && "Expected unlinked node")(static_cast <bool> (N.Next.getInt() == true &&
"Expected unlinked node") ? void (0) : __assert_fail ("N.Next.getInt() == true && \"Expected unlinked node\""
, "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 497, __extension__ __PRETTY_FUNCTION__))
;
498
499 if (Last) {
500 N.Next = Last->Next;
501 Last->Next.setPointerAndInt(&N, false);
502 }
503 Last = &N;
504 }
505};
506
507template <class T> class IntrusiveBackList : IntrusiveBackListBase {
508public:
509 using IntrusiveBackListBase::empty;
510
511 void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
512 T &back() { return *static_cast<T *>(Last); }
513 const T &back() const { return *static_cast<T *>(Last); }
514
515 class const_iterator;
516 class iterator
517 : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
518 friend class const_iterator;
519
520 Node *N = nullptr;
521
522 public:
523 iterator() = default;
524 explicit iterator(T *N) : N(N) {}
525
526 iterator &operator++() {
527 N = N->getNext();
528 return *this;
529 }
530
531 explicit operator bool() const { return N; }
532 T &operator*() const { return *static_cast<T *>(N); }
533
534 bool operator==(const iterator &X) const { return N == X.N; }
535 bool operator!=(const iterator &X) const { return N != X.N; }
536 };
537
538 class const_iterator
539 : public iterator_facade_base<const_iterator, std::forward_iterator_tag,
540 const T> {
541 const Node *N = nullptr;
542
543 public:
544 const_iterator() = default;
545 // Placate MSVC by explicitly scoping 'iterator'.
546 const_iterator(typename IntrusiveBackList<T>::iterator X) : N(X.N) {}
547 explicit const_iterator(const T *N) : N(N) {}
548
549 const_iterator &operator++() {
550 N = N->getNext();
551 return *this;
552 }
553
554 explicit operator bool() const { return N; }
555 const T &operator*() const { return *static_cast<const T *>(N); }
556
557 bool operator==(const const_iterator &X) const { return N == X.N; }
558 bool operator!=(const const_iterator &X) const { return N != X.N; }
559 };
560
561 iterator begin() {
562 return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();
563 }
564 const_iterator begin() const {
565 return const_cast<IntrusiveBackList *>(this)->begin();
566 }
567 iterator end() { return iterator(); }
568 const_iterator end() const { return const_iterator(); }
569
570 static iterator toIterator(T &N) { return iterator(&N); }
571 static const_iterator toIterator(const T &N) { return const_iterator(&N); }
572};
573
574/// A list of DIE values.
575///
576/// This is a singly-linked list, but instead of reversing the order of
577/// insertion, we keep a pointer to the back of the list so we can push in
578/// order.
579///
580/// There are two main reasons to choose a linked list over a customized
581/// vector-like data structure.
582///
583/// 1. For teardown efficiency, we want DIEs to be BumpPtrAllocated. Using a
584/// linked list here makes this way easier to accomplish.
585/// 2. Carrying an extra pointer per \a DIEValue isn't expensive. 45% of DIEs
586/// have 2 or fewer values, and 90% have 5 or fewer. A vector would be
587/// over-allocated by 50% on average anyway, the same cost as the
588/// linked-list node.
589class DIEValueList {
590 struct Node : IntrusiveBackListNode {
591 DIEValue V;
592
593 explicit Node(DIEValue V) : V(V) {}
594 };
595
596 using ListTy = IntrusiveBackList<Node>;
597
598 ListTy List;
599
600public:
601 class const_value_iterator;
602 class value_iterator
603 : public iterator_adaptor_base<value_iterator, ListTy::iterator,
604 std::forward_iterator_tag, DIEValue> {
605 friend class const_value_iterator;
606
607 using iterator_adaptor =
608 iterator_adaptor_base<value_iterator, ListTy::iterator,
609 std::forward_iterator_tag, DIEValue>;
610
611 public:
612 value_iterator() = default;
613 explicit value_iterator(ListTy::iterator X) : iterator_adaptor(X) {}
614
615 explicit operator bool() const { return bool(wrapped()); }
616 DIEValue &operator*() const { return wrapped()->V; }
617 };
618
619 class const_value_iterator : public iterator_adaptor_base<
620 const_value_iterator, ListTy::const_iterator,
621 std::forward_iterator_tag, const DIEValue> {
622 using iterator_adaptor =
623 iterator_adaptor_base<const_value_iterator, ListTy::const_iterator,
624 std::forward_iterator_tag, const DIEValue>;
625
626 public:
627 const_value_iterator() = default;
628 const_value_iterator(DIEValueList::value_iterator X)
629 : iterator_adaptor(X.wrapped()) {}
630 explicit const_value_iterator(ListTy::const_iterator X)
631 : iterator_adaptor(X) {}
632
633 explicit operator bool() const { return bool(wrapped()); }
634 const DIEValue &operator*() const { return wrapped()->V; }
635 };
636
637 using value_range = iterator_range<value_iterator>;
638 using const_value_range = iterator_range<const_value_iterator>;
639
640 value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) {
641 List.push_back(*new (Alloc) Node(V));
9
Forming reference to null pointer
642 return value_iterator(ListTy::toIterator(List.back()));
643 }
644 template <class T>
645 value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
646 dwarf::Form Form, T &&Value) {
647 return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));
8
Calling 'DIEValueList::addValue'
648 }
649
650 value_range values() {
651 return make_range(value_iterator(List.begin()), value_iterator(List.end()));
652 }
653 const_value_range values() const {
654 return make_range(const_value_iterator(List.begin()),
655 const_value_iterator(List.end()));
656 }
657};
658
659//===--------------------------------------------------------------------===//
660/// A structured debug information entry. Has an abbreviation which
661/// describes its organization.
662class DIE : IntrusiveBackListNode, public DIEValueList {
663 friend class IntrusiveBackList<DIE>;
664 friend class DIEUnit;
665
666 /// Dwarf unit relative offset.
667 unsigned Offset = 0;
668 /// Size of instance + children.
669 unsigned Size = 0;
670 unsigned AbbrevNumber = ~0u;
671 /// Dwarf tag code.
672 dwarf::Tag Tag = (dwarf::Tag)0;
673 /// Set to true to force a DIE to emit an abbreviation that says it has
674 /// children even when it doesn't. This is used for unit testing purposes.
675 bool ForceChildren = false;
676 /// Children DIEs.
677 IntrusiveBackList<DIE> Children;
678
679 /// The owner is either the parent DIE for children of other DIEs, or a
680 /// DIEUnit which contains this DIE as its unit DIE.
681 PointerUnion<DIE *, DIEUnit *> Owner;
682
683 explicit DIE(dwarf::Tag Tag) : Tag(Tag) {}
684
685public:
686 DIE() = delete;
687 DIE(const DIE &RHS) = delete;
688 DIE(DIE &&RHS) = delete;
689 DIE &operator=(const DIE &RHS) = delete;
690 DIE &operator=(const DIE &&RHS) = delete;
691
692 static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
693 return new (Alloc) DIE(Tag);
694 }
695
696 // Accessors.
697 unsigned getAbbrevNumber() const { return AbbrevNumber; }
698 dwarf::Tag getTag() const { return Tag; }
699 /// Get the compile/type unit relative offset of this DIE.
700 unsigned getOffset() const { return Offset; }
701 unsigned getSize() const { return Size; }
702 bool hasChildren() const { return ForceChildren || !Children.empty(); }
703 void setForceChildren(bool B) { ForceChildren = B; }
704
705 using child_iterator = IntrusiveBackList<DIE>::iterator;
706 using const_child_iterator = IntrusiveBackList<DIE>::const_iterator;
707 using child_range = iterator_range<child_iterator>;
708 using const_child_range = iterator_range<const_child_iterator>;
709
710 child_range children() {
711 return make_range(Children.begin(), Children.end());
712 }
713 const_child_range children() const {
714 return make_range(Children.begin(), Children.end());
715 }
716
717 DIE *getParent() const;
718
719 /// Generate the abbreviation for this DIE.
720 ///
721 /// Calculate the abbreviation for this, which should be uniqued and
722 /// eventually used to call \a setAbbrevNumber().
723 DIEAbbrev generateAbbrev() const;
724
725 /// Set the abbreviation number for this DIE.
726 void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
727
728 /// Get the absolute offset within the .debug_info or .debug_types section
729 /// for this DIE.
730 unsigned getDebugSectionOffset() const;
731
732 /// Compute the offset of this DIE and all its children.
733 ///
734 /// This function gets called just before we are going to generate the debug
735 /// information and gives each DIE a chance to figure out its CU relative DIE
736 /// offset, unique its abbreviation and fill in the abbreviation code, and
737 /// return the unit offset that points to where the next DIE will be emitted
738 /// within the debug unit section. After this function has been called for all
739 /// DIE objects, the DWARF can be generated since all DIEs will be able to
740 /// properly refer to other DIE objects since all DIEs have calculated their
741 /// offsets.
742 ///
743 /// \param AP AsmPrinter to use when calculating sizes.
744 /// \param AbbrevSet the abbreviation used to unique DIE abbreviations.
745 /// \param CUOffset the compile/type unit relative offset in bytes.
746 /// \returns the offset for the DIE that follows this DIE within the
747 /// current compile/type unit.
748 unsigned computeOffsetsAndAbbrevs(const AsmPrinter *AP,
749 DIEAbbrevSet &AbbrevSet, unsigned CUOffset);
750
751 /// Climb up the parent chain to get the compile unit or type unit DIE that
752 /// this DIE belongs to.
753 ///
754 /// \returns the compile or type unit DIE that owns this DIE, or NULL if
755 /// this DIE hasn't been added to a unit DIE.
756 const DIE *getUnitDie() const;
757
758 /// Climb up the parent chain to get the compile unit or type unit that this
759 /// DIE belongs to.
760 ///
761 /// \returns the DIEUnit that represents the compile or type unit that owns
762 /// this DIE, or NULL if this DIE hasn't been added to a unit DIE.
763 const DIEUnit *getUnit() const;
764
765 void setOffset(unsigned O) { Offset = O; }
766 void setSize(unsigned S) { Size = S; }
767
768 /// Add a child to the DIE.
769 DIE &addChild(DIE *Child) {
770 assert(!Child->getParent() && "Child should be orphaned")(static_cast <bool> (!Child->getParent() && "Child should be orphaned"
) ? void (0) : __assert_fail ("!Child->getParent() && \"Child should be orphaned\""
, "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 770, __extension__ __PRETTY_FUNCTION__))
;
771 Child->Owner = this;
772 Children.push_back(*Child);
773 return Children.back();
774 }
775
776 /// Find a value in the DIE with the attribute given.
777 ///
778 /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
779 /// gives \a DIEValue::isNone) if no such attribute exists.
780 DIEValue findAttribute(dwarf::Attribute Attribute) const;
781
782 void print(raw_ostream &O, unsigned IndentCount = 0) const;
783 void dump() const;
784};
785
786//===--------------------------------------------------------------------===//
787/// Represents a compile or type unit.
788class DIEUnit {
789 /// The compile unit or type unit DIE. This variable must be an instance of
790 /// DIE so that we can calculate the DIEUnit from any DIE by traversing the
791 /// parent backchain and getting the Unit DIE, and then casting itself to a
792 /// DIEUnit. This allows us to be able to find the DIEUnit for any DIE without
793 /// having to store a pointer to the DIEUnit in each DIE instance.
794 DIE Die;
795 /// The section this unit will be emitted in. This may or may not be set to
796 /// a valid section depending on the client that is emitting DWARF.
797 MCSection *Section;
798 uint64_t Offset; /// .debug_info or .debug_types absolute section offset.
799 uint32_t Length; /// The length in bytes of all of the DIEs in this unit.
800 const uint16_t Version; /// The Dwarf version number for this unit.
801 const uint8_t AddrSize; /// The size in bytes of an address for this unit.
802protected:
803 ~DIEUnit() = default;
804
805public:
806 DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
807 DIEUnit(const DIEUnit &RHS) = delete;
808 DIEUnit(DIEUnit &&RHS) = delete;
809 void operator=(const DIEUnit &RHS) = delete;
810 void operator=(const DIEUnit &&RHS) = delete;
811 /// Set the section that this DIEUnit will be emitted into.
812 ///
813 /// This function is used by some clients to set the section. Not all clients
814 /// that emit DWARF use this section variable.
815 void setSection(MCSection *Section) {
816 assert(!this->Section)(static_cast <bool> (!this->Section) ? void (0) : __assert_fail
("!this->Section", "/build/llvm-toolchain-snapshot-7~svn325118/include/llvm/CodeGen/DIE.h"
, 816, __extension__ __PRETTY_FUNCTION__))
;
817 this->Section = Section;
818 }
819
820 virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const {
821 return nullptr;
822 }
823
824 /// Return the section that this DIEUnit will be emitted into.
825 ///
826 /// \returns Section pointer which can be NULL.
827 MCSection *getSection() const { return Section; }
828 void setDebugSectionOffset(unsigned O) { Offset = O; }
829 unsigned getDebugSectionOffset() const { return Offset; }
830 void setLength(uint64_t L) { Length = L; }
831 uint64_t getLength() const { return Length; }
832 uint16_t getDwarfVersion() const { return Version; }
833 uint16_t getAddressSize() const { return AddrSize; }
834 DIE &getUnitDie() { return Die; }
835 const DIE &getUnitDie() const { return Die; }
836};
837
838struct BasicDIEUnit final : DIEUnit {
839 BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)
840 : DIEUnit(Version, AddrSize, UnitTag) {}
841};
842
843//===--------------------------------------------------------------------===//
844/// DIELoc - Represents an expression location.
845//
846class DIELoc : public DIEValueList {
847 mutable unsigned Size = 0; // Size in bytes excluding size header.
848
849public:
850 DIELoc() = default;
851
852 /// ComputeSize - Calculate the size of the location expression.
853 ///
854 unsigned ComputeSize(const AsmPrinter *AP) const;
855
856 /// BestForm - Choose the best form for data.
857 ///
858 dwarf::Form BestForm(unsigned DwarfVersion) const {
859 if (DwarfVersion > 3)
860 return dwarf::DW_FORM_exprloc;
861 // Pre-DWARF4 location expressions were blocks and not exprloc.
862 if ((unsigned char)Size == Size)
863 return dwarf::DW_FORM_block1;
864 if ((unsigned short)Size == Size)
865 return dwarf::DW_FORM_block2;
866 if ((unsigned int)Size == Size)
867 return dwarf::DW_FORM_block4;
868 return dwarf::DW_FORM_block;
869 }
870
871 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
872 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
873
874 void print(raw_ostream &O) const;
875};
876
877//===--------------------------------------------------------------------===//
878/// DIEBlock - Represents a block of values.
879//
880class DIEBlock : public DIEValueList {
881 mutable unsigned Size = 0; // Size in bytes excluding size header.
882
883public:
884 DIEBlock() = default;
885
886 /// ComputeSize - Calculate the size of the location expression.
887 ///
888 unsigned ComputeSize(const AsmPrinter *AP) const;
889
890 /// BestForm - Choose the best form for data.
891 ///
892 dwarf::Form BestForm() const {
893 if ((unsigned char)Size == Size)
894 return dwarf::DW_FORM_block1;
895 if ((unsigned short)Size == Size)
896 return dwarf::DW_FORM_block2;
897 if ((unsigned int)Size == Size)
898 return dwarf::DW_FORM_block4;
899 return dwarf::DW_FORM_block;
900 }
901
902 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
903 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
904
905 void print(raw_ostream &O) const;
906};
907
908} // end namespace llvm
909
910#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H