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