Bug Summary

File:include/llvm/CodeGen/DIE.h
Warning:line 641, column 5
Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DwarfUnit.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-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-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-8~svn345461/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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-8~svn345461/build-llvm/lib/CodeGen/AsmPrinter -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/lib/CodeGen/AsmPrinter/DwarfUnit.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/CodeGen/DIE.h

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