Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DwarfUnit.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/lib/CodeGen/AsmPrinter -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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

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

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

1//===- lib/CodeGen/DIE.h - DWARF Info Entries -------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Data structures for DWARF info entries.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
15#define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
16
17#include "llvm/ADT/FoldingSet.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/ADT/PointerUnion.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/BinaryFormat/Dwarf.h"
25#include "llvm/CodeGen/DwarfStringPoolEntry.h"
26#include "llvm/Support/AlignOf.h"
27#include "llvm/Support/Allocator.h"
28#include <cassert>
29#include <cstddef>
30#include <cstdint>
31#include <iterator>
32#include <new>
33#include <type_traits>
34#include <utility>
35#include <vector>
36
37namespace llvm {
38
39class AsmPrinter;
40class DIE;
41class DIEUnit;
42class MCExpr;
43class MCSection;
44class MCSymbol;
45class raw_ostream;
46
47//===--------------------------------------------------------------------===//
48/// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.
49class DIEAbbrevData {
50 /// Dwarf attribute code.
51 dwarf::Attribute Attribute;
52
53 /// Dwarf form code.
54 dwarf::Form Form;
55
56 /// Dwarf attribute value for DW_FORM_implicit_const
57 int64_t Value = 0;
58
59public:
60 DIEAbbrevData(dwarf::Attribute A, dwarf::Form F)
61 : Attribute(A), Form(F) {}
62 DIEAbbrevData(dwarf::Attribute A, int64_t V)
63 : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}
64
65 /// Accessors.
66 /// @{
67 dwarf::Attribute getAttribute() const { return Attribute; }
68 dwarf::Form getForm() const { return Form; }
69 int64_t getValue() const { return Value; }
70 /// @}
71
72 /// Used to gather unique data for the abbreviation folding set.
73 void Profile(FoldingSetNodeID &ID) const;
74};
75
76//===--------------------------------------------------------------------===//
77/// Dwarf abbreviation, describes the organization of a debug information
78/// object.
79class DIEAbbrev : public FoldingSetNode {
80 /// Unique number for node.
81 unsigned Number;
82
83 /// Dwarf tag code.
84 dwarf::Tag Tag;
85
86 /// Whether or not this node has children.
87 ///
88 /// This cheats a bit in all of the uses since the values in the standard
89 /// are 0 and 1 for no children and children respectively.
90 bool Children;
91
92 /// Raw data bytes for abbreviation.
93 SmallVector<DIEAbbrevData, 12> Data;
94
95public:
96 DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}
97
98 /// Accessors.
99 /// @{
100 dwarf::Tag getTag() const { return Tag; }
101 unsigned getNumber() const { return Number; }
102 bool hasChildren() const { return Children; }
103 const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
104 void setChildrenFlag(bool hasChild) { Children = hasChild; }
105 void setNumber(unsigned N) { Number = N; }
106 /// @}
107
108 /// Adds another set of attribute information to the abbreviation.
109 void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
110 Data.push_back(DIEAbbrevData(Attribute, Form));
111 }
112
113 /// Adds attribute with DW_FORM_implicit_const value
114 void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
115 Data.push_back(DIEAbbrevData(Attribute, Value));
116 }
117
118 /// Used to gather unique data for the abbreviation folding set.
119 void Profile(FoldingSetNodeID &ID) const;
120
121 /// Print the abbreviation using the specified asm printer.
122 void Emit(const AsmPrinter *AP) const;
123
124 void print(raw_ostream &O) const;
125 void dump() const;
126};
127
128//===--------------------------------------------------------------------===//
129/// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
130///
131/// This class will unique the DIE abbreviations for a llvm::DIE object and
132/// assign a unique abbreviation number to each unique DIEAbbrev object it
133/// finds. The resulting collection of DIEAbbrev objects can then be emitted
134/// into the .debug_abbrev section.
135class DIEAbbrevSet {
136 /// The bump allocator to use when creating DIEAbbrev objects in the uniqued
137 /// storage container.
138 BumpPtrAllocator &Alloc;
139 /// \brief FoldingSet that uniques the abbreviations.
140 FoldingSet<DIEAbbrev> AbbreviationsSet;
141 /// A list of all the unique abbreviations in use.
142 std::vector<DIEAbbrev *> Abbreviations;
143
144public:
145 DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {}
146 ~DIEAbbrevSet();
147
148 /// Generate the abbreviation declaration for a DIE and return a pointer to
149 /// the generated abbreviation.
150 ///
151 /// \param Die the debug info entry to generate the abbreviation for.
152 /// \returns A reference to the uniqued abbreviation declaration that is
153 /// owned by this class.
154 DIEAbbrev &uniqueAbbreviation(DIE &Die);
155
156 /// Print all abbreviations using the specified asm printer.
157 void Emit(const AsmPrinter *AP, MCSection *Section) const;
158};
159
160//===--------------------------------------------------------------------===//
161/// An integer value DIE.
162///
163class DIEInteger {
164 uint64_t Integer;
165
166public:
167 explicit DIEInteger(uint64_t I) : Integer(I) {}
168
169 /// Choose the best form for integer.
170 static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
171 if (IsSigned) {
172 const int64_t SignedInt = Int;
173 if ((char)Int == SignedInt)
174 return dwarf::DW_FORM_data1;
175 if ((short)Int == SignedInt)
176 return dwarf::DW_FORM_data2;
177 if ((int)Int == SignedInt)
178 return dwarf::DW_FORM_data4;
179 } else {
180 if ((unsigned char)Int == Int)
181 return dwarf::DW_FORM_data1;
182 if ((unsigned short)Int == Int)
183 return dwarf::DW_FORM_data2;
184 if ((unsigned int)Int == Int)
185 return dwarf::DW_FORM_data4;
186 }
187 return dwarf::DW_FORM_data8;
188 }
189
190 uint64_t getValue() const { return Integer; }
191 void setValue(uint64_t Val) { Integer = Val; }
192
193 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
194 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
195
196 void print(raw_ostream &O) const;
197};
198
199//===--------------------------------------------------------------------===//
200/// An expression DIE.
201class DIEExpr {
202 const MCExpr *Expr;
203
204public:
205 explicit DIEExpr(const MCExpr *E) : Expr(E) {}
206
207 /// Get MCExpr.
208 const MCExpr *getValue() const { return Expr; }
209
210 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
211 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
212
213 void print(raw_ostream &O) const;
214};
215
216//===--------------------------------------------------------------------===//
217/// A label DIE.
218class DIELabel {
219 const MCSymbol *Label;
220
221public:
222 explicit DIELabel(const MCSymbol *L) : Label(L) {}
223
224 /// Get MCSymbol.
225 const MCSymbol *getValue() const { return Label; }
226
227 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
228 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
229
230 void print(raw_ostream &O) const;
231};
232
233//===--------------------------------------------------------------------===//
234/// A simple label difference DIE.
235///
236class DIEDelta {
237 const MCSymbol *LabelHi;
238 const MCSymbol *LabelLo;
239
240public:
241 DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
242
243 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
244 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
245
246 void print(raw_ostream &O) const;
247};
248
249//===--------------------------------------------------------------------===//
250/// A container for string pool string values.
251///
252/// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.
253class DIEString {
254 DwarfStringPoolEntryRef S;
255
256public:
257 DIEString(DwarfStringPoolEntryRef S) : S(S) {}
258
259 /// Grab the string out of the object.
260 StringRef getString() const { return S.getString(); }
261
262 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
263 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
264
265 void print(raw_ostream &O) const;
266};
267
268//===--------------------------------------------------------------------===//
269/// A container for inline string values.
270///
271/// This class is used with the DW_FORM_string form.
272class DIEInlineString {
273 StringRef S;
274
275public:
276 template <typename Allocator>
277 explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}
278
279 ~DIEInlineString() = default;
280
281 /// Grab the string out of the object.
282 StringRef getString() const { return S; }
283
284 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
285 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
286
287 void print(raw_ostream &O) const;
288};
289
290//===--------------------------------------------------------------------===//
291/// A pointer to another debug information entry. An instance of this class can
292/// also be used as a proxy for a debug information entry not yet defined
293/// (ie. types.)
294class DIEEntry {
295 DIE *Entry;
296
297public:
298 DIEEntry() = delete;
299 explicit DIEEntry(DIE &E) : Entry(&E) {}
300
301 DIE &getEntry() const { return *Entry; }
302
303 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
304 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
305
306 void print(raw_ostream &O) const;
307};
308
309//===--------------------------------------------------------------------===//
310/// Represents a pointer to a location list in the debug_loc
311/// section.
312class DIELocList {
313 /// Index into the .debug_loc vector.
314 size_t Index;
315
316public:
317 DIELocList(size_t I) : Index(I) {}
318
319 /// Grab the current index out.
320 size_t getValue() const { return Index; }
321
322 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
323 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
324
325 void print(raw_ostream &O) const;
326};
327
328//===--------------------------------------------------------------------===//
329/// A debug information entry value. Some of these roughly correlate
330/// to DWARF attribute classes.
331class DIEBlock;
332class DIELoc;
333class DIEValue {
334public:
335 enum Type {
336 isNone,
337#define HANDLE_DIEVALUE(T) is##T,
338#include "llvm/CodeGen/DIEValue.def"
339 };
340
341private:
342 /// Type of data stored in the value.
343 Type Ty = isNone;
344 dwarf::Attribute Attribute = (dwarf::Attribute)0;
345 dwarf::Form Form = (dwarf::Form)0;
346
347 /// Storage for the value.
348 ///
349 /// All values that aren't standard layout (or are larger than 8 bytes)
350 /// should be stored by reference instead of by value.
351 using ValTy = AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
352 DIEDelta *, DIEEntry, DIEBlock *,
353 DIELoc *, DIELocList>;
354
355 static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
356 sizeof(ValTy) <= sizeof(void *),
357 "Expected all large types to be stored via pointer");
358
359 /// Underlying stored value.
360 ValTy Val;
361
362 template <class T> void construct(T V) {
363 static_assert(std::is_standard_layout<T>::value ||
364 std::is_pointer<T>::value,
365 "Expected standard layout or pointer");
366 new (reinterpret_cast<void *>(Val.buffer)) T(V);
367 }
368
369 template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
370 template <class T> const T *get() const {
371 return reinterpret_cast<const T *>(Val.buffer);
372 }
373 template <class T> void destruct() { get<T>()->~T(); }
374
375 /// Destroy the underlying value.
376 ///
377 /// This should get optimized down to a no-op. We could skip it if we could
378 /// add a static assert on \a std::is_trivially_copyable(), but we currently
379 /// support versions of GCC that don't understand that.
380 void destroyVal() {
381 switch (Ty) {
382 case isNone:
383 return;
384#define HANDLE_DIEVALUE_SMALL(T) \
385 case is##T: \
386 destruct<DIE##T>(); \
387 return;
388#define HANDLE_DIEVALUE_LARGE(T) \
389 case is##T: \
390 destruct<const DIE##T *>(); \
391 return;
392#include "llvm/CodeGen/DIEValue.def"
393 }
394 }
395
396 /// Copy the underlying value.
397 ///
398 /// This should get optimized down to a simple copy. We need to actually
399 /// construct the value, rather than calling memcpy, to satisfy strict
400 /// aliasing rules.
401 void copyVal(const DIEValue &X) {
402 switch (Ty) {
403 case isNone:
404 return;
405#define HANDLE_DIEVALUE_SMALL(T) \
406 case is##T: \
407 construct<DIE##T>(*X.get<DIE##T>()); \
408 return;
409#define HANDLE_DIEVALUE_LARGE(T) \
410 case is##T: \
411 construct<const DIE##T *>(*X.get<const DIE##T *>()); \
412 return;
413#include "llvm/CodeGen/DIEValue.def"
414 }
415 }
416
417public:
418 DIEValue() = default;
419
420 DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
421 copyVal(X);
422 }
423
424 DIEValue &operator=(const DIEValue &X) {
425 destroyVal();
426 Ty = X.Ty;
427 Attribute = X.Attribute;
428 Form = X.Form;
429 copyVal(X);
430 return *this;
431 }
432
433 ~DIEValue() { destroyVal(); }
434
435#define HANDLE_DIEVALUE_SMALL(T) \
436 DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V) \
437 : Ty(is##T), Attribute(Attribute), Form(Form) { \
438 construct<DIE##T>(V); \
439 }
440#define HANDLE_DIEVALUE_LARGE(T) \
441 DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V) \
442 : Ty(is##T), Attribute(Attribute), Form(Form) { \
443 assert(V && "Expected valid value")(static_cast <bool> (V && "Expected valid value"
) ? void (0) : __assert_fail ("V && \"Expected valid value\""
, "/build/llvm-toolchain-snapshot-7~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/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~svn329677/include/llvm/CodeGen/DIE.h"
, 816, __extension__ __PRETTY_FUNCTION__))
;
817 this->Section = Section;
818 }
819
820 virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const {
821 return nullptr;
822 }
823
824 /// Return the section that this DIEUnit will be emitted into.
825 ///
826 /// \returns Section pointer which can be NULL.
827 MCSection *getSection() const { return Section; }
828 void setDebugSectionOffset(unsigned O) { Offset = O; }
829 unsigned getDebugSectionOffset() const { return Offset; }
830 void setLength(uint64_t L) { Length = L; }
831 uint64_t getLength() const { return Length; }
832 uint16_t getDwarfVersion() const { return Version; }
833 uint16_t getAddressSize() const { return AddrSize; }
834 DIE &getUnitDie() { return Die; }
835 const DIE &getUnitDie() const { return Die; }
836};
837
838struct BasicDIEUnit final : DIEUnit {
839 BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)
840 : DIEUnit(Version, AddrSize, UnitTag) {}
841};
842
843//===--------------------------------------------------------------------===//
844/// DIELoc - Represents an expression location.
845//
846class DIELoc : public DIEValueList {
847 mutable unsigned Size = 0; // Size in bytes excluding size header.
848
849public:
850 DIELoc() = default;
851
852 /// ComputeSize - Calculate the size of the location expression.
853 ///
854 unsigned ComputeSize(const AsmPrinter *AP) const;
855
856 /// BestForm - Choose the best form for data.
857 ///
858 dwarf::Form BestForm(unsigned DwarfVersion) const {
859 if (DwarfVersion > 3)
860 return dwarf::DW_FORM_exprloc;
861 // Pre-DWARF4 location expressions were blocks and not exprloc.
862 if ((unsigned char)Size == Size)
863 return dwarf::DW_FORM_block1;
864 if ((unsigned short)Size == Size)
865 return dwarf::DW_FORM_block2;
866 if ((unsigned int)Size == Size)
867 return dwarf::DW_FORM_block4;
868 return dwarf::DW_FORM_block;
869 }
870
871 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
872 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
873
874 void print(raw_ostream &O) const;
875};
876
877//===--------------------------------------------------------------------===//
878/// DIEBlock - Represents a block of values.
879//
880class DIEBlock : public DIEValueList {
881 mutable unsigned Size = 0; // Size in bytes excluding size header.
882
883public:
884 DIEBlock() = default;
885
886 /// ComputeSize - Calculate the size of the location expression.
887 ///
888 unsigned ComputeSize(const AsmPrinter *AP) const;
889
890 /// BestForm - Choose the best form for data.
891 ///
892 dwarf::Form BestForm() const {
893 if ((unsigned char)Size == Size)
894 return dwarf::DW_FORM_block1;
895 if ((unsigned short)Size == Size)
896 return dwarf::DW_FORM_block2;
897 if ((unsigned int)Size == Size)
898 return dwarf::DW_FORM_block4;
899 return dwarf::DW_FORM_block;
900 }
901
902 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
903 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
904
905 void print(raw_ostream &O) const;
906};
907
908} // end namespace llvm
909
910#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H