Bug Summary

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

Annotated Source Code

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