Bug Summary

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