Bug Summary

File:lib/CodeGen/AsmPrinter/DwarfUnit.cpp
Warning:line 993, column 46
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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

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

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

/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h

1//===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- 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// Declarations for metadata specific to debug info.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_DEBUGINFOMETADATA_H
15#define LLVM_IR_DEBUGINFOMETADATA_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/BitmaskEnum.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/PointerUnion.h"
22#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/BinaryFormat/Dwarf.h"
27#include "llvm/IR/Constants.h"
28#include "llvm/IR/Metadata.h"
29#include "llvm/Support/Casting.h"
30#include <cassert>
31#include <climits>
32#include <cstddef>
33#include <cstdint>
34#include <iterator>
35#include <type_traits>
36#include <vector>
37
38// Helper macros for defining get() overrides.
39#define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
40#define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
41#define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)static CLASS *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
(FORMAL)) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(
ARGS), Distinct); } static TempCLASS getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { return TempCLASS
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)
); }
\
42 static CLASS *getDistinct(LLVMContext &Context, \
43 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
44 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct); \
45 } \
46 static Temp##CLASS getTemporary(LLVMContext &Context, \
47 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
48 return Temp##CLASS( \
49 getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)); \
50 }
51#define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS) \
52 static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
53 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued); \
54 } \
55 static CLASS *getIfExists(LLVMContext &Context, \
56 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
57 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued, \
58 /* ShouldCreate */ false); \
59 } \
60 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)static CLASS *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
(FORMAL)) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(
ARGS), Distinct); } static TempCLASS getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { return TempCLASS
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)
); }
61
62namespace llvm {
63
64/// Holds a subclass of DINode.
65///
66/// FIXME: This class doesn't currently make much sense. Previously it was a
67/// union beteen MDString (for ODR-uniqued types) and things like DIType. To
68/// support CodeView work, it wasn't deleted outright when MDString-based type
69/// references were deleted; we'll soon need a similar concept for CodeView
70/// DITypeIndex.
71template <class T> class TypedDINodeRef {
72 const Metadata *MD = nullptr;
73
74public:
75 TypedDINodeRef() = default;
76 TypedDINodeRef(std::nullptr_t) {}
77 TypedDINodeRef(const T *MD) : MD(MD) {}
78
79 explicit TypedDINodeRef(const Metadata *MD) : MD(MD) {
80 assert((!MD || isa<T>(MD)) && "Expected valid type ref")(static_cast <bool> ((!MD || isa<T>(MD)) &&
"Expected valid type ref") ? void (0) : __assert_fail ("(!MD || isa<T>(MD)) && \"Expected valid type ref\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 80, __extension__ __PRETTY_FUNCTION__))
;
81 }
82
83 template <class U>
84 TypedDINodeRef(
85 const TypedDINodeRef<U> &X,
86 typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
87 nullptr)
88 : MD(X) {}
89
90 operator Metadata *() const { return const_cast<Metadata *>(MD); }
91
92 T *resolve() const { return const_cast<T *>(cast_or_null<T>(MD)); }
93
94 bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; }
95 bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; }
96};
97
98using DINodeRef = TypedDINodeRef<DINode>;
99using DIScopeRef = TypedDINodeRef<DIScope>;
100using DITypeRef = TypedDINodeRef<DIType>;
101
102class DITypeRefArray {
103 const MDTuple *N = nullptr;
104
105public:
106 DITypeRefArray() = default;
107 DITypeRefArray(const MDTuple *N) : N(N) {}
108
109 explicit operator bool() const { return get(); }
110 explicit operator MDTuple *() const { return get(); }
111
112 MDTuple *get() const { return const_cast<MDTuple *>(N); }
113 MDTuple *operator->() const { return get(); }
114 MDTuple &operator*() const { return *get(); }
115
116 // FIXME: Fix callers and remove condition on N.
117 unsigned size() const { return N ? N->getNumOperands() : 0u; }
118 DITypeRef operator[](unsigned I) const { return DITypeRef(N->getOperand(I)); }
119
120 class iterator : std::iterator<std::input_iterator_tag, DITypeRef,
121 std::ptrdiff_t, void, DITypeRef> {
122 MDNode::op_iterator I = nullptr;
123
124 public:
125 iterator() = default;
126 explicit iterator(MDNode::op_iterator I) : I(I) {}
127
128 DITypeRef operator*() const { return DITypeRef(*I); }
129
130 iterator &operator++() {
131 ++I;
132 return *this;
133 }
134
135 iterator operator++(int) {
136 iterator Temp(*this);
137 ++I;
138 return Temp;
139 }
140
141 bool operator==(const iterator &X) const { return I == X.I; }
142 bool operator!=(const iterator &X) const { return I != X.I; }
143 };
144
145 // FIXME: Fix callers and remove condition on N.
146 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
147 iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
148};
149
150/// Tagged DWARF-like metadata node.
151///
152/// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
153/// defined in llvm/BinaryFormat/Dwarf.h). Called \a DINode because it's
154/// potentially used for non-DWARF output.
155class DINode : public MDNode {
156 friend class LLVMContextImpl;
157 friend class MDNode;
158
159protected:
160 DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
161 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
162 : MDNode(C, ID, Storage, Ops1, Ops2) {
163 assert(Tag < 1u << 16)(static_cast <bool> (Tag < 1u << 16) ? void (0
) : __assert_fail ("Tag < 1u << 16", "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 163, __extension__ __PRETTY_FUNCTION__))
;
164 SubclassData16 = Tag;
165 }
166 ~DINode() = default;
167
168 template <class Ty> Ty *getOperandAs(unsigned I) const {
169 return cast_or_null<Ty>(getOperand(I));
170 }
171
172 StringRef getStringOperand(unsigned I) const {
173 if (auto *S = getOperandAs<MDString>(I))
174 return S->getString();
175 return StringRef();
176 }
177
178 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
179 if (S.empty())
180 return nullptr;
181 return MDString::get(Context, S);
182 }
183
184 /// Allow subclasses to mutate the tag.
185 void setTag(unsigned Tag) { SubclassData16 = Tag; }
186
187public:
188 unsigned getTag() const { return SubclassData16; }
189
190 /// Debug info flags.
191 ///
192 /// The three accessibility flags are mutually exclusive and rolled together
193 /// in the first two bits.
194 enum DIFlags : uint32_t {
195#define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID,
196#define DI_FLAG_LARGEST_NEEDED
197#include "llvm/IR/DebugInfoFlags.def"
198 FlagAccessibility = FlagPrivate | FlagProtected | FlagPublic,
199 FlagPtrToMemberRep = FlagSingleInheritance | FlagMultipleInheritance |
200 FlagVirtualInheritance,
201 LLVM_MARK_AS_BITMASK_ENUM(FlagLargest)LLVM_BITMASK_LARGEST_ENUMERATOR = FlagLargest
202 };
203
204 static DIFlags getFlag(StringRef Flag);
205 static StringRef getFlagString(DIFlags Flag);
206
207 /// Split up a flags bitfield.
208 ///
209 /// Split \c Flags into \c SplitFlags, a vector of its components. Returns
210 /// any remaining (unrecognized) bits.
211 static DIFlags splitFlags(DIFlags Flags,
212 SmallVectorImpl<DIFlags> &SplitFlags);
213
214 static bool classof(const Metadata *MD) {
215 switch (MD->getMetadataID()) {
216 default:
217 return false;
218 case GenericDINodeKind:
219 case DISubrangeKind:
220 case DIEnumeratorKind:
221 case DIBasicTypeKind:
222 case DIDerivedTypeKind:
223 case DICompositeTypeKind:
224 case DISubroutineTypeKind:
225 case DIFileKind:
226 case DICompileUnitKind:
227 case DISubprogramKind:
228 case DILexicalBlockKind:
229 case DILexicalBlockFileKind:
230 case DINamespaceKind:
231 case DITemplateTypeParameterKind:
232 case DITemplateValueParameterKind:
233 case DIGlobalVariableKind:
234 case DILocalVariableKind:
235 case DILabelKind:
236 case DIObjCPropertyKind:
237 case DIImportedEntityKind:
238 case DIModuleKind:
239 return true;
240 }
241 }
242};
243
244template <class T> struct simplify_type<const TypedDINodeRef<T>> {
245 using SimpleType = Metadata *;
246
247 static SimpleType getSimplifiedValue(const TypedDINodeRef<T> &MD) {
248 return MD;
249 }
250};
251
252template <class T>
253struct simplify_type<TypedDINodeRef<T>>
254 : simplify_type<const TypedDINodeRef<T>> {};
255
256/// Generic tagged DWARF-like metadata node.
257///
258/// An un-specialized DWARF-like metadata node. The first operand is a
259/// (possibly empty) null-separated \a MDString header that contains arbitrary
260/// fields. The remaining operands are \a dwarf_operands(), and are pointers
261/// to other metadata.
262class GenericDINode : public DINode {
263 friend class LLVMContextImpl;
264 friend class MDNode;
265
266 GenericDINode(LLVMContext &C, StorageType Storage, unsigned Hash,
267 unsigned Tag, ArrayRef<Metadata *> Ops1,
268 ArrayRef<Metadata *> Ops2)
269 : DINode(C, GenericDINodeKind, Storage, Tag, Ops1, Ops2) {
270 setHash(Hash);
271 }
272 ~GenericDINode() { dropAllReferences(); }
273
274 void setHash(unsigned Hash) { SubclassData32 = Hash; }
275 void recalculateHash();
276
277 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
278 StringRef Header, ArrayRef<Metadata *> DwarfOps,
279 StorageType Storage, bool ShouldCreate = true) {
280 return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
281 DwarfOps, Storage, ShouldCreate);
282 }
283
284 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
285 MDString *Header, ArrayRef<Metadata *> DwarfOps,
286 StorageType Storage, bool ShouldCreate = true);
287
288 TempGenericDINode cloneImpl() const {
289 return getTemporary(
290 getContext(), getTag(), getHeader(),
291 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
292 }
293
294public:
295 unsigned getHash() const { return SubclassData32; }
296
297 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header,
298 ArrayRef<Metadata *> DwarfOps),
299 (Tag, Header, DwarfOps))
300 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
301 ArrayRef<Metadata *> DwarfOps),
302 (Tag, Header, DwarfOps))
303
304 /// Return a (temporary) clone of this.
305 TempGenericDINode clone() const { return cloneImpl(); }
306
307 unsigned getTag() const { return SubclassData16; }
308 StringRef getHeader() const { return getStringOperand(0); }
309 MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
310
311 op_iterator dwarf_op_begin() const { return op_begin() + 1; }
312 op_iterator dwarf_op_end() const { return op_end(); }
313 op_range dwarf_operands() const {
314 return op_range(dwarf_op_begin(), dwarf_op_end());
315 }
316
317 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
318 const MDOperand &getDwarfOperand(unsigned I) const {
319 return getOperand(I + 1);
320 }
321 void replaceDwarfOperandWith(unsigned I, Metadata *New) {
322 replaceOperandWith(I + 1, New);
323 }
324
325 static bool classof(const Metadata *MD) {
326 return MD->getMetadataID() == GenericDINodeKind;
327 }
328};
329
330/// Array subrange.
331///
332/// TODO: Merge into node for DW_TAG_array_type, which should have a custom
333/// type.
334class DISubrange : public DINode {
335 friend class LLVMContextImpl;
336 friend class MDNode;
337
338 int64_t LowerBound;
339
340 DISubrange(LLVMContext &C, StorageType Storage, Metadata *Node,
341 int64_t LowerBound, ArrayRef<Metadata *> Ops)
342 : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops),
343 LowerBound(LowerBound) {}
344
345 ~DISubrange() = default;
346
347 static DISubrange *getImpl(LLVMContext &Context, int64_t Count,
348 int64_t LowerBound, StorageType Storage,
349 bool ShouldCreate = true);
350
351 static DISubrange *getImpl(LLVMContext &Context, Metadata *CountNode,
352 int64_t LowerBound, StorageType Storage,
353 bool ShouldCreate = true);
354
355 TempDISubrange cloneImpl() const {
356 return getTemporary(getContext(), getRawCountNode(), getLowerBound());
357 }
358
359public:
360 DEFINE_MDNODE_GET(DISubrange, (int64_t Count, int64_t LowerBound = 0),
361 (Count, LowerBound))
362
363 DEFINE_MDNODE_GET(DISubrange, (Metadata *CountNode, int64_t LowerBound = 0),
364 (CountNode, LowerBound))
365
366 TempDISubrange clone() const { return cloneImpl(); }
367
368 int64_t getLowerBound() const { return LowerBound; }
369
370 Metadata *getRawCountNode() const {
371 return getOperand(0).get();
372 }
373
374 typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
375
376 CountType getCount() const {
377 if (auto *MD = dyn_cast<ConstantAsMetadata>(getRawCountNode()))
378 return CountType(cast<ConstantInt>(MD->getValue()));
379
380 if (auto *DV = dyn_cast<DIVariable>(getRawCountNode()))
381 return CountType(DV);
382
383 return CountType();
384 }
385
386 static bool classof(const Metadata *MD) {
387 return MD->getMetadataID() == DISubrangeKind;
388 }
389};
390
391/// Enumeration value.
392///
393/// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
394/// longer creates a type cycle.
395class DIEnumerator : public DINode {
396 friend class LLVMContextImpl;
397 friend class MDNode;
398
399 int64_t Value;
400 DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
401 bool IsUnsigned, ArrayRef<Metadata *> Ops)
402 : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
403 Value(Value) {
404 SubclassData32 = IsUnsigned;
405 }
406 ~DIEnumerator() = default;
407
408 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
409 bool IsUnsigned, StringRef Name,
410 StorageType Storage, bool ShouldCreate = true) {
411 return getImpl(Context, Value, IsUnsigned,
412 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
413 }
414 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
415 bool IsUnsigned, MDString *Name,
416 StorageType Storage, bool ShouldCreate = true);
417
418 TempDIEnumerator cloneImpl() const {
419 return getTemporary(getContext(), getValue(), isUnsigned(), getName());
420 }
421
422public:
423 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, StringRef Name),
424 (Value, IsUnsigned, Name))
425 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, MDString *Name),
426 (Value, IsUnsigned, Name))
427
428 TempDIEnumerator clone() const { return cloneImpl(); }
429
430 int64_t getValue() const { return Value; }
431 bool isUnsigned() const { return SubclassData32; }
432 StringRef getName() const { return getStringOperand(0); }
433
434 MDString *getRawName() const { return getOperandAs<MDString>(0); }
435
436 static bool classof(const Metadata *MD) {
437 return MD->getMetadataID() == DIEnumeratorKind;
438 }
439};
440
441/// Base class for scope-like contexts.
442///
443/// Base class for lexical scopes and types (which are also declaration
444/// contexts).
445///
446/// TODO: Separate the concepts of declaration contexts and lexical scopes.
447class DIScope : public DINode {
448protected:
449 DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
450 ArrayRef<Metadata *> Ops)
451 : DINode(C, ID, Storage, Tag, Ops) {}
452 ~DIScope() = default;
453
454public:
455 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
456
457 inline StringRef getFilename() const;
458 inline StringRef getDirectory() const;
459 inline Optional<StringRef> getSource() const;
460
461 StringRef getName() const;
462 DIScopeRef getScope() const;
463
464 /// Return the raw underlying file.
465 ///
466 /// A \a DIFile is a \a DIScope, but it doesn't point at a separate file (it
467 /// \em is the file). If \c this is an \a DIFile, we need to return \c this.
468 /// Otherwise, return the first operand, which is where all other subclasses
469 /// store their file pointer.
470 Metadata *getRawFile() const {
471 return isa<DIFile>(this) ? const_cast<DIScope *>(this)
472 : static_cast<Metadata *>(getOperand(0));
473 }
474
475 static bool classof(const Metadata *MD) {
476 switch (MD->getMetadataID()) {
477 default:
478 return false;
479 case DIBasicTypeKind:
480 case DIDerivedTypeKind:
481 case DICompositeTypeKind:
482 case DISubroutineTypeKind:
483 case DIFileKind:
484 case DICompileUnitKind:
485 case DISubprogramKind:
486 case DILexicalBlockKind:
487 case DILexicalBlockFileKind:
488 case DINamespaceKind:
489 case DIModuleKind:
490 return true;
491 }
492 }
493};
494
495/// File.
496///
497/// TODO: Merge with directory/file node (including users).
498/// TODO: Canonicalize paths on creation.
499class DIFile : public DIScope {
500 friend class LLVMContextImpl;
501 friend class MDNode;
502
503public:
504 /// Which algorithm (e.g. MD5) a checksum was generated with.
505 ///
506 /// The encoding is explicit because it is used directly in Bitcode. The
507 /// value 0 is reserved to indicate the absence of a checksum in Bitcode.
508 enum ChecksumKind {
509 // The first variant was originally CSK_None, encoded as 0. The new
510 // internal representation removes the need for this by wrapping the
511 // ChecksumInfo in an Optional, but to preserve Bitcode compatibility the 0
512 // encoding is reserved.
513 CSK_MD5 = 1,
514 CSK_SHA1 = 2,
515 CSK_Last = CSK_SHA1 // Should be last enumeration.
516 };
517
518 /// A single checksum, represented by a \a Kind and a \a Value (a string).
519 template <typename T>
520 struct ChecksumInfo {
521 /// The kind of checksum which \a Value encodes.
522 ChecksumKind Kind;
523 /// The string value of the checksum.
524 T Value;
525
526 ChecksumInfo(ChecksumKind Kind, T Value) : Kind(Kind), Value(Value) { }
527 ~ChecksumInfo() = default;
528 bool operator==(const ChecksumInfo<T> &X) const {
529 return Kind == X.Kind && Value == X.Value;
530 }
531 bool operator!=(const ChecksumInfo<T> &X) const { return !(*this == X); }
532 StringRef getKindAsString() const { return getChecksumKindAsString(Kind); }
533 };
534
535private:
536 Optional<ChecksumInfo<MDString *>> Checksum;
537 Optional<MDString *> Source;
538
539 DIFile(LLVMContext &C, StorageType Storage,
540 Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
541 ArrayRef<Metadata *> Ops)
542 : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
543 Checksum(CS), Source(Src) {}
544 ~DIFile() = default;
545
546 static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
547 StringRef Directory,
548 Optional<ChecksumInfo<StringRef>> CS,
549 Optional<StringRef> Source,
550 StorageType Storage, bool ShouldCreate = true) {
551 Optional<ChecksumInfo<MDString *>> MDChecksum;
552 if (CS)
553 MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));
554 return getImpl(Context, getCanonicalMDString(Context, Filename),
555 getCanonicalMDString(Context, Directory), MDChecksum,
556 Source ? Optional<MDString *>(getCanonicalMDString(Context, *Source)) : None,
557 Storage, ShouldCreate);
558 }
559 static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
560 MDString *Directory,
561 Optional<ChecksumInfo<MDString *>> CS,
562 Optional<MDString *> Source, StorageType Storage,
563 bool ShouldCreate = true);
564
565 TempDIFile cloneImpl() const {
566 return getTemporary(getContext(), getFilename(), getDirectory(),
567 getChecksum(), getSource());
568 }
569
570public:
571 DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
572 Optional<ChecksumInfo<StringRef>> CS = None,
573 Optional<StringRef> Source = None),
574 (Filename, Directory, CS, Source))
575 DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory,
576 Optional<ChecksumInfo<MDString *>> CS = None,
577 Optional<MDString *> Source = None),
578 (Filename, Directory, CS, Source))
579
580 TempDIFile clone() const { return cloneImpl(); }
581
582 StringRef getFilename() const { return getStringOperand(0); }
583 StringRef getDirectory() const { return getStringOperand(1); }
584 Optional<ChecksumInfo<StringRef>> getChecksum() const {
585 Optional<ChecksumInfo<StringRef>> StringRefChecksum;
586 if (Checksum)
587 StringRefChecksum.emplace(Checksum->Kind, Checksum->Value->getString());
588 return StringRefChecksum;
589 }
590 Optional<StringRef> getSource() const {
591 return Source ? Optional<StringRef>((*Source)->getString()) : None;
592 }
593
594 MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
595 MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
596 Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
597 Optional<MDString *> getRawSource() const { return Source; }
598
599 static StringRef getChecksumKindAsString(ChecksumKind CSKind);
600 static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
601
602 static bool classof(const Metadata *MD) {
603 return MD->getMetadataID() == DIFileKind;
604 }
605};
606
607StringRef DIScope::getFilename() const {
608 if (auto *F = getFile())
609 return F->getFilename();
610 return "";
611}
612
613StringRef DIScope::getDirectory() const {
614 if (auto *F = getFile())
615 return F->getDirectory();
616 return "";
617}
618
619Optional<StringRef> DIScope::getSource() const {
620 if (auto *F = getFile())
621 return F->getSource();
622 return None;
623}
624
625/// Base class for types.
626///
627/// TODO: Remove the hardcoded name and context, since many types don't use
628/// them.
629/// TODO: Split up flags.
630class DIType : public DIScope {
631 unsigned Line;
632 DIFlags Flags;
633 uint64_t SizeInBits;
634 uint64_t OffsetInBits;
635 uint32_t AlignInBits;
636
637protected:
638 DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
639 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
640 uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
641 : DIScope(C, ID, Storage, Tag, Ops) {
642 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
643 }
644 ~DIType() = default;
645
646 void init(unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
647 uint64_t OffsetInBits, DIFlags Flags) {
648 this->Line = Line;
649 this->Flags = Flags;
650 this->SizeInBits = SizeInBits;
651 this->AlignInBits = AlignInBits;
652 this->OffsetInBits = OffsetInBits;
653 }
654
655 /// Change fields in place.
656 void mutate(unsigned Tag, unsigned Line, uint64_t SizeInBits,
657 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
658 assert(isDistinct() && "Only distinct nodes can mutate")(static_cast <bool> (isDistinct() && "Only distinct nodes can mutate"
) ? void (0) : __assert_fail ("isDistinct() && \"Only distinct nodes can mutate\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 658, __extension__ __PRETTY_FUNCTION__))
;
659 setTag(Tag);
660 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
661 }
662
663public:
664 TempDIType clone() const {
665 return TempDIType(cast<DIType>(MDNode::clone().release()));
666 }
667
668 unsigned getLine() const { return Line; }
669 uint64_t getSizeInBits() const { return SizeInBits; }
670 uint32_t getAlignInBits() const { return AlignInBits; }
671 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT8; }
672 uint64_t getOffsetInBits() const { return OffsetInBits; }
673 DIFlags getFlags() const { return Flags; }
674
675 DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
676 StringRef getName() const { return getStringOperand(2); }
677
678
679 Metadata *getRawScope() const { return getOperand(1); }
680 MDString *getRawName() const { return getOperandAs<MDString>(2); }
681
682 /// Returns a new temporary DIType with updated Flags
683 TempDIType cloneWithFlags(DIFlags NewFlags) const {
684 auto NewTy = clone();
685 NewTy->Flags = NewFlags;
686 return NewTy;
687 }
688
689 bool isPrivate() const {
690 return (getFlags() & FlagAccessibility) == FlagPrivate;
691 }
692 bool isProtected() const {
693 return (getFlags() & FlagAccessibility) == FlagProtected;
694 }
695 bool isPublic() const {
696 return (getFlags() & FlagAccessibility) == FlagPublic;
697 }
698 bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
699 bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
700 bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; }
701 bool isVirtual() const { return getFlags() & FlagVirtual; }
702 bool isArtificial() const { return getFlags() & FlagArtificial; }
703 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
704 bool isObjcClassComplete() const {
705 return getFlags() & FlagObjcClassComplete;
706 }
707 bool isVector() const { return getFlags() & FlagVector; }
708 bool isBitField() const { return getFlags() & FlagBitField; }
709 bool isStaticMember() const { return getFlags() & FlagStaticMember; }
710 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
711 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
712 bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
713 bool isTypePassByReference() const {
714 return getFlags() & FlagTypePassByReference;
715 }
716
717 static bool classof(const Metadata *MD) {
718 switch (MD->getMetadataID()) {
719 default:
720 return false;
721 case DIBasicTypeKind:
722 case DIDerivedTypeKind:
723 case DICompositeTypeKind:
724 case DISubroutineTypeKind:
725 return true;
726 }
727 }
728};
729
730/// Basic type, like 'int' or 'float'.
731///
732/// TODO: Split out DW_TAG_unspecified_type.
733/// TODO: Drop unused accessors.
734class DIBasicType : public DIType {
735 friend class LLVMContextImpl;
736 friend class MDNode;
737
738 unsigned Encoding;
739
740 DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
741 uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
742 ArrayRef<Metadata *> Ops)
743 : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
744 FlagZero, Ops),
745 Encoding(Encoding) {}
746 ~DIBasicType() = default;
747
748 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
749 StringRef Name, uint64_t SizeInBits,
750 uint32_t AlignInBits, unsigned Encoding,
751 StorageType Storage, bool ShouldCreate = true) {
752 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
753 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
754 }
755 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
756 MDString *Name, uint64_t SizeInBits,
757 uint32_t AlignInBits, unsigned Encoding,
758 StorageType Storage, bool ShouldCreate = true);
759
760 TempDIBasicType cloneImpl() const {
761 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
762 getAlignInBits(), getEncoding());
763 }
764
765public:
766 DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
767 (Tag, Name, 0, 0, 0))
768 DEFINE_MDNODE_GET(DIBasicType,
769 (unsigned Tag, StringRef Name, uint64_t SizeInBits,
770 uint32_t AlignInBits, unsigned Encoding),
771 (Tag, Name, SizeInBits, AlignInBits, Encoding))
772 DEFINE_MDNODE_GET(DIBasicType,
773 (unsigned Tag, MDString *Name, uint64_t SizeInBits,
774 uint32_t AlignInBits, unsigned Encoding),
775 (Tag, Name, SizeInBits, AlignInBits, Encoding))
776
777 TempDIBasicType clone() const { return cloneImpl(); }
778
779 unsigned getEncoding() const { return Encoding; }
780
781 enum class Signedness { Signed, Unsigned };
782
783 /// Return the signedness of this type, or None if this type is neither
784 /// signed nor unsigned.
785 Optional<Signedness> getSignedness() const;
786
787 static bool classof(const Metadata *MD) {
788 return MD->getMetadataID() == DIBasicTypeKind;
789 }
790};
791
792/// Derived types.
793///
794/// This includes qualified types, pointers, references, friends, typedefs, and
795/// class members.
796///
797/// TODO: Split out members (inheritance, fields, methods, etc.).
798class DIDerivedType : public DIType {
799 friend class LLVMContextImpl;
800 friend class MDNode;
801
802 /// The DWARF address space of the memory pointed to or referenced by a
803 /// pointer or reference type respectively.
804 Optional<unsigned> DWARFAddressSpace;
805
806 DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
807 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
808 uint64_t OffsetInBits, Optional<unsigned> DWARFAddressSpace,
809 DIFlags Flags, ArrayRef<Metadata *> Ops)
810 : DIType(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits,
811 AlignInBits, OffsetInBits, Flags, Ops),
812 DWARFAddressSpace(DWARFAddressSpace) {}
813 ~DIDerivedType() = default;
814
815 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
816 StringRef Name, DIFile *File, unsigned Line,
817 DIScopeRef Scope, DITypeRef BaseType,
818 uint64_t SizeInBits, uint32_t AlignInBits,
819 uint64_t OffsetInBits,
820 Optional<unsigned> DWARFAddressSpace,
821 DIFlags Flags, Metadata *ExtraData,
822 StorageType Storage, bool ShouldCreate = true) {
823 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
824 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
825 DWARFAddressSpace, Flags, ExtraData, Storage, ShouldCreate);
826 }
827 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
828 MDString *Name, Metadata *File, unsigned Line,
829 Metadata *Scope, Metadata *BaseType,
830 uint64_t SizeInBits, uint32_t AlignInBits,
831 uint64_t OffsetInBits,
832 Optional<unsigned> DWARFAddressSpace,
833 DIFlags Flags, Metadata *ExtraData,
834 StorageType Storage, bool ShouldCreate = true);
835
836 TempDIDerivedType cloneImpl() const {
837 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
838 getScope(), getBaseType(), getSizeInBits(),
839 getAlignInBits(), getOffsetInBits(),
840 getDWARFAddressSpace(), getFlags(), getExtraData());
841 }
842
843public:
844 DEFINE_MDNODE_GET(DIDerivedType,
845 (unsigned Tag, MDString *Name, Metadata *File,
846 unsigned Line, Metadata *Scope, Metadata *BaseType,
847 uint64_t SizeInBits, uint32_t AlignInBits,
848 uint64_t OffsetInBits,
849 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
850 Metadata *ExtraData = nullptr),
851 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
852 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
853 ExtraData))
854 DEFINE_MDNODE_GET(DIDerivedType,
855 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
856 DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
857 uint32_t AlignInBits, uint64_t OffsetInBits,
858 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
859 Metadata *ExtraData = nullptr),
860 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
861 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
862 ExtraData))
863
864 TempDIDerivedType clone() const { return cloneImpl(); }
865
866 /// Get the base type this is derived from.
867 DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
868 Metadata *getRawBaseType() const { return getOperand(3); }
869
870 /// \returns The DWARF address space of the memory pointed to or referenced by
871 /// a pointer or reference type respectively.
872 Optional<unsigned> getDWARFAddressSpace() const { return DWARFAddressSpace; }
873
874 /// Get extra data associated with this derived type.
875 ///
876 /// Class type for pointer-to-members, objective-c property node for ivars,
877 /// global constant wrapper for static members, or virtual base pointer offset
878 /// for inheritance.
879 ///
880 /// TODO: Separate out types that need this extra operand: pointer-to-member
881 /// types and member fields (static members and ivars).
882 Metadata *getExtraData() const { return getRawExtraData(); }
883 Metadata *getRawExtraData() const { return getOperand(4); }
884
885 /// Get casted version of extra data.
886 /// @{
887 DITypeRef getClassType() const {
888 assert(getTag() == dwarf::DW_TAG_ptr_to_member_type)(static_cast <bool> (getTag() == dwarf::DW_TAG_ptr_to_member_type
) ? void (0) : __assert_fail ("getTag() == dwarf::DW_TAG_ptr_to_member_type"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 888, __extension__ __PRETTY_FUNCTION__))
;
889 return DITypeRef(getExtraData());
890 }
891
892 DIObjCProperty *getObjCProperty() const {
893 return dyn_cast_or_null<DIObjCProperty>(getExtraData());
894 }
895
896 uint32_t getVBPtrOffset() const {
897 assert(getTag() == dwarf::DW_TAG_inheritance)(static_cast <bool> (getTag() == dwarf::DW_TAG_inheritance
) ? void (0) : __assert_fail ("getTag() == dwarf::DW_TAG_inheritance"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 897, __extension__ __PRETTY_FUNCTION__))
;
898 if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
899 if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
900 return static_cast<uint32_t>(CI->getZExtValue());
901 return 0;
902 }
903
904 Constant *getStorageOffsetInBits() const {
905 assert(getTag() == dwarf::DW_TAG_member && isBitField())(static_cast <bool> (getTag() == dwarf::DW_TAG_member &&
isBitField()) ? void (0) : __assert_fail ("getTag() == dwarf::DW_TAG_member && isBitField()"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 905, __extension__ __PRETTY_FUNCTION__))
;
906 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
907 return C->getValue();
908 return nullptr;
909 }
910
911 Constant *getConstant() const {
912 assert(getTag() == dwarf::DW_TAG_member && isStaticMember())(static_cast <bool> (getTag() == dwarf::DW_TAG_member &&
isStaticMember()) ? void (0) : __assert_fail ("getTag() == dwarf::DW_TAG_member && isStaticMember()"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 912, __extension__ __PRETTY_FUNCTION__))
;
913 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
914 return C->getValue();
915 return nullptr;
916 }
917 Constant *getDiscriminantValue() const {
918 assert(getTag() == dwarf::DW_TAG_member && !isStaticMember())(static_cast <bool> (getTag() == dwarf::DW_TAG_member &&
!isStaticMember()) ? void (0) : __assert_fail ("getTag() == dwarf::DW_TAG_member && !isStaticMember()"
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 918, __extension__ __PRETTY_FUNCTION__))
;
919 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
920 return C->getValue();
921 return nullptr;
922 }
923 /// @}
924
925 static bool classof(const Metadata *MD) {
926 return MD->getMetadataID() == DIDerivedTypeKind;
927 }
928};
929
930/// Composite types.
931///
932/// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
933/// TODO: Create a custom, unrelated node for DW_TAG_array_type.
934class DICompositeType : public DIType {
935 friend class LLVMContextImpl;
936 friend class MDNode;
937
938 unsigned RuntimeLang;
939
940 DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
941 unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
942 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
943 ArrayRef<Metadata *> Ops)
944 : DIType(C, DICompositeTypeKind, Storage, Tag, Line, SizeInBits,
945 AlignInBits, OffsetInBits, Flags, Ops),
946 RuntimeLang(RuntimeLang) {}
947 ~DICompositeType() = default;
948
949 /// Change fields in place.
950 void mutate(unsigned Tag, unsigned Line, unsigned RuntimeLang,
951 uint64_t SizeInBits, uint32_t AlignInBits,
952 uint64_t OffsetInBits, DIFlags Flags) {
953 assert(isDistinct() && "Only distinct nodes can mutate")(static_cast <bool> (isDistinct() && "Only distinct nodes can mutate"
) ? void (0) : __assert_fail ("isDistinct() && \"Only distinct nodes can mutate\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 953, __extension__ __PRETTY_FUNCTION__))
;
954 assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate")(static_cast <bool> (getRawIdentifier() && "Only ODR-uniqued nodes should mutate"
) ? void (0) : __assert_fail ("getRawIdentifier() && \"Only ODR-uniqued nodes should mutate\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 954, __extension__ __PRETTY_FUNCTION__))
;
955 this->RuntimeLang = RuntimeLang;
956 DIType::mutate(Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
957 }
958
959 static DICompositeType *
960 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
961 unsigned Line, DIScopeRef Scope, DITypeRef BaseType,
962 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
963 DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
964 DITypeRef VTableHolder, DITemplateParameterArray TemplateParams,
965 StringRef Identifier, DIDerivedType *Discriminator,
966 StorageType Storage, bool ShouldCreate = true) {
967 return getImpl(
968 Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
969 BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
970 RuntimeLang, VTableHolder, TemplateParams.get(),
971 getCanonicalMDString(Context, Identifier), Discriminator, Storage, ShouldCreate);
972 }
973 static DICompositeType *
974 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
975 unsigned Line, Metadata *Scope, Metadata *BaseType,
976 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
977 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
978 Metadata *VTableHolder, Metadata *TemplateParams,
979 MDString *Identifier, Metadata *Discriminator,
980 StorageType Storage, bool ShouldCreate = true);
981
982 TempDICompositeType cloneImpl() const {
983 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
984 getScope(), getBaseType(), getSizeInBits(),
985 getAlignInBits(), getOffsetInBits(), getFlags(),
986 getElements(), getRuntimeLang(), getVTableHolder(),
987 getTemplateParams(), getIdentifier(), getDiscriminator());
988 }
989
990public:
991 DEFINE_MDNODE_GET(DICompositeType,
992 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
993 DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
994 uint32_t AlignInBits, uint64_t OffsetInBits,
995 DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
996 DITypeRef VTableHolder,
997 DITemplateParameterArray TemplateParams = nullptr,
998 StringRef Identifier = "", DIDerivedType *Discriminator = nullptr),
999 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1000 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1001 VTableHolder, TemplateParams, Identifier, Discriminator))
1002 DEFINE_MDNODE_GET(DICompositeType,
1003 (unsigned Tag, MDString *Name, Metadata *File,
1004 unsigned Line, Metadata *Scope, Metadata *BaseType,
1005 uint64_t SizeInBits, uint32_t AlignInBits,
1006 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1007 unsigned RuntimeLang, Metadata *VTableHolder,
1008 Metadata *TemplateParams = nullptr,
1009 MDString *Identifier = nullptr,
1010 Metadata *Discriminator = nullptr),
1011 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1012 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1013 VTableHolder, TemplateParams, Identifier, Discriminator))
1014
1015 TempDICompositeType clone() const { return cloneImpl(); }
1016
1017 /// Get a DICompositeType with the given ODR identifier.
1018 ///
1019 /// If \a LLVMContext::isODRUniquingDebugTypes(), gets the mapped
1020 /// DICompositeType for the given ODR \c Identifier. If none exists, creates
1021 /// a new node.
1022 ///
1023 /// Else, returns \c nullptr.
1024 static DICompositeType *
1025 getODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
1026 MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
1027 Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
1028 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1029 unsigned RuntimeLang, Metadata *VTableHolder,
1030 Metadata *TemplateParams, Metadata *Discriminator);
1031 static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
1032 MDString &Identifier);
1033
1034 /// Build a DICompositeType with the given ODR identifier.
1035 ///
1036 /// Looks up the mapped DICompositeType for the given ODR \c Identifier. If
1037 /// it doesn't exist, creates a new one. If it does exist and \a
1038 /// isForwardDecl(), and the new arguments would be a definition, mutates the
1039 /// the type in place. In either case, returns the type.
1040 ///
1041 /// If not \a LLVMContext::isODRUniquingDebugTypes(), this function returns
1042 /// nullptr.
1043 static DICompositeType *
1044 buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
1045 MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
1046 Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
1047 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1048 unsigned RuntimeLang, Metadata *VTableHolder,
1049 Metadata *TemplateParams, Metadata *Discriminator);
1050
1051 DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
1052 DINodeArray getElements() const {
1053 return cast_or_null<MDTuple>(getRawElements());
1054 }
1055 DITypeRef getVTableHolder() const { return DITypeRef(getRawVTableHolder()); }
1056 DITemplateParameterArray getTemplateParams() const {
1057 return cast_or_null<MDTuple>(getRawTemplateParams());
1058 }
1059 StringRef getIdentifier() const { return getStringOperand(7); }
1060 unsigned getRuntimeLang() const { return RuntimeLang; }
1061
1062 Metadata *getRawBaseType() const { return getOperand(3); }
1063 Metadata *getRawElements() const { return getOperand(4); }
1064 Metadata *getRawVTableHolder() const { return getOperand(5); }
1065 Metadata *getRawTemplateParams() const { return getOperand(6); }
1066 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
1067 Metadata *getRawDiscriminator() const { return getOperand(8); }
1068 DIDerivedType *getDiscriminator() const { return getOperandAs<DIDerivedType>(8); }
23
Calling 'DINode::getOperandAs'
24
Returning from 'DINode::getOperandAs'
1069
1070 /// Replace operands.
1071 ///
1072 /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
1073 /// this will be RAUW'ed and deleted. Use a \a TrackingMDRef to keep track
1074 /// of its movement if necessary.
1075 /// @{
1076 void replaceElements(DINodeArray Elements) {
1077#ifndef NDEBUG
1078 for (DINode *Op : getElements())
1079 assert(is_contained(Elements->operands(), Op) &&(static_cast <bool> (is_contained(Elements->operands
(), Op) && "Lost a member during member list replacement"
) ? void (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a member during member list replacement\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 1080, __extension__ __PRETTY_FUNCTION__))
1080 "Lost a member during member list replacement")(static_cast <bool> (is_contained(Elements->operands
(), Op) && "Lost a member during member list replacement"
) ? void (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a member during member list replacement\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 1080, __extension__ __PRETTY_FUNCTION__))
;
1081#endif
1082 replaceOperandWith(4, Elements.get());
1083 }
1084
1085 void replaceVTableHolder(DITypeRef VTableHolder) {
1086 replaceOperandWith(5, VTableHolder);
1087 }
1088
1089 void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
1090 replaceOperandWith(6, TemplateParams.get());
1091 }
1092 /// @}
1093
1094 static bool classof(const Metadata *MD) {
1095 return MD->getMetadataID() == DICompositeTypeKind;
1096 }
1097};
1098
1099/// Type array for a subprogram.
1100///
1101/// TODO: Fold the array of types in directly as operands.
1102class DISubroutineType : public DIType {
1103 friend class LLVMContextImpl;
1104 friend class MDNode;
1105
1106 /// The calling convention used with DW_AT_calling_convention. Actually of
1107 /// type dwarf::CallingConvention.
1108 uint8_t CC;
1109
1110 DISubroutineType(LLVMContext &C, StorageType Storage, DIFlags Flags,
1111 uint8_t CC, ArrayRef<Metadata *> Ops)
1112 : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type,
1113 0, 0, 0, 0, Flags, Ops),
1114 CC(CC) {}
1115 ~DISubroutineType() = default;
1116
1117 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1118 uint8_t CC, DITypeRefArray TypeArray,
1119 StorageType Storage,
1120 bool ShouldCreate = true) {
1121 return getImpl(Context, Flags, CC, TypeArray.get(), Storage, ShouldCreate);
1122 }
1123 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1124 uint8_t CC, Metadata *TypeArray,
1125 StorageType Storage,
1126 bool ShouldCreate = true);
1127
1128 TempDISubroutineType cloneImpl() const {
1129 return getTemporary(getContext(), getFlags(), getCC(), getTypeArray());
1130 }
1131
1132public:
1133 DEFINE_MDNODE_GET(DISubroutineType,
1134 (DIFlags Flags, uint8_t CC, DITypeRefArray TypeArray),
1135 (Flags, CC, TypeArray))
1136 DEFINE_MDNODE_GET(DISubroutineType,
1137 (DIFlags Flags, uint8_t CC, Metadata *TypeArray),
1138 (Flags, CC, TypeArray))
1139
1140 TempDISubroutineType clone() const { return cloneImpl(); }
1141
1142 uint8_t getCC() const { return CC; }
1143
1144 DITypeRefArray getTypeArray() const {
1145 return cast_or_null<MDTuple>(getRawTypeArray());
1146 }
1147
1148 Metadata *getRawTypeArray() const { return getOperand(3); }
1149
1150 static bool classof(const Metadata *MD) {
1151 return MD->getMetadataID() == DISubroutineTypeKind;
1152 }
1153};
1154
1155/// Compile unit.
1156class DICompileUnit : public DIScope {
1157 friend class LLVMContextImpl;
1158 friend class MDNode;
1159
1160public:
1161 enum DebugEmissionKind : unsigned {
1162 NoDebug = 0,
1163 FullDebug,
1164 LineTablesOnly,
1165 LastEmissionKind = LineTablesOnly
1166 };
1167
1168 static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
1169 static const char *emissionKindString(DebugEmissionKind EK);
1170
1171private:
1172 unsigned SourceLanguage;
1173 bool IsOptimized;
1174 unsigned RuntimeVersion;
1175 unsigned EmissionKind;
1176 uint64_t DWOId;
1177 bool SplitDebugInlining;
1178 bool DebugInfoForProfiling;
1179 bool GnuPubnames;
1180
1181 DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
1182 bool IsOptimized, unsigned RuntimeVersion,
1183 unsigned EmissionKind, uint64_t DWOId, bool SplitDebugInlining,
1184 bool DebugInfoForProfiling, bool GnuPubnames, ArrayRef<Metadata *> Ops)
1185 : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
1186 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
1187 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind),
1188 DWOId(DWOId), SplitDebugInlining(SplitDebugInlining),
1189 DebugInfoForProfiling(DebugInfoForProfiling), GnuPubnames(GnuPubnames) {
1190 assert(Storage != Uniqued)(static_cast <bool> (Storage != Uniqued) ? void (0) : __assert_fail
("Storage != Uniqued", "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 1190, __extension__ __PRETTY_FUNCTION__))
;
1191 }
1192 ~DICompileUnit() = default;
1193
1194 static DICompileUnit *
1195 getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
1196 StringRef Producer, bool IsOptimized, StringRef Flags,
1197 unsigned RuntimeVersion, StringRef SplitDebugFilename,
1198 unsigned EmissionKind, DICompositeTypeArray EnumTypes,
1199 DIScopeArray RetainedTypes,
1200 DIGlobalVariableExpressionArray GlobalVariables,
1201 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
1202 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
1203 bool GnuPubnames, StorageType Storage, bool ShouldCreate = true) {
1204 return getImpl(
1205 Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
1206 IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
1207 getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
1208 EnumTypes.get(), RetainedTypes.get(), GlobalVariables.get(),
1209 ImportedEntities.get(), Macros.get(), DWOId, SplitDebugInlining,
1210 DebugInfoForProfiling, GnuPubnames, Storage, ShouldCreate);
1211 }
1212 static DICompileUnit *
1213 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
1214 MDString *Producer, bool IsOptimized, MDString *Flags,
1215 unsigned RuntimeVersion, MDString *SplitDebugFilename,
1216 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
1217 Metadata *GlobalVariables, Metadata *ImportedEntities,
1218 Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
1219 bool DebugInfoForProfiling, bool GnuPubnames, StorageType Storage,
1220 bool ShouldCreate = true);
1221
1222 TempDICompileUnit cloneImpl() const {
1223 return getTemporary(getContext(), getSourceLanguage(), getFile(),
1224 getProducer(), isOptimized(), getFlags(),
1225 getRuntimeVersion(), getSplitDebugFilename(),
1226 getEmissionKind(), getEnumTypes(), getRetainedTypes(),
1227 getGlobalVariables(), getImportedEntities(),
1228 getMacros(), DWOId, getSplitDebugInlining(),
1229 getDebugInfoForProfiling(), getGnuPubnames());
1230 }
1231
1232public:
1233 static void get() = delete;
1234 static void getIfExists() = delete;
1235
1236 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1237 DICompileUnit,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1238 (unsigned SourceLanguage, DIFile *File, StringRef Producer,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1239 bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1240 StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1241 DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1242 DIGlobalVariableExpressionArray GlobalVariables,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1243 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1244 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1245 bool GnuPubnames),static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1246 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1247 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1248 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1249 DebugInfoForProfiling, GnuPubnames))static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, GnuPubnames)), Distinct); } static TempDICompileUnit
getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1250 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1251 DICompileUnit,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1252 (unsigned SourceLanguage, Metadata *File, MDString *Producer,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1253 bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1254 MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1255 Metadata *RetainedTypes, Metadata *GlobalVariables,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1256 Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1257 bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames),static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1258 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1259 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1260 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1261 DebugInfoForProfiling, GnuPubnames))static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, bool GnuPubnames
))) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, bool GnuPubnames))) { return TempDICompileUnit( getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, GnuPubnames)), Temporary
)); }
1262
1263 TempDICompileUnit clone() const { return cloneImpl(); }
1264
1265 unsigned getSourceLanguage() const { return SourceLanguage; }
1266 bool isOptimized() const { return IsOptimized; }
1267 unsigned getRuntimeVersion() const { return RuntimeVersion; }
1268 DebugEmissionKind getEmissionKind() const {
1269 return (DebugEmissionKind)EmissionKind;
1270 }
1271 bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
1272 bool getGnuPubnames() const { return GnuPubnames; }
1273 StringRef getProducer() const { return getStringOperand(1); }
1274 StringRef getFlags() const { return getStringOperand(2); }
1275 StringRef getSplitDebugFilename() const { return getStringOperand(3); }
1276 DICompositeTypeArray getEnumTypes() const {
1277 return cast_or_null<MDTuple>(getRawEnumTypes());
1278 }
1279 DIScopeArray getRetainedTypes() const {
1280 return cast_or_null<MDTuple>(getRawRetainedTypes());
1281 }
1282 DIGlobalVariableExpressionArray getGlobalVariables() const {
1283 return cast_or_null<MDTuple>(getRawGlobalVariables());
1284 }
1285 DIImportedEntityArray getImportedEntities() const {
1286 return cast_or_null<MDTuple>(getRawImportedEntities());
1287 }
1288 DIMacroNodeArray getMacros() const {
1289 return cast_or_null<MDTuple>(getRawMacros());
1290 }
1291 uint64_t getDWOId() const { return DWOId; }
1292 void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
1293 bool getSplitDebugInlining() const { return SplitDebugInlining; }
1294 void setSplitDebugInlining(bool SplitDebugInlining) {
1295 this->SplitDebugInlining = SplitDebugInlining;
1296 }
1297
1298 MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
1299 MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
1300 MDString *getRawSplitDebugFilename() const {
1301 return getOperandAs<MDString>(3);
1302 }
1303 Metadata *getRawEnumTypes() const { return getOperand(4); }
1304 Metadata *getRawRetainedTypes() const { return getOperand(5); }
1305 Metadata *getRawGlobalVariables() const { return getOperand(6); }
1306 Metadata *getRawImportedEntities() const { return getOperand(7); }
1307 Metadata *getRawMacros() const { return getOperand(8); }
1308
1309 /// Replace arrays.
1310 ///
1311 /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
1312 /// deleted on a uniquing collision. In practice, uniquing collisions on \a
1313 /// DICompileUnit should be fairly rare.
1314 /// @{
1315 void replaceEnumTypes(DICompositeTypeArray N) {
1316 replaceOperandWith(4, N.get());
1317 }
1318 void replaceRetainedTypes(DITypeArray N) {
1319 replaceOperandWith(5, N.get());
1320 }
1321 void replaceGlobalVariables(DIGlobalVariableExpressionArray N) {
1322 replaceOperandWith(6, N.get());
1323 }
1324 void replaceImportedEntities(DIImportedEntityArray N) {
1325 replaceOperandWith(7, N.get());
1326 }
1327 void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(8, N.get()); }
1328 /// @}
1329
1330 static bool classof(const Metadata *MD) {
1331 return MD->getMetadataID() == DICompileUnitKind;
1332 }
1333};
1334
1335/// A scope for locals.
1336///
1337/// A legal scope for lexical blocks, local variables, and debug info
1338/// locations. Subclasses are \a DISubprogram, \a DILexicalBlock, and \a
1339/// DILexicalBlockFile.
1340class DILocalScope : public DIScope {
1341protected:
1342 DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1343 ArrayRef<Metadata *> Ops)
1344 : DIScope(C, ID, Storage, Tag, Ops) {}
1345 ~DILocalScope() = default;
1346
1347public:
1348 /// Get the subprogram for this scope.
1349 ///
1350 /// Return this if it's an \a DISubprogram; otherwise, look up the scope
1351 /// chain.
1352 DISubprogram *getSubprogram() const;
1353
1354 /// Get the first non DILexicalBlockFile scope of this scope.
1355 ///
1356 /// Return this if it's not a \a DILexicalBlockFIle; otherwise, look up the
1357 /// scope chain.
1358 DILocalScope *getNonLexicalBlockFileScope() const;
1359
1360 static bool classof(const Metadata *MD) {
1361 return MD->getMetadataID() == DISubprogramKind ||
1362 MD->getMetadataID() == DILexicalBlockKind ||
1363 MD->getMetadataID() == DILexicalBlockFileKind;
1364 }
1365};
1366
1367/// Debug location.
1368///
1369/// A debug location in source code, used for debug info and otherwise.
1370class DILocation : public MDNode {
1371 friend class LLVMContextImpl;
1372 friend class MDNode;
1373
1374 DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
1375 unsigned Column, ArrayRef<Metadata *> MDs);
1376 ~DILocation() { dropAllReferences(); }
1377
1378 static DILocation *getImpl(LLVMContext &Context, unsigned Line,
1379 unsigned Column, Metadata *Scope,
1380 Metadata *InlinedAt, StorageType Storage,
1381 bool ShouldCreate = true);
1382 static DILocation *getImpl(LLVMContext &Context, unsigned Line,
1383 unsigned Column, DILocalScope *Scope,
1384 DILocation *InlinedAt, StorageType Storage,
1385 bool ShouldCreate = true) {
1386 return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
1387 static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate);
1388 }
1389
1390 /// With a given unsigned int \p U, use up to 13 bits to represent it.
1391 /// old_bit 1~5 --> new_bit 1~5
1392 /// old_bit 6~12 --> new_bit 7~13
1393 /// new_bit_6 is 0 if higher bits (7~13) are all 0
1394 static unsigned getPrefixEncodingFromUnsigned(unsigned U) {
1395 U &= 0xfff;
1396 return U > 0x1f ? (((U & 0xfe0) << 1) | (U & 0x1f) | 0x20) : U;
1397 }
1398
1399 /// Reverse transformation as getPrefixEncodingFromUnsigned.
1400 static unsigned getUnsignedFromPrefixEncoding(unsigned U) {
1401 return (U & 0x20) ? (((U >> 1) & 0xfe0) | (U & 0x1f)) : (U & 0x1f);
1402 }
1403
1404 /// Returns the next component stored in discriminator.
1405 static unsigned getNextComponentInDiscriminator(unsigned D) {
1406 if ((D & 1) == 0)
1407 return D >> ((D & 0x40) ? 14 : 7);
1408 else
1409 return D >> 1;
1410 }
1411
1412 TempDILocation cloneImpl() const {
1413 // Get the raw scope/inlinedAt since it is possible to invoke this on
1414 // a DILocation containing temporary metadata.
1415 return getTemporary(getContext(), getLine(), getColumn(), getRawScope(),
1416 getRawInlinedAt());
1417 }
1418
1419public:
1420 // Disallow replacing operands.
1421 void replaceOperandWith(unsigned I, Metadata *New) = delete;
1422
1423 DEFINE_MDNODE_GET(DILocation,
1424 (unsigned Line, unsigned Column, Metadata *Scope,
1425 Metadata *InlinedAt = nullptr),
1426 (Line, Column, Scope, InlinedAt))
1427 DEFINE_MDNODE_GET(DILocation,
1428 (unsigned Line, unsigned Column, DILocalScope *Scope,
1429 DILocation *InlinedAt = nullptr),
1430 (Line, Column, Scope, InlinedAt))
1431
1432 /// Return a (temporary) clone of this.
1433 TempDILocation clone() const { return cloneImpl(); }
1434
1435 unsigned getLine() const { return SubclassData32; }
1436 unsigned getColumn() const { return SubclassData16; }
1437 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1438
1439 DILocation *getInlinedAt() const {
1440 return cast_or_null<DILocation>(getRawInlinedAt());
1441 }
1442
1443 DIFile *getFile() const { return getScope()->getFile(); }
1444 StringRef getFilename() const { return getScope()->getFilename(); }
1445 StringRef getDirectory() const { return getScope()->getDirectory(); }
1446 Optional<StringRef> getSource() const { return getScope()->getSource(); }
1447
1448 /// Get the scope where this is inlined.
1449 ///
1450 /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
1451 /// location.
1452 DILocalScope *getInlinedAtScope() const {
1453 if (auto *IA = getInlinedAt())
1454 return IA->getInlinedAtScope();
1455 return getScope();
1456 }
1457
1458 /// Check whether this can be discriminated from another location.
1459 ///
1460 /// Check \c this can be discriminated from \c RHS in a linetable entry.
1461 /// Scope and inlined-at chains are not recorded in the linetable, so they
1462 /// cannot be used to distinguish basic blocks.
1463 bool canDiscriminate(const DILocation &RHS) const {
1464 return getLine() != RHS.getLine() ||
1465 getColumn() != RHS.getColumn() ||
1466 getDiscriminator() != RHS.getDiscriminator() ||
1467 getFilename() != RHS.getFilename() ||
1468 getDirectory() != RHS.getDirectory();
1469 }
1470
1471 /// Get the DWARF discriminator.
1472 ///
1473 /// DWARF discriminators distinguish identical file locations between
1474 /// instructions that are on different basic blocks.
1475 ///
1476 /// There are 3 components stored in discriminator, from lower bits:
1477 ///
1478 /// Base discriminator: assigned by AddDiscriminators pass to identify IRs
1479 /// that are defined by the same source line, but
1480 /// different basic blocks.
1481 /// Duplication factor: assigned by optimizations that will scale down
1482 /// the execution frequency of the original IR.
1483 /// Copy Identifier: assigned by optimizations that clones the IR.
1484 /// Each copy of the IR will be assigned an identifier.
1485 ///
1486 /// Encoding:
1487 ///
1488 /// The above 3 components are encoded into a 32bit unsigned integer in
1489 /// order. If the lowest bit is 1, the current component is empty, and the
1490 /// next component will start in the next bit. Otherwise, the current
1491 /// component is non-empty, and its content starts in the next bit. The
1492 /// length of each components is either 5 bit or 12 bit: if the 7th bit
1493 /// is 0, the bit 2~6 (5 bits) are used to represent the component; if the
1494 /// 7th bit is 1, the bit 2~6 (5 bits) and 8~14 (7 bits) are combined to
1495 /// represent the component.
1496
1497 inline unsigned getDiscriminator() const;
1498
1499 /// Returns a new DILocation with updated \p Discriminator.
1500 inline const DILocation *cloneWithDiscriminator(unsigned Discriminator) const;
1501
1502 /// Returns a new DILocation with updated base discriminator \p BD.
1503 inline const DILocation *setBaseDiscriminator(unsigned BD) const;
1504
1505 /// Returns the duplication factor stored in the discriminator.
1506 inline unsigned getDuplicationFactor() const;
1507
1508 /// Returns the copy identifier stored in the discriminator.
1509 inline unsigned getCopyIdentifier() const;
1510
1511 /// Returns the base discriminator stored in the discriminator.
1512 inline unsigned getBaseDiscriminator() const;
1513
1514 /// Returns a new DILocation with duplication factor \p DF encoded in the
1515 /// discriminator.
1516 inline const DILocation *cloneWithDuplicationFactor(unsigned DF) const;
1517
1518 enum { NoGeneratedLocation = false, WithGeneratedLocation = true };
1519
1520 /// When two instructions are combined into a single instruction we also
1521 /// need to combine the original locations into a single location.
1522 ///
1523 /// When the locations are the same we can use either location. When they
1524 /// differ, we need a third location which is distinct from either. If they
1525 /// have the same file/line but have a different discriminator we could
1526 /// create a location with a new discriminator. If they are from different
1527 /// files/lines the location is ambiguous and can't be represented in a line
1528 /// entry. In this case, if \p GenerateLocation is true, we will set the
1529 /// merged debug location as line 0 of the nearest common scope where the two
1530 /// locations are inlined from.
1531 ///
1532 /// \p GenerateLocation: Whether the merged location can be generated when
1533 /// \p LocA and \p LocB differ.
1534 static const DILocation *
1535 getMergedLocation(const DILocation *LocA, const DILocation *LocB,
1536 bool GenerateLocation = NoGeneratedLocation);
1537
1538 /// Returns the base discriminator for a given encoded discriminator \p D.
1539 static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
1540 if ((D & 1) == 0)
1541 return getUnsignedFromPrefixEncoding(D >> 1);
1542 else
1543 return 0;
1544 }
1545
1546 /// Returns the duplication factor for a given encoded discriminator \p D.
1547 static unsigned getDuplicationFactorFromDiscriminator(unsigned D) {
1548 D = getNextComponentInDiscriminator(D);
1549 if (D == 0 || (D & 1))
1550 return 1;
1551 else
1552 return getUnsignedFromPrefixEncoding(D >> 1);
1553 }
1554
1555 /// Returns the copy identifier for a given encoded discriminator \p D.
1556 static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
1557 return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(
1558 getNextComponentInDiscriminator(D)));
1559 }
1560
1561
1562 Metadata *getRawScope() const { return getOperand(0); }
1563 Metadata *getRawInlinedAt() const {
1564 if (getNumOperands() == 2)
1565 return getOperand(1);
1566 return nullptr;
1567 }
1568
1569 static bool classof(const Metadata *MD) {
1570 return MD->getMetadataID() == DILocationKind;
1571 }
1572};
1573
1574/// Subprogram description.
1575///
1576/// TODO: Remove DisplayName. It's always equal to Name.
1577/// TODO: Split up flags.
1578class DISubprogram : public DILocalScope {
1579 friend class LLVMContextImpl;
1580 friend class MDNode;
1581
1582 unsigned Line;
1583 unsigned ScopeLine;
1584 unsigned VirtualIndex;
1585
1586 /// In the MS ABI, the implicit 'this' parameter is adjusted in the prologue
1587 /// of method overrides from secondary bases by this amount. It may be
1588 /// negative.
1589 int ThisAdjustment;
1590
1591 // Virtuality can only assume three values, so we can pack
1592 // in 2 bits (none/pure/pure_virtual).
1593 unsigned Virtuality : 2;
1594
1595 // These are boolean flags so one bit is enough.
1596 // MSVC starts a new container field every time the base
1597 // type changes so we can't use 'bool' to ensure these bits
1598 // are packed.
1599 unsigned IsLocalToUnit : 1;
1600 unsigned IsDefinition : 1;
1601 unsigned IsOptimized : 1;
1602
1603 unsigned Padding : 3;
1604
1605 DIFlags Flags;
1606
1607 DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
1608 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
1609 int ThisAdjustment, DIFlags Flags, bool IsLocalToUnit,
1610 bool IsDefinition, bool IsOptimized, ArrayRef<Metadata *> Ops)
1611 : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
1612 Ops),
1613 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
1614 ThisAdjustment(ThisAdjustment), Virtuality(Virtuality),
1615 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition),
1616 IsOptimized(IsOptimized), Flags(Flags) {
1617 static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
1618 assert(Virtuality < 4 && "Virtuality out of range")(static_cast <bool> (Virtuality < 4 && "Virtuality out of range"
) ? void (0) : __assert_fail ("Virtuality < 4 && \"Virtuality out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 1618, __extension__ __PRETTY_FUNCTION__))
;
1619 }
1620 ~DISubprogram() = default;
1621
1622 static DISubprogram *
1623 getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name,
1624 StringRef LinkageName, DIFile *File, unsigned Line,
1625 DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
1626 unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality,
1627 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1628 bool IsOptimized, DICompileUnit *Unit,
1629 DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
1630 DINodeArray RetainedNodes, DITypeArray ThrownTypes,
1631 StorageType Storage, bool ShouldCreate = true) {
1632 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1633 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1634 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
1635 Virtuality, VirtualIndex, ThisAdjustment, Flags, IsOptimized,
1636 Unit, TemplateParams.get(), Declaration, RetainedNodes.get(),
1637 ThrownTypes.get(), Storage, ShouldCreate);
1638 }
1639 static DISubprogram *
1640 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1641 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1642 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1643 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
1644 int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit,
1645 Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
1646 Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate = true);
1647
1648 TempDISubprogram cloneImpl() const {
1649 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1650 getFile(), getLine(), getType(), isLocalToUnit(),
1651 isDefinition(), getScopeLine(), getContainingType(),
1652 getVirtuality(), getVirtualIndex(), getThisAdjustment(),
1653 getFlags(), isOptimized(), getUnit(),
1654 getTemplateParams(), getDeclaration(), getRetainedNodes(),
1655 getThrownTypes());
1656 }
1657
1658public:
1659 DEFINE_MDNODE_GET(DISubprogram,
1660 (DIScopeRef Scope, StringRef Name, StringRef LinkageName,
1661 DIFile *File, unsigned Line, DISubroutineType *Type,
1662 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
1663 DITypeRef ContainingType, unsigned Virtuality,
1664 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1665 bool IsOptimized, DICompileUnit *Unit,
1666 DITemplateParameterArray TemplateParams = nullptr,
1667 DISubprogram *Declaration = nullptr,
1668 DINodeArray RetainedNodes = nullptr,
1669 DITypeArray ThrownTypes = nullptr),
1670 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1671 IsDefinition, ScopeLine, ContainingType, Virtuality,
1672 VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit,
1673 TemplateParams, Declaration, RetainedNodes, ThrownTypes))
1674 DEFINE_MDNODE_GET(
1675 DISubprogram,
1676 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
1677 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
1678 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
1679 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1680 bool IsOptimized, Metadata *Unit, Metadata *TemplateParams = nullptr,
1681 Metadata *Declaration = nullptr, Metadata *RetainedNodes = nullptr,
1682 Metadata *ThrownTypes = nullptr),
1683 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
1684 ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment,
1685 Flags, IsOptimized, Unit, TemplateParams, Declaration, RetainedNodes,
1686 ThrownTypes))
1687
1688 TempDISubprogram clone() const { return cloneImpl(); }
1689
1690 /// Returns a new temporary DISubprogram with updated Flags
1691 TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
1692 auto NewSP = clone();
1693 NewSP->Flags = NewFlags;
1694 return NewSP;
1695 }
1696
1697public:
1698 unsigned getLine() const { return Line; }
1699 unsigned getVirtuality() const { return Virtuality; }
1700 unsigned getVirtualIndex() const { return VirtualIndex; }
1701 int getThisAdjustment() const { return ThisAdjustment; }
1702 unsigned getScopeLine() const { return ScopeLine; }
1703 DIFlags getFlags() const { return Flags; }
1704 bool isLocalToUnit() const { return IsLocalToUnit; }
1705 bool isDefinition() const { return IsDefinition; }
1706 bool isOptimized() const { return IsOptimized; }
1707
1708 bool isArtificial() const { return getFlags() & FlagArtificial; }
1709 bool isPrivate() const {
1710 return (getFlags() & FlagAccessibility) == FlagPrivate;
1711 }
1712 bool isProtected() const {
1713 return (getFlags() & FlagAccessibility) == FlagProtected;
1714 }
1715 bool isPublic() const {
1716 return (getFlags() & FlagAccessibility) == FlagPublic;
1717 }
1718 bool isExplicit() const { return getFlags() & FlagExplicit; }
1719 bool isPrototyped() const { return getFlags() & FlagPrototyped; }
1720 bool isMainSubprogram() const { return getFlags() & FlagMainSubprogram; }
1721
1722 /// Check if this is reference-qualified.
1723 ///
1724 /// Return true if this subprogram is a C++11 reference-qualified non-static
1725 /// member function (void foo() &).
1726 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
1727
1728 /// Check if this is rvalue-reference-qualified.
1729 ///
1730 /// Return true if this subprogram is a C++11 rvalue-reference-qualified
1731 /// non-static member function (void foo() &&).
1732 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
1733
1734 /// Check if this is marked as noreturn.
1735 ///
1736 /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
1737 bool isNoReturn() const { return getFlags() & FlagNoReturn; }
1738
1739 // Check if this routine is a compiler-generated thunk.
1740 //
1741 // Returns true if this subprogram is a thunk generated by the compiler.
1742 bool isThunk() const { return getFlags() & FlagThunk; }
1743
1744 DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
1745
1746 StringRef getName() const { return getStringOperand(2); }
1747 StringRef getLinkageName() const { return getStringOperand(3); }
1748
1749 DISubroutineType *getType() const {
1750 return cast_or_null<DISubroutineType>(getRawType());
1751 }
1752 DITypeRef getContainingType() const {
1753 return DITypeRef(getRawContainingType());
1754 }
1755
1756 DICompileUnit *getUnit() const {
1757 return cast_or_null<DICompileUnit>(getRawUnit());
1758 }
1759 void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
1760 DITemplateParameterArray getTemplateParams() const {
1761 return cast_or_null<MDTuple>(getRawTemplateParams());
1762 }
1763 DISubprogram *getDeclaration() const {
1764 return cast_or_null<DISubprogram>(getRawDeclaration());
1765 }
1766 DINodeArray getRetainedNodes() const {
1767 return cast_or_null<MDTuple>(getRawRetainedNodes());
1768 }
1769 DITypeArray getThrownTypes() const {
1770 return cast_or_null<MDTuple>(getRawThrownTypes());
1771 }
1772
1773 Metadata *getRawScope() const { return getOperand(1); }
1774 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1775 MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
1776 Metadata *getRawType() const { return getOperand(4); }
1777 Metadata *getRawUnit() const { return getOperand(5); }
1778 Metadata *getRawDeclaration() const { return getOperand(6); }
1779 Metadata *getRawRetainedNodes() const { return getOperand(7); }
1780 Metadata *getRawContainingType() const {
1781 return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
1782 }
1783 Metadata *getRawTemplateParams() const {
1784 return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr;
1785 }
1786 Metadata *getRawThrownTypes() const {
1787 return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
1788 }
1789
1790 /// Check if this subprogram describes the given function.
1791 ///
1792 /// FIXME: Should this be looking through bitcasts?
1793 bool describes(const Function *F) const;
1794
1795 static bool classof(const Metadata *MD) {
1796 return MD->getMetadataID() == DISubprogramKind;
1797 }
1798};
1799
1800class DILexicalBlockBase : public DILocalScope {
1801protected:
1802 DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1803 ArrayRef<Metadata *> Ops)
1804 : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1805 ~DILexicalBlockBase() = default;
1806
1807public:
1808 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1809
1810 Metadata *getRawScope() const { return getOperand(1); }
1811
1812 static bool classof(const Metadata *MD) {
1813 return MD->getMetadataID() == DILexicalBlockKind ||
1814 MD->getMetadataID() == DILexicalBlockFileKind;
1815 }
1816};
1817
1818class DILexicalBlock : public DILexicalBlockBase {
1819 friend class LLVMContextImpl;
1820 friend class MDNode;
1821
1822 unsigned Line;
1823 uint16_t Column;
1824
1825 DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1826 unsigned Column, ArrayRef<Metadata *> Ops)
1827 : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
1828 Column(Column) {
1829 assert(Column < (1u << 16) && "Expected 16-bit column")(static_cast <bool> (Column < (1u << 16) &&
"Expected 16-bit column") ? void (0) : __assert_fail ("Column < (1u << 16) && \"Expected 16-bit column\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 1829, __extension__ __PRETTY_FUNCTION__))
;
1830 }
1831 ~DILexicalBlock() = default;
1832
1833 static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
1834 DIFile *File, unsigned Line, unsigned Column,
1835 StorageType Storage,
1836 bool ShouldCreate = true) {
1837 return getImpl(Context, static_cast<Metadata *>(Scope),
1838 static_cast<Metadata *>(File), Line, Column, Storage,
1839 ShouldCreate);
1840 }
1841
1842 static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1843 Metadata *File, unsigned Line, unsigned Column,
1844 StorageType Storage, bool ShouldCreate = true);
1845
1846 TempDILexicalBlock cloneImpl() const {
1847 return getTemporary(getContext(), getScope(), getFile(), getLine(),
1848 getColumn());
1849 }
1850
1851public:
1852 DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File,
1853 unsigned Line, unsigned Column),
1854 (Scope, File, Line, Column))
1855 DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File,
1856 unsigned Line, unsigned Column),
1857 (Scope, File, Line, Column))
1858
1859 TempDILexicalBlock clone() const { return cloneImpl(); }
1860
1861 unsigned getLine() const { return Line; }
1862 unsigned getColumn() const { return Column; }
1863
1864 static bool classof(const Metadata *MD) {
1865 return MD->getMetadataID() == DILexicalBlockKind;
1866 }
1867};
1868
1869class DILexicalBlockFile : public DILexicalBlockBase {
1870 friend class LLVMContextImpl;
1871 friend class MDNode;
1872
1873 unsigned Discriminator;
1874
1875 DILexicalBlockFile(LLVMContext &C, StorageType Storage,
1876 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1877 : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops),
1878 Discriminator(Discriminator) {}
1879 ~DILexicalBlockFile() = default;
1880
1881 static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope,
1882 DIFile *File, unsigned Discriminator,
1883 StorageType Storage,
1884 bool ShouldCreate = true) {
1885 return getImpl(Context, static_cast<Metadata *>(Scope),
1886 static_cast<Metadata *>(File), Discriminator, Storage,
1887 ShouldCreate);
1888 }
1889
1890 static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1891 Metadata *File, unsigned Discriminator,
1892 StorageType Storage,
1893 bool ShouldCreate = true);
1894
1895 TempDILexicalBlockFile cloneImpl() const {
1896 return getTemporary(getContext(), getScope(), getFile(),
1897 getDiscriminator());
1898 }
1899
1900public:
1901 DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File,
1902 unsigned Discriminator),
1903 (Scope, File, Discriminator))
1904 DEFINE_MDNODE_GET(DILexicalBlockFile,
1905 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1906 (Scope, File, Discriminator))
1907
1908 TempDILexicalBlockFile clone() const { return cloneImpl(); }
1909
1910 // TODO: Remove these once they're gone from DILexicalBlockBase.
1911 unsigned getLine() const = delete;
1912 unsigned getColumn() const = delete;
1913
1914 unsigned getDiscriminator() const { return Discriminator; }
1915
1916 static bool classof(const Metadata *MD) {
1917 return MD->getMetadataID() == DILexicalBlockFileKind;
1918 }
1919};
1920
1921unsigned DILocation::getDiscriminator() const {
1922 if (auto *F = dyn_cast<DILexicalBlockFile>(getScope()))
1923 return F->getDiscriminator();
1924 return 0;
1925}
1926
1927const DILocation *
1928DILocation::cloneWithDiscriminator(unsigned Discriminator) const {
1929 DIScope *Scope = getScope();
1930 // Skip all parent DILexicalBlockFile that already have a discriminator
1931 // assigned. We do not want to have nested DILexicalBlockFiles that have
1932 // mutliple discriminators because only the leaf DILexicalBlockFile's
1933 // dominator will be used.
1934 for (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope);
1935 LBF && LBF->getDiscriminator() != 0;
1936 LBF = dyn_cast<DILexicalBlockFile>(Scope))
1937 Scope = LBF->getScope();
1938 DILexicalBlockFile *NewScope =
1939 DILexicalBlockFile::get(getContext(), Scope, getFile(), Discriminator);
1940 return DILocation::get(getContext(), getLine(), getColumn(), NewScope,
1941 getInlinedAt());
1942}
1943
1944unsigned DILocation::getBaseDiscriminator() const {
1945 return getBaseDiscriminatorFromDiscriminator(getDiscriminator());
1946}
1947
1948unsigned DILocation::getDuplicationFactor() const {
1949 return getDuplicationFactorFromDiscriminator(getDiscriminator());
1950}
1951
1952unsigned DILocation::getCopyIdentifier() const {
1953 return getCopyIdentifierFromDiscriminator(getDiscriminator());
1954}
1955
1956const DILocation *DILocation::setBaseDiscriminator(unsigned D) const {
1957 if (D == 0)
1958 return this;
1959 else
1960 return cloneWithDiscriminator(getPrefixEncodingFromUnsigned(D) << 1);
1961}
1962
1963const DILocation *DILocation::cloneWithDuplicationFactor(unsigned DF) const {
1964 DF *= getDuplicationFactor();
1965 if (DF <= 1)
1966 return this;
1967
1968 unsigned BD = getBaseDiscriminator();
1969 unsigned CI = getCopyIdentifier() << (DF > 0x1f ? 14 : 7);
1970 unsigned D = CI | (getPrefixEncodingFromUnsigned(DF) << 1);
1971
1972 if (BD == 0)
1973 D = (D << 1) | 1;
1974 else
1975 D = (D << (BD > 0x1f ? 14 : 7)) | (getPrefixEncodingFromUnsigned(BD) << 1);
1976
1977 return cloneWithDiscriminator(D);
1978}
1979
1980class DINamespace : public DIScope {
1981 friend class LLVMContextImpl;
1982 friend class MDNode;
1983
1984 unsigned ExportSymbols : 1;
1985
1986 DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols,
1987 ArrayRef<Metadata *> Ops)
1988 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,
1989 Ops),
1990 ExportSymbols(ExportSymbols) {}
1991 ~DINamespace() = default;
1992
1993 static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope,
1994 StringRef Name, bool ExportSymbols,
1995 StorageType Storage, bool ShouldCreate = true) {
1996 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1997 ExportSymbols, Storage, ShouldCreate);
1998 }
1999 static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope,
2000 MDString *Name, bool ExportSymbols,
2001 StorageType Storage, bool ShouldCreate = true);
2002
2003 TempDINamespace cloneImpl() const {
2004 return getTemporary(getContext(), getScope(), getName(),
2005 getExportSymbols());
2006 }
2007
2008public:
2009 DEFINE_MDNODE_GET(DINamespace,
2010 (DIScope *Scope, StringRef Name, bool ExportSymbols),
2011 (Scope, Name, ExportSymbols))
2012 DEFINE_MDNODE_GET(DINamespace,
2013 (Metadata *Scope, MDString *Name, bool ExportSymbols),
2014 (Scope, Name, ExportSymbols))
2015
2016 TempDINamespace clone() const { return cloneImpl(); }
2017
2018 bool getExportSymbols() const { return ExportSymbols; }
2019 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2020 StringRef getName() const { return getStringOperand(2); }
2021
2022 Metadata *getRawScope() const { return getOperand(1); }
2023 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2024
2025 static bool classof(const Metadata *MD) {
2026 return MD->getMetadataID() == DINamespaceKind;
2027 }
2028};
2029
2030/// A (clang) module that has been imported by the compile unit.
2031///
2032class DIModule : public DIScope {
2033 friend class LLVMContextImpl;
2034 friend class MDNode;
2035
2036 DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
2037 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
2038 ~DIModule() = default;
2039
2040 static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
2041 StringRef Name, StringRef ConfigurationMacros,
2042 StringRef IncludePath, StringRef ISysRoot,
2043 StorageType Storage, bool ShouldCreate = true) {
2044 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2045 getCanonicalMDString(Context, ConfigurationMacros),
2046 getCanonicalMDString(Context, IncludePath),
2047 getCanonicalMDString(Context, ISysRoot),
2048 Storage, ShouldCreate);
2049 }
2050 static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
2051 MDString *Name, MDString *ConfigurationMacros,
2052 MDString *IncludePath, MDString *ISysRoot,
2053 StorageType Storage, bool ShouldCreate = true);
2054
2055 TempDIModule cloneImpl() const {
2056 return getTemporary(getContext(), getScope(), getName(),
2057 getConfigurationMacros(), getIncludePath(),
2058 getISysRoot());
2059 }
2060
2061public:
2062 DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name,
2063 StringRef ConfigurationMacros, StringRef IncludePath,
2064 StringRef ISysRoot),
2065 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
2066 DEFINE_MDNODE_GET(DIModule,
2067 (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
2068 MDString *IncludePath, MDString *ISysRoot),
2069 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
2070
2071 TempDIModule clone() const { return cloneImpl(); }
2072
2073 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2074 StringRef getName() const { return getStringOperand(1); }
2075 StringRef getConfigurationMacros() const { return getStringOperand(2); }
2076 StringRef getIncludePath() const { return getStringOperand(3); }
2077 StringRef getISysRoot() const { return getStringOperand(4); }
2078
2079 Metadata *getRawScope() const { return getOperand(0); }
2080 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2081 MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
2082 MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
2083 MDString *getRawISysRoot() const { return getOperandAs<MDString>(4); }
2084
2085 static bool classof(const Metadata *MD) {
2086 return MD->getMetadataID() == DIModuleKind;
2087 }
2088};
2089
2090/// Base class for template parameters.
2091class DITemplateParameter : public DINode {
2092protected:
2093 DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
2094 unsigned Tag, ArrayRef<Metadata *> Ops)
2095 : DINode(Context, ID, Storage, Tag, Ops) {}
2096 ~DITemplateParameter() = default;
2097
2098public:
2099 StringRef getName() const { return getStringOperand(0); }
2100 DITypeRef getType() const { return DITypeRef(getRawType()); }
2101
2102 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2103 Metadata *getRawType() const { return getOperand(1); }
2104
2105 static bool classof(const Metadata *MD) {
2106 return MD->getMetadataID() == DITemplateTypeParameterKind ||
2107 MD->getMetadataID() == DITemplateValueParameterKind;
2108 }
2109};
2110
2111class DITemplateTypeParameter : public DITemplateParameter {
2112 friend class LLVMContextImpl;
2113 friend class MDNode;
2114
2115 DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
2116 ArrayRef<Metadata *> Ops)
2117 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
2118 dwarf::DW_TAG_template_type_parameter, Ops) {}
2119 ~DITemplateTypeParameter() = default;
2120
2121 static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
2122 DITypeRef Type, StorageType Storage,
2123 bool ShouldCreate = true) {
2124 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
2125 ShouldCreate);
2126 }
2127 static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
2128 Metadata *Type, StorageType Storage,
2129 bool ShouldCreate = true);
2130
2131 TempDITemplateTypeParameter cloneImpl() const {
2132 return getTemporary(getContext(), getName(), getType());
2133 }
2134
2135public:
2136 DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DITypeRef Type),
2137 (Name, Type))
2138 DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
2139 (Name, Type))
2140
2141 TempDITemplateTypeParameter clone() const { return cloneImpl(); }
2142
2143 static bool classof(const Metadata *MD) {
2144 return MD->getMetadataID() == DITemplateTypeParameterKind;
2145 }
2146};
2147
2148class DITemplateValueParameter : public DITemplateParameter {
2149 friend class LLVMContextImpl;
2150 friend class MDNode;
2151
2152 DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
2153 unsigned Tag, ArrayRef<Metadata *> Ops)
2154 : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
2155 Ops) {}
2156 ~DITemplateValueParameter() = default;
2157
2158 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2159 StringRef Name, DITypeRef Type,
2160 Metadata *Value, StorageType Storage,
2161 bool ShouldCreate = true) {
2162 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
2163 Value, Storage, ShouldCreate);
2164 }
2165 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2166 MDString *Name, Metadata *Type,
2167 Metadata *Value, StorageType Storage,
2168 bool ShouldCreate = true);
2169
2170 TempDITemplateValueParameter cloneImpl() const {
2171 return getTemporary(getContext(), getTag(), getName(), getType(),
2172 getValue());
2173 }
2174
2175public:
2176 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, StringRef Name,
2177 DITypeRef Type, Metadata *Value),
2178 (Tag, Name, Type, Value))
2179 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
2180 Metadata *Type, Metadata *Value),
2181 (Tag, Name, Type, Value))
2182
2183 TempDITemplateValueParameter clone() const { return cloneImpl(); }
2184
2185 Metadata *getValue() const { return getOperand(2); }
2186
2187 static bool classof(const Metadata *MD) {
2188 return MD->getMetadataID() == DITemplateValueParameterKind;
2189 }
2190};
2191
2192/// Base class for variables.
2193class DIVariable : public DINode {
2194 unsigned Line;
2195 uint32_t AlignInBits;
2196
2197protected:
2198 DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line,
2199 ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0)
2200 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
2201 AlignInBits(AlignInBits) {}
2202 ~DIVariable() = default;
2203
2204public:
2205 unsigned getLine() const { return Line; }
2206 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2207 StringRef getName() const { return getStringOperand(1); }
2208 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2209 DITypeRef getType() const { return DITypeRef(getRawType()); }
2210 uint32_t getAlignInBits() const { return AlignInBits; }
2211 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT8; }
2212 /// Determines the size of the variable's type.
2213 Optional<uint64_t> getSizeInBits() const;
2214
2215 /// Return the signedness of this variable's type, or None if this type is
2216 /// neither signed nor unsigned.
2217 Optional<DIBasicType::Signedness> getSignedness() const {
2218 if (auto *BT = dyn_cast<DIBasicType>(getType().resolve()))
2219 return BT->getSignedness();
2220 return None;
2221 }
2222
2223 StringRef getFilename() const {
2224 if (auto *F = getFile())
2225 return F->getFilename();
2226 return "";
2227 }
2228
2229 StringRef getDirectory() const {
2230 if (auto *F = getFile())
2231 return F->getDirectory();
2232 return "";
2233 }
2234
2235 Optional<StringRef> getSource() const {
2236 if (auto *F = getFile())
2237 return F->getSource();
2238 return None;
2239 }
2240
2241 Metadata *getRawScope() const { return getOperand(0); }
2242 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2243 Metadata *getRawFile() const { return getOperand(2); }
2244 Metadata *getRawType() const { return getOperand(3); }
2245
2246 static bool classof(const Metadata *MD) {
2247 return MD->getMetadataID() == DILocalVariableKind ||
2248 MD->getMetadataID() == DIGlobalVariableKind;
2249 }
2250};
2251
2252/// DWARF expression.
2253///
2254/// This is (almost) a DWARF expression that modifies the location of a
2255/// variable, or the location of a single piece of a variable, or (when using
2256/// DW_OP_stack_value) is the constant variable value.
2257///
2258/// TODO: Co-allocate the expression elements.
2259/// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
2260/// storage types.
2261class DIExpression : public MDNode {
2262 friend class LLVMContextImpl;
2263 friend class MDNode;
2264
2265 std::vector<uint64_t> Elements;
2266
2267 DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
2268 : MDNode(C, DIExpressionKind, Storage, None),
2269 Elements(Elements.begin(), Elements.end()) {}
2270 ~DIExpression() = default;
2271
2272 static DIExpression *getImpl(LLVMContext &Context,
2273 ArrayRef<uint64_t> Elements, StorageType Storage,
2274 bool ShouldCreate = true);
2275
2276 TempDIExpression cloneImpl() const {
2277 return getTemporary(getContext(), getElements());
2278 }
2279
2280public:
2281 DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
2282
2283 TempDIExpression clone() const { return cloneImpl(); }
2284
2285 ArrayRef<uint64_t> getElements() const { return Elements; }
2286
2287 unsigned getNumElements() const { return Elements.size(); }
2288
2289 uint64_t getElement(unsigned I) const {
2290 assert(I < Elements.size() && "Index out of range")(static_cast <bool> (I < Elements.size() && "Index out of range"
) ? void (0) : __assert_fail ("I < Elements.size() && \"Index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 2290, __extension__ __PRETTY_FUNCTION__))
;
2291 return Elements[I];
2292 }
2293
2294 /// Determine whether this represents a standalone constant value.
2295 bool isConstant() const;
2296
2297 using element_iterator = ArrayRef<uint64_t>::iterator;
2298
2299 element_iterator elements_begin() const { return getElements().begin(); }
2300 element_iterator elements_end() const { return getElements().end(); }
2301
2302 /// A lightweight wrapper around an expression operand.
2303 ///
2304 /// TODO: Store arguments directly and change \a DIExpression to store a
2305 /// range of these.
2306 class ExprOperand {
2307 const uint64_t *Op = nullptr;
2308
2309 public:
2310 ExprOperand() = default;
2311 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
2312
2313 const uint64_t *get() const { return Op; }
2314
2315 /// Get the operand code.
2316 uint64_t getOp() const { return *Op; }
2317
2318 /// Get an argument to the operand.
2319 ///
2320 /// Never returns the operand itself.
2321 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
2322
2323 unsigned getNumArgs() const { return getSize() - 1; }
2324
2325 /// Return the size of the operand.
2326 ///
2327 /// Return the number of elements in the operand (1 + args).
2328 unsigned getSize() const;
2329
2330 /// Append the elements of this operand to \p V.
2331 void appendToVector(SmallVectorImpl<uint64_t> &V) const {
2332 V.append(get(), get() + getSize());
2333 }
2334 };
2335
2336 /// An iterator for expression operands.
2337 class expr_op_iterator
2338 : public std::iterator<std::input_iterator_tag, ExprOperand> {
2339 ExprOperand Op;
2340
2341 public:
2342 expr_op_iterator() = default;
2343 explicit expr_op_iterator(element_iterator I) : Op(I) {}
2344
2345 element_iterator getBase() const { return Op.get(); }
2346 const ExprOperand &operator*() const { return Op; }
2347 const ExprOperand *operator->() const { return &Op; }
2348
2349 expr_op_iterator &operator++() {
2350 increment();
2351 return *this;
2352 }
2353 expr_op_iterator operator++(int) {
2354 expr_op_iterator T(*this);
2355 increment();
2356 return T;
2357 }
2358
2359 /// Get the next iterator.
2360 ///
2361 /// \a std::next() doesn't work because this is technically an
2362 /// input_iterator, but it's a perfectly valid operation. This is an
2363 /// accessor to provide the same functionality.
2364 expr_op_iterator getNext() const { return ++expr_op_iterator(*this); }
2365
2366 bool operator==(const expr_op_iterator &X) const {
2367 return getBase() == X.getBase();
2368 }
2369 bool operator!=(const expr_op_iterator &X) const {
2370 return getBase() != X.getBase();
2371 }
2372
2373 private:
2374 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
2375 };
2376
2377 /// Visit the elements via ExprOperand wrappers.
2378 ///
2379 /// These range iterators visit elements through \a ExprOperand wrappers.
2380 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
2381 /// true.
2382 ///
2383 /// \pre \a isValid() gives \c true.
2384 /// @{
2385 expr_op_iterator expr_op_begin() const {
2386 return expr_op_iterator(elements_begin());
2387 }
2388 expr_op_iterator expr_op_end() const {
2389 return expr_op_iterator(elements_end());
2390 }
2391 iterator_range<expr_op_iterator> expr_ops() const {
2392 return {expr_op_begin(), expr_op_end()};
2393 }
2394 /// @}
2395
2396 bool isValid() const;
2397
2398 static bool classof(const Metadata *MD) {
2399 return MD->getMetadataID() == DIExpressionKind;
2400 }
2401
2402 /// Return whether the first element a DW_OP_deref.
2403 bool startsWithDeref() const {
2404 return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
2405 }
2406
2407 /// Holds the characteristics of one fragment of a larger variable.
2408 struct FragmentInfo {
2409 uint64_t SizeInBits;
2410 uint64_t OffsetInBits;
2411 };
2412
2413 /// Retrieve the details of this fragment expression.
2414 static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start,
2415 expr_op_iterator End);
2416
2417 /// Retrieve the details of this fragment expression.
2418 Optional<FragmentInfo> getFragmentInfo() const {
2419 return getFragmentInfo(expr_op_begin(), expr_op_end());
2420 }
2421
2422 /// Return whether this is a piece of an aggregate variable.
2423 bool isFragment() const { return getFragmentInfo().hasValue(); }
2424
2425 /// Append \p Ops with operations to apply the \p Offset.
2426 static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset);
2427
2428 /// If this is a constant offset, extract it. If there is no expression,
2429 /// return true with an offset of zero.
2430 bool extractIfOffset(int64_t &Offset) const;
2431
2432 /// Constants for DIExpression::prepend.
2433 enum { NoDeref = false, WithDeref = true, WithStackValue = true };
2434
2435 /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
2436 /// into a stack value.
2437 static DIExpression *prepend(const DIExpression *Expr, bool DerefBefore,
2438 int64_t Offset = 0, bool DerefAfter = false,
2439 bool StackValue = false);
2440
2441 /// Prepend \p DIExpr with the given opcodes and optionally turn it into a
2442 /// stack value.
2443 static DIExpression *prependOpcodes(const DIExpression *Expr,
2444 SmallVectorImpl<uint64_t> &Ops,
2445 bool StackValue = false);
2446
2447 /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the
2448 /// returned expression is a stack value only if \p DIExpr is a stack value.
2449 /// If \p DIExpr describes a fragment, the returned expression will describe
2450 /// the same fragment.
2451 static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops);
2452
2453 /// Convert \p DIExpr into a stack value if it isn't one already by appending
2454 /// DW_OP_deref if needed, and appending \p Ops to the resulting expression.
2455 /// If \p DIExpr describes a fragment, the returned expression will describe
2456 /// the same fragment.
2457 static DIExpression *appendToStack(const DIExpression *Expr,
2458 ArrayRef<uint64_t> Ops);
2459
2460 /// Create a DIExpression to describe one part of an aggregate variable that
2461 /// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation
2462 /// will be appended to the elements of \c Expr. If \c Expr already contains
2463 /// a \c DW_OP_LLVM_fragment \c OffsetInBits is interpreted as an offset
2464 /// into the existing fragment.
2465 ///
2466 /// \param OffsetInBits Offset of the piece in bits.
2467 /// \param SizeInBits Size of the piece in bits.
2468 /// \return Creating a fragment expression may fail if \c Expr
2469 /// contains arithmetic operations that would be truncated.
2470 static Optional<DIExpression *>
2471 createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits,
2472 unsigned SizeInBits);
2473
2474 /// Determine the relative position of the fragments described by this
2475 /// DIExpression and \p Other.
2476 /// Returns -1 if this is entirely before Other, 0 if this and Other overlap,
2477 /// 1 if this is entirely after Other.
2478 int fragmentCmp(const DIExpression *Other) const {
2479 auto Fragment1 = *getFragmentInfo();
2480 auto Fragment2 = *Other->getFragmentInfo();
2481 unsigned l1 = Fragment1.OffsetInBits;
2482 unsigned l2 = Fragment2.OffsetInBits;
2483 unsigned r1 = l1 + Fragment1.SizeInBits;
2484 unsigned r2 = l2 + Fragment2.SizeInBits;
2485 if (r1 <= l2)
2486 return -1;
2487 else if (r2 <= l1)
2488 return 1;
2489 else
2490 return 0;
2491 }
2492
2493 /// Check if fragments overlap between this DIExpression and \p Other.
2494 bool fragmentsOverlap(const DIExpression *Other) const {
2495 if (!isFragment() || !Other->isFragment())
2496 return true;
2497 return fragmentCmp(Other) == 0;
2498 }
2499};
2500
2501/// Global variables.
2502///
2503/// TODO: Remove DisplayName. It's always equal to Name.
2504class DIGlobalVariable : public DIVariable {
2505 friend class LLVMContextImpl;
2506 friend class MDNode;
2507
2508 bool IsLocalToUnit;
2509 bool IsDefinition;
2510
2511 DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2512 bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits,
2513 ArrayRef<Metadata *> Ops)
2514 : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits),
2515 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
2516 ~DIGlobalVariable() = default;
2517
2518 static DIGlobalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
2519 StringRef Name, StringRef LinkageName,
2520 DIFile *File, unsigned Line, DITypeRef Type,
2521 bool IsLocalToUnit, bool IsDefinition,
2522 DIDerivedType *StaticDataMemberDeclaration,
2523 uint32_t AlignInBits, StorageType Storage,
2524 bool ShouldCreate = true) {
2525 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2526 getCanonicalMDString(Context, LinkageName), File, Line, Type,
2527 IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
2528 AlignInBits, Storage, ShouldCreate);
2529 }
2530 static DIGlobalVariable *
2531 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
2532 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
2533 bool IsLocalToUnit, bool IsDefinition,
2534 Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits,
2535 StorageType Storage, bool ShouldCreate = true);
2536
2537 TempDIGlobalVariable cloneImpl() const {
2538 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
2539 getFile(), getLine(), getType(), isLocalToUnit(),
2540 isDefinition(), getStaticDataMemberDeclaration(),
2541 getAlignInBits());
2542 }
2543
2544public:
2545 DEFINE_MDNODE_GET(DIGlobalVariable,
2546 (DIScope * Scope, StringRef Name, StringRef LinkageName,
2547 DIFile *File, unsigned Line, DITypeRef Type,
2548 bool IsLocalToUnit, bool IsDefinition,
2549 DIDerivedType *StaticDataMemberDeclaration,
2550 uint32_t AlignInBits),
2551 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2552 IsDefinition, StaticDataMemberDeclaration, AlignInBits))
2553 DEFINE_MDNODE_GET(DIGlobalVariable,
2554 (Metadata * Scope, MDString *Name, MDString *LinkageName,
2555 Metadata *File, unsigned Line, Metadata *Type,
2556 bool IsLocalToUnit, bool IsDefinition,
2557 Metadata *StaticDataMemberDeclaration,
2558 uint32_t AlignInBits),
2559 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2560 IsDefinition, StaticDataMemberDeclaration, AlignInBits))
2561
2562 TempDIGlobalVariable clone() const { return cloneImpl(); }
2563
2564 bool isLocalToUnit() const { return IsLocalToUnit; }
2565 bool isDefinition() const { return IsDefinition; }
2566 StringRef getDisplayName() const { return getStringOperand(4); }
2567 StringRef getLinkageName() const { return getStringOperand(5); }
2568 DIDerivedType *getStaticDataMemberDeclaration() const {
2569 return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
2570 }
2571
2572 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
2573 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
2574
2575 static bool classof(const Metadata *MD) {
2576 return MD->getMetadataID() == DIGlobalVariableKind;
2577 }
2578};
2579
2580/// Local variable.
2581///
2582/// TODO: Split up flags.
2583class DILocalVariable : public DIVariable {
2584 friend class LLVMContextImpl;
2585 friend class MDNode;
2586
2587 unsigned Arg : 16;
2588 DIFlags Flags;
2589
2590 DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2591 unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
2592 ArrayRef<Metadata *> Ops)
2593 : DIVariable(C, DILocalVariableKind, Storage, Line, Ops, AlignInBits),
2594 Arg(Arg), Flags(Flags) {
2595 assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range")(static_cast <bool> (Arg < (1 << 16) &&
"DILocalVariable: Arg out of range") ? void (0) : __assert_fail
("Arg < (1 << 16) && \"DILocalVariable: Arg out of range\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 2595, __extension__ __PRETTY_FUNCTION__))
;
2596 }
2597 ~DILocalVariable() = default;
2598
2599 static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
2600 StringRef Name, DIFile *File, unsigned Line,
2601 DITypeRef Type, unsigned Arg, DIFlags Flags,
2602 uint32_t AlignInBits, StorageType Storage,
2603 bool ShouldCreate = true) {
2604 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2605 Line, Type, Arg, Flags, AlignInBits, Storage, ShouldCreate);
2606 }
2607 static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope,
2608 MDString *Name, Metadata *File, unsigned Line,
2609 Metadata *Type, unsigned Arg, DIFlags Flags,
2610 uint32_t AlignInBits, StorageType Storage,
2611 bool ShouldCreate = true);
2612
2613 TempDILocalVariable cloneImpl() const {
2614 return getTemporary(getContext(), getScope(), getName(), getFile(),
2615 getLine(), getType(), getArg(), getFlags(),
2616 getAlignInBits());
2617 }
2618
2619public:
2620 DEFINE_MDNODE_GET(DILocalVariable,
2621 (DILocalScope * Scope, StringRef Name, DIFile *File,
2622 unsigned Line, DITypeRef Type, unsigned Arg,
2623 DIFlags Flags, uint32_t AlignInBits),
2624 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2625 DEFINE_MDNODE_GET(DILocalVariable,
2626 (Metadata * Scope, MDString *Name, Metadata *File,
2627 unsigned Line, Metadata *Type, unsigned Arg,
2628 DIFlags Flags, uint32_t AlignInBits),
2629 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2630
2631 TempDILocalVariable clone() const { return cloneImpl(); }
2632
2633 /// Get the local scope for this variable.
2634 ///
2635 /// Variables must be defined in a local scope.
2636 DILocalScope *getScope() const {
2637 return cast<DILocalScope>(DIVariable::getScope());
2638 }
2639
2640 bool isParameter() const { return Arg; }
2641 unsigned getArg() const { return Arg; }
2642 DIFlags getFlags() const { return Flags; }
2643
2644 bool isArtificial() const { return getFlags() & FlagArtificial; }
2645 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
2646
2647 /// Check that a location is valid for this variable.
2648 ///
2649 /// Check that \c DL exists, is in the same subprogram, and has the same
2650 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2651 /// to a \a DbgInfoIntrinsic.)
2652 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2653 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2654 }
2655
2656 static bool classof(const Metadata *MD) {
2657 return MD->getMetadataID() == DILocalVariableKind;
2658 }
2659};
2660
2661/// Label.
2662///
2663class DILabel : public DINode {
2664 friend class LLVMContextImpl;
2665 friend class MDNode;
2666
2667 unsigned Line;
2668
2669 DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
2670 ArrayRef<Metadata *> Ops)
2671 : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
2672 ~DILabel() = default;
2673
2674 static DILabel *getImpl(LLVMContext &Context, DIScope *Scope,
2675 StringRef Name, DIFile *File, unsigned Line,
2676 StorageType Storage,
2677 bool ShouldCreate = true) {
2678 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2679 Line, Storage, ShouldCreate);
2680 }
2681 static DILabel *getImpl(LLVMContext &Context, Metadata *Scope,
2682 MDString *Name, Metadata *File, unsigned Line,
2683 StorageType Storage,
2684 bool ShouldCreate = true);
2685
2686 TempDILabel cloneImpl() const {
2687 return getTemporary(getContext(), getScope(), getName(), getFile(),
2688 getLine());
2689 }
2690
2691public:
2692 DEFINE_MDNODE_GET(DILabel,
2693 (DILocalScope * Scope, StringRef Name, DIFile *File,
2694 unsigned Line),
2695 (Scope, Name, File, Line))
2696 DEFINE_MDNODE_GET(DILabel,
2697 (Metadata * Scope, MDString *Name, Metadata *File,
2698 unsigned Line),
2699 (Scope, Name, File, Line))
2700
2701 TempDILabel clone() const { return cloneImpl(); }
2702
2703 /// Get the local scope for this label.
2704 ///
2705 /// Labels must be defined in a local scope.
2706 DILocalScope *getScope() const {
2707 return cast_or_null<DILocalScope>(getRawScope());
2708 }
2709 unsigned getLine() const { return Line; }
2710 StringRef getName() const { return getStringOperand(1); }
2711 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2712
2713 Metadata *getRawScope() const { return getOperand(0); }
2714 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2715 Metadata *getRawFile() const { return getOperand(2); }
2716
2717 /// Check that a location is valid for this label.
2718 ///
2719 /// Check that \c DL exists, is in the same subprogram, and has the same
2720 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2721 /// to a \a DbgInfoIntrinsic.)
2722 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2723 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2724 }
2725
2726 static bool classof(const Metadata *MD) {
2727 return MD->getMetadataID() == DILabelKind;
2728 }
2729};
2730
2731class DIObjCProperty : public DINode {
2732 friend class LLVMContextImpl;
2733 friend class MDNode;
2734
2735 unsigned Line;
2736 unsigned Attributes;
2737
2738 DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
2739 unsigned Attributes, ArrayRef<Metadata *> Ops)
2740 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
2741 Ops),
2742 Line(Line), Attributes(Attributes) {}
2743 ~DIObjCProperty() = default;
2744
2745 static DIObjCProperty *
2746 getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
2747 StringRef GetterName, StringRef SetterName, unsigned Attributes,
2748 DITypeRef Type, StorageType Storage, bool ShouldCreate = true) {
2749 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
2750 getCanonicalMDString(Context, GetterName),
2751 getCanonicalMDString(Context, SetterName), Attributes, Type,
2752 Storage, ShouldCreate);
2753 }
2754 static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
2755 Metadata *File, unsigned Line,
2756 MDString *GetterName, MDString *SetterName,
2757 unsigned Attributes, Metadata *Type,
2758 StorageType Storage, bool ShouldCreate = true);
2759
2760 TempDIObjCProperty cloneImpl() const {
2761 return getTemporary(getContext(), getName(), getFile(), getLine(),
2762 getGetterName(), getSetterName(), getAttributes(),
2763 getType());
2764 }
2765
2766public:
2767 DEFINE_MDNODE_GET(DIObjCProperty,
2768 (StringRef Name, DIFile *File, unsigned Line,
2769 StringRef GetterName, StringRef SetterName,
2770 unsigned Attributes, DITypeRef Type),
2771 (Name, File, Line, GetterName, SetterName, Attributes,
2772 Type))
2773 DEFINE_MDNODE_GET(DIObjCProperty,
2774 (MDString * Name, Metadata *File, unsigned Line,
2775 MDString *GetterName, MDString *SetterName,
2776 unsigned Attributes, Metadata *Type),
2777 (Name, File, Line, GetterName, SetterName, Attributes,
2778 Type))
2779
2780 TempDIObjCProperty clone() const { return cloneImpl(); }
2781
2782 unsigned getLine() const { return Line; }
2783 unsigned getAttributes() const { return Attributes; }
2784 StringRef getName() const { return getStringOperand(0); }
2785 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2786 StringRef getGetterName() const { return getStringOperand(2); }
2787 StringRef getSetterName() const { return getStringOperand(3); }
2788 DITypeRef getType() const { return DITypeRef(getRawType()); }
2789
2790 StringRef getFilename() const {
2791 if (auto *F = getFile())
2792 return F->getFilename();
2793 return "";
2794 }
2795
2796 StringRef getDirectory() const {
2797 if (auto *F = getFile())
2798 return F->getDirectory();
2799 return "";
2800 }
2801
2802 Optional<StringRef> getSource() const {
2803 if (auto *F = getFile())
2804 return F->getSource();
2805 return None;
2806 }
2807
2808 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2809 Metadata *getRawFile() const { return getOperand(1); }
2810 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
2811 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
2812 Metadata *getRawType() const { return getOperand(4); }
2813
2814 static bool classof(const Metadata *MD) {
2815 return MD->getMetadataID() == DIObjCPropertyKind;
2816 }
2817};
2818
2819/// An imported module (C++ using directive or similar).
2820class DIImportedEntity : public DINode {
2821 friend class LLVMContextImpl;
2822 friend class MDNode;
2823
2824 unsigned Line;
2825
2826 DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
2827 unsigned Line, ArrayRef<Metadata *> Ops)
2828 : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
2829 ~DIImportedEntity() = default;
2830
2831 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
2832 DIScope *Scope, DINodeRef Entity,
2833 DIFile *File, unsigned Line, StringRef Name,
2834 StorageType Storage,
2835 bool ShouldCreate = true) {
2836 return getImpl(Context, Tag, Scope, Entity, File, Line,
2837 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
2838 }
2839 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
2840 Metadata *Scope, Metadata *Entity,
2841 Metadata *File, unsigned Line,
2842 MDString *Name, StorageType Storage,
2843 bool ShouldCreate = true);
2844
2845 TempDIImportedEntity cloneImpl() const {
2846 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
2847 getFile(), getLine(), getName());
2848 }
2849
2850public:
2851 DEFINE_MDNODE_GET(DIImportedEntity,
2852 (unsigned Tag, DIScope *Scope, DINodeRef Entity,
2853 DIFile *File, unsigned Line, StringRef Name = ""),
2854 (Tag, Scope, Entity, File, Line, Name))
2855 DEFINE_MDNODE_GET(DIImportedEntity,
2856 (unsigned Tag, Metadata *Scope, Metadata *Entity,
2857 Metadata *File, unsigned Line, MDString *Name),
2858 (Tag, Scope, Entity, File, Line, Name))
2859
2860 TempDIImportedEntity clone() const { return cloneImpl(); }
2861
2862 unsigned getLine() const { return Line; }
2863 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2864 DINodeRef getEntity() const { return DINodeRef(getRawEntity()); }
2865 StringRef getName() const { return getStringOperand(2); }
2866 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2867
2868 Metadata *getRawScope() const { return getOperand(0); }
2869 Metadata *getRawEntity() const { return getOperand(1); }
2870 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2871 Metadata *getRawFile() const { return getOperand(3); }
2872
2873 static bool classof(const Metadata *MD) {
2874 return MD->getMetadataID() == DIImportedEntityKind;
2875 }
2876};
2877
2878/// A pair of DIGlobalVariable and DIExpression.
2879class DIGlobalVariableExpression : public MDNode {
2880 friend class LLVMContextImpl;
2881 friend class MDNode;
2882
2883 DIGlobalVariableExpression(LLVMContext &C, StorageType Storage,
2884 ArrayRef<Metadata *> Ops)
2885 : MDNode(C, DIGlobalVariableExpressionKind, Storage, Ops) {}
2886 ~DIGlobalVariableExpression() = default;
2887
2888 static DIGlobalVariableExpression *
2889 getImpl(LLVMContext &Context, Metadata *Variable, Metadata *Expression,
2890 StorageType Storage, bool ShouldCreate = true);
2891
2892 TempDIGlobalVariableExpression cloneImpl() const {
2893 return getTemporary(getContext(), getVariable(), getExpression());
2894 }
2895
2896public:
2897 DEFINE_MDNODE_GET(DIGlobalVariableExpression,
2898 (Metadata * Variable, Metadata *Expression),
2899 (Variable, Expression))
2900
2901 TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
2902
2903 Metadata *getRawVariable() const { return getOperand(0); }
2904
2905 DIGlobalVariable *getVariable() const {
2906 return cast_or_null<DIGlobalVariable>(getRawVariable());
2907 }
2908
2909 Metadata *getRawExpression() const { return getOperand(1); }
2910
2911 DIExpression *getExpression() const {
2912 return cast<DIExpression>(getRawExpression());
2913 }
2914
2915 static bool classof(const Metadata *MD) {
2916 return MD->getMetadataID() == DIGlobalVariableExpressionKind;
2917 }
2918};
2919
2920/// Macro Info DWARF-like metadata node.
2921///
2922/// A metadata node with a DWARF macro info (i.e., a constant named
2923/// \c DW_MACINFO_*, defined in llvm/BinaryFormat/Dwarf.h). Called \a
2924/// DIMacroNode
2925/// because it's potentially used for non-DWARF output.
2926class DIMacroNode : public MDNode {
2927 friend class LLVMContextImpl;
2928 friend class MDNode;
2929
2930protected:
2931 DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType,
2932 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
2933 : MDNode(C, ID, Storage, Ops1, Ops2) {
2934 assert(MIType < 1u << 16)(static_cast <bool> (MIType < 1u << 16) ? void
(0) : __assert_fail ("MIType < 1u << 16", "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 2934, __extension__ __PRETTY_FUNCTION__))
;
2935 SubclassData16 = MIType;
2936 }
2937 ~DIMacroNode() = default;
2938
2939 template <class Ty> Ty *getOperandAs(unsigned I) const {
2940 return cast_or_null<Ty>(getOperand(I));
2941 }
2942
2943 StringRef getStringOperand(unsigned I) const {
2944 if (auto *S = getOperandAs<MDString>(I))
2945 return S->getString();
2946 return StringRef();
2947 }
2948
2949 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
2950 if (S.empty())
2951 return nullptr;
2952 return MDString::get(Context, S);
2953 }
2954
2955public:
2956 unsigned getMacinfoType() const { return SubclassData16; }
2957
2958 static bool classof(const Metadata *MD) {
2959 switch (MD->getMetadataID()) {
2960 default:
2961 return false;
2962 case DIMacroKind:
2963 case DIMacroFileKind:
2964 return true;
2965 }
2966 }
2967};
2968
2969class DIMacro : public DIMacroNode {
2970 friend class LLVMContextImpl;
2971 friend class MDNode;
2972
2973 unsigned Line;
2974
2975 DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line,
2976 ArrayRef<Metadata *> Ops)
2977 : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {}
2978 ~DIMacro() = default;
2979
2980 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
2981 StringRef Name, StringRef Value, StorageType Storage,
2982 bool ShouldCreate = true) {
2983 return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name),
2984 getCanonicalMDString(Context, Value), Storage, ShouldCreate);
2985 }
2986 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
2987 MDString *Name, MDString *Value, StorageType Storage,
2988 bool ShouldCreate = true);
2989
2990 TempDIMacro cloneImpl() const {
2991 return getTemporary(getContext(), getMacinfoType(), getLine(), getName(),
2992 getValue());
2993 }
2994
2995public:
2996 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name,
2997 StringRef Value = ""),
2998 (MIType, Line, Name, Value))
2999 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name,
3000 MDString *Value),
3001 (MIType, Line, Name, Value))
3002
3003 TempDIMacro clone() const { return cloneImpl(); }
3004
3005 unsigned getLine() const { return Line; }
3006
3007 StringRef getName() const { return getStringOperand(0); }
3008 StringRef getValue() const { return getStringOperand(1); }
3009
3010 MDString *getRawName() const { return getOperandAs<MDString>(0); }
3011 MDString *getRawValue() const { return getOperandAs<MDString>(1); }
3012
3013 static bool classof(const Metadata *MD) {
3014 return MD->getMetadataID() == DIMacroKind;
3015 }
3016};
3017
3018class DIMacroFile : public DIMacroNode {
3019 friend class LLVMContextImpl;
3020 friend class MDNode;
3021
3022 unsigned Line;
3023
3024 DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType,
3025 unsigned Line, ArrayRef<Metadata *> Ops)
3026 : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {}
3027 ~DIMacroFile() = default;
3028
3029 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3030 unsigned Line, DIFile *File,
3031 DIMacroNodeArray Elements, StorageType Storage,
3032 bool ShouldCreate = true) {
3033 return getImpl(Context, MIType, Line, static_cast<Metadata *>(File),
3034 Elements.get(), Storage, ShouldCreate);
3035 }
3036
3037 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3038 unsigned Line, Metadata *File, Metadata *Elements,
3039 StorageType Storage, bool ShouldCreate = true);
3040
3041 TempDIMacroFile cloneImpl() const {
3042 return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(),
3043 getElements());
3044 }
3045
3046public:
3047 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File,
3048 DIMacroNodeArray Elements),
3049 (MIType, Line, File, Elements))
3050 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line,
3051 Metadata *File, Metadata *Elements),
3052 (MIType, Line, File, Elements))
3053
3054 TempDIMacroFile clone() const { return cloneImpl(); }
3055
3056 void replaceElements(DIMacroNodeArray Elements) {
3057#ifndef NDEBUG
3058 for (DIMacroNode *Op : getElements())
3059 assert(is_contained(Elements->operands(), Op) &&(static_cast <bool> (is_contained(Elements->operands
(), Op) && "Lost a macro node during macro node list replacement"
) ? void (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a macro node during macro node list replacement\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 3060, __extension__ __PRETTY_FUNCTION__))
3060 "Lost a macro node during macro node list replacement")(static_cast <bool> (is_contained(Elements->operands
(), Op) && "Lost a macro node during macro node list replacement"
) ? void (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a macro node during macro node list replacement\""
, "/build/llvm-toolchain-snapshot-7~svn338205/include/llvm/IR/DebugInfoMetadata.h"
, 3060, __extension__ __PRETTY_FUNCTION__))
;
3061#endif
3062 replaceOperandWith(1, Elements.get());
3063 }
3064
3065 unsigned getLine() const { return Line; }
3066 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
3067
3068 DIMacroNodeArray getElements() const {
3069 return cast_or_null<MDTuple>(getRawElements());
3070 }
3071
3072 Metadata *getRawFile() const { return getOperand(0); }
3073 Metadata *getRawElements() const { return getOperand(1); }
3074
3075 static bool classof(const Metadata *MD) {
3076 return MD->getMetadataID() == DIMacroFileKind;
3077 }
3078};
3079
3080} // end namespace llvm
3081
3082#undef DEFINE_MDNODE_GET_UNPACK_IMPL
3083#undef DEFINE_MDNODE_GET_UNPACK
3084#undef DEFINE_MDNODE_GET
3085
3086#endif // LLVM_IR_DEBUGINFOMETADATA_H