Bug Summary

File:include/llvm/CodeGen/DIE.h
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~svn338205/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/lib/CodeGen/AsmPrinter -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfUnit.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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

/build/llvm-toolchain-snapshot-7~svn338205/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 /// 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 *Asm, 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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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 *Asm, 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 *Asm, 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