LLVM 19.0.0git
DwarfUnit.cpp
Go to the documentation of this file.
1//===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains support for constructing a dwarf compile unit.
10//
11//===----------------------------------------------------------------------===//
12
13#include "DwarfUnit.h"
14#include "AddressPool.h"
15#include "DwarfCompileUnit.h"
16#include "DwarfExpression.h"
17#include "llvm/ADT/APFloat.h"
18#include "llvm/ADT/APInt.h"
20#include "llvm/IR/Constants.h"
21#include "llvm/IR/DataLayout.h"
22#include "llvm/IR/GlobalValue.h"
23#include "llvm/IR/Metadata.h"
24#include "llvm/MC/MCAsmInfo.h"
25#include "llvm/MC/MCContext.h"
26#include "llvm/MC/MCDwarf.h"
27#include "llvm/MC/MCSection.h"
28#include "llvm/MC/MCStreamer.h"
31#include <cassert>
32#include <cstdint>
33#include <string>
34#include <utility>
35
36using namespace llvm;
37
38#define DEBUG_TYPE "dwarfdebug"
39
42 : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP), OutDIE(DIE) {}
43
44void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
45 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Op);
46}
47
48void DIEDwarfExpression::emitSigned(int64_t Value) {
49 CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata, Value);
50}
51
52void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
53 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value);
54}
55
56void DIEDwarfExpression::emitData1(uint8_t Value) {
57 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value);
58}
59
60void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
61 CU.addBaseTypeRef(getActiveDIE(), Idx);
62}
63
64void DIEDwarfExpression::enableTemporaryBuffer() {
65 assert(!IsBuffering && "Already buffering?");
66 IsBuffering = true;
67}
68
69void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
70
71unsigned DIEDwarfExpression::getTemporaryBufferSize() {
72 return TmpDIE.computeSize(AP.getDwarfFormParams());
73}
74
75void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
76
77bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
78 llvm::Register MachineReg) {
79 return MachineReg == TRI.getFrameRegister(*AP.MF);
80}
81
83 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU,
84 unsigned UniqueID)
85 : DIEUnit(UnitTag), UniqueID(UniqueID), CUNode(Node), Asm(A), DD(DW),
86 DU(DWU) {}
87
89 DwarfDebug *DW, DwarfFile *DWU, unsigned UniqueID,
90 MCDwarfDwoLineTable *SplitLineTable)
91 : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU, UniqueID),
92 CU(CU), SplitLineTable(SplitLineTable) {}
93
95 for (DIEBlock *B : DIEBlocks)
96 B->~DIEBlock();
97 for (DIELoc *L : DIELocs)
98 L->~DIELoc();
99}
100
101int64_t DwarfUnit::getDefaultLowerBound() const {
102 switch (getLanguage()) {
103 default:
104 break;
105
106 // The languages below have valid values in all DWARF versions.
107 case dwarf::DW_LANG_C:
108 case dwarf::DW_LANG_C89:
109 case dwarf::DW_LANG_C_plus_plus:
110 return 0;
111
112 case dwarf::DW_LANG_Fortran77:
113 case dwarf::DW_LANG_Fortran90:
114 return 1;
115
116 // The languages below have valid values only if the DWARF version >= 3.
117 case dwarf::DW_LANG_C99:
118 case dwarf::DW_LANG_ObjC:
119 case dwarf::DW_LANG_ObjC_plus_plus:
120 if (DD->getDwarfVersion() >= 3)
121 return 0;
122 break;
123
124 case dwarf::DW_LANG_Fortran95:
125 if (DD->getDwarfVersion() >= 3)
126 return 1;
127 break;
128
129 // Starting with DWARF v4, all defined languages have valid values.
130 case dwarf::DW_LANG_D:
131 case dwarf::DW_LANG_Java:
132 case dwarf::DW_LANG_Python:
133 case dwarf::DW_LANG_UPC:
134 if (DD->getDwarfVersion() >= 4)
135 return 0;
136 break;
137
138 case dwarf::DW_LANG_Ada83:
139 case dwarf::DW_LANG_Ada95:
140 case dwarf::DW_LANG_Cobol74:
141 case dwarf::DW_LANG_Cobol85:
142 case dwarf::DW_LANG_Modula2:
143 case dwarf::DW_LANG_Pascal83:
144 case dwarf::DW_LANG_PLI:
145 if (DD->getDwarfVersion() >= 4)
146 return 1;
147 break;
148
149 // The languages below are new in DWARF v5.
150 case dwarf::DW_LANG_BLISS:
151 case dwarf::DW_LANG_C11:
152 case dwarf::DW_LANG_C_plus_plus_03:
153 case dwarf::DW_LANG_C_plus_plus_11:
154 case dwarf::DW_LANG_C_plus_plus_14:
155 case dwarf::DW_LANG_Dylan:
156 case dwarf::DW_LANG_Go:
157 case dwarf::DW_LANG_Haskell:
158 case dwarf::DW_LANG_OCaml:
159 case dwarf::DW_LANG_OpenCL:
160 case dwarf::DW_LANG_RenderScript:
161 case dwarf::DW_LANG_Rust:
162 case dwarf::DW_LANG_Swift:
163 if (DD->getDwarfVersion() >= 5)
164 return 0;
165 break;
166
167 case dwarf::DW_LANG_Fortran03:
168 case dwarf::DW_LANG_Fortran08:
169 case dwarf::DW_LANG_Julia:
170 case dwarf::DW_LANG_Modula3:
171 if (DD->getDwarfVersion() >= 5)
172 return 1;
173 break;
174 }
175
176 return -1;
177}
178
179/// Check whether the DIE for this MDNode can be shared across CUs.
181 // When the MDNode can be part of the type system, the DIE can be shared
182 // across CUs.
183 // Combining type units and cross-CU DIE sharing is lower value (since
184 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
185 // level already) but may be implementable for some value in projects
186 // building multiple independent libraries with LTO and then linking those
187 // together.
188 if (isDwoUnit() && !DD->shareAcrossDWOCUs())
189 return false;
190 return (isa<DIType>(D) ||
191 (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
193}
194
197 return DU->getDIE(D);
198 return MDNodeToDieMap.lookup(D);
199}
200
203 DU->insertDIE(Desc, D);
204 return;
205 }
206 MDNodeToDieMap.insert(std::make_pair(Desc, D));
207}
208
210 MDNodeToDieMap.insert(std::make_pair(nullptr, D));
211}
212
214 if (DD->getDwarfVersion() >= 4)
215 addAttribute(Die, Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
216 else
217 addAttribute(Die, Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
218}
219
221 std::optional<dwarf::Form> Form, uint64_t Integer) {
222 if (!Form)
224 assert(Form != dwarf::DW_FORM_implicit_const &&
225 "DW_FORM_implicit_const is used only for signed integers");
227}
228
232}
233
235 std::optional<dwarf::Form> Form, int64_t Integer) {
236 if (!Form)
239}
240
241void DwarfUnit::addSInt(DIELoc &Die, std::optional<dwarf::Form> Form,
242 int64_t Integer) {
244}
245
249 return;
250
251 if (DD->useInlineStrings()) {
252 addAttribute(Die, Attribute, dwarf::DW_FORM_string,
255 return;
256 }
257 dwarf::Form IxForm =
258 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
259
260 auto StringPoolEntry =
261 useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index
264
265 // For DWARF v5 and beyond, use the smallest strx? form possible.
267 IxForm = dwarf::DW_FORM_strx1;
268 unsigned Index = StringPoolEntry.getIndex();
269 if (Index > 0xffffff)
270 IxForm = dwarf::DW_FORM_strx4;
271 else if (Index > 0xffff)
272 IxForm = dwarf::DW_FORM_strx3;
273 else if (Index > 0xff)
274 IxForm = dwarf::DW_FORM_strx2;
275 }
276 addAttribute(Die, Attribute, IxForm, DIEString(StringPoolEntry));
277}
278
280 dwarf::Form Form, const MCSymbol *Label) {
281 addAttribute(Die, Attribute, Form, DIELabel(Label));
282}
283
285 addLabel(Die, (dwarf::Attribute)0, Form, Label);
286}
287
291}
292
293unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
294 if (!SplitLineTable)
295 return getCU().getOrCreateSourceID(File);
296 if (!UsedLineTable) {
297 UsedLineTable = true;
298 // This is a split type unit that needs a line table.
299 addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
300 }
301 return SplitLineTable->getFile(
302 File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
303 Asm->OutContext.getDwarfVersion(), File->getSource());
304}
305
307 bool UseAddrOffsetFormOrExpressions =
309
310 const MCSymbol *Base = nullptr;
311 if (Label->isInSection() && UseAddrOffsetFormOrExpressions)
312 Base = DD->getSectionLabel(&Label->getSection());
313
315
316 if (DD->getDwarfVersion() >= 5) {
317 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
318 addUInt(Die, dwarf::DW_FORM_addrx, Index);
319 } else {
320 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
321 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, Index);
322 }
323
324 if (Base && Base != Label) {
325 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_const4u);
326 addLabelDelta(Die, (dwarf::Attribute)0, Label, Base);
327 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
328 }
329}
330
332 if (DD->getDwarfVersion() >= 5) {
333 addPoolOpAddress(Die, Sym);
334 return;
335 }
336
337 if (DD->useSplitDwarf()) {
338 addPoolOpAddress(Die, Sym);
339 return;
340 }
341
342 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
343 addLabel(Die, dwarf::DW_FORM_addr, Sym);
344}
345
347 const MCSymbol *Hi, const MCSymbol *Lo) {
348 addAttribute(Die, Attribute, dwarf::DW_FORM_data4,
350}
351
353 addDIEEntry(Die, Attribute, DIEEntry(Entry));
354}
355
357 // Flag the type unit reference as a declaration so that if it contains
358 // members (implicit special members, static data member definitions, member
359 // declarations for definitions in this CU, etc) consumers don't get confused
360 // and think this is a full definition.
361 addFlag(Die, dwarf::DW_AT_declaration);
362
363 addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
364 DIEInteger(Signature));
365}
366
368 DIEEntry Entry) {
369 const DIEUnit *CU = Die.getUnit();
370 const DIEUnit *EntryCU = Entry.getEntry().getUnit();
371 if (!CU)
372 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
373 CU = getUnitDie().getUnit();
374 if (!EntryCU)
375 EntryCU = getUnitDie().getUnit();
376 assert(EntryCU == CU || !DD->useSplitDwarf() || DD->shareAcrossDWOCUs() ||
377 !static_cast<const DwarfUnit*>(CU)->isDwoUnit());
379 EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
380 Entry);
381}
382
384 DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag));
385 if (N)
386 insertDIE(N, &Die);
387 return Die;
388}
389
392 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
393 addAttribute(Die, Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
394}
395
397 DIEBlock *Block) {
398 Block->computeSize(Asm->getDwarfFormParams());
399 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
401}
402
404 DIEBlock *Block) {
405 addBlock(Die, Attribute, Block->BestForm(), Block);
406}
407
408void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
409 if (Line == 0)
410 return;
411
412 unsigned FileID = getOrCreateSourceID(File);
413 addUInt(Die, dwarf::DW_AT_decl_file, std::nullopt, FileID);
414 addUInt(Die, dwarf::DW_AT_decl_line, std::nullopt, Line);
415}
416
418 assert(V);
419
420 addSourceLine(Die, V->getLine(), V->getFile());
421}
422
424 assert(G);
425
426 addSourceLine(Die, G->getLine(), G->getFile());
427}
428
430 assert(SP);
431
432 addSourceLine(Die, SP->getLine(), SP->getFile());
433}
434
436 assert(L);
437
438 addSourceLine(Die, L->getLine(), L->getFile());
439}
440
441void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
442 assert(Ty);
443
444 addSourceLine(Die, Ty->getLine(), Ty->getFile());
445}
446
448 assert(Ty);
449
450 addSourceLine(Die, Ty->getLine(), Ty->getFile());
451}
452
454 // Pass this down to addConstantValue as an unsigned bag of bits.
455 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
456}
457
459 const DIType *Ty) {
460 addConstantValue(Die, CI->getValue(), Ty);
461}
462
463void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
464 addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
465}
466
468 // FIXME: This is a bit conservative/simple - it emits negative values always
469 // sign extended to 64 bits rather than minimizing the number of bytes.
470 addUInt(Die, dwarf::DW_AT_const_value,
471 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
472}
473
474void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
475 addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
476}
477
478void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
479 unsigned CIBitWidth = Val.getBitWidth();
480 if (CIBitWidth <= 64) {
482 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
483 return;
484 }
485
487
488 // Get the raw data form of the large APInt.
489 const uint64_t *Ptr64 = Val.getRawData();
490
491 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
492 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
493
494 // Output the constant to DWARF one byte at a time.
495 for (int i = 0; i < NumBytes; i++) {
496 uint8_t c;
497 if (LittleEndian)
498 c = Ptr64[i / 8] >> (8 * (i & 7));
499 else
500 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
501 addUInt(*Block, dwarf::DW_FORM_data1, c);
502 }
503
504 addBlock(Die, dwarf::DW_AT_const_value, Block);
505}
506
508 if (!LinkageName.empty())
509 addString(Die,
510 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
511 : dwarf::DW_AT_MIPS_linkage_name,
513}
514
515void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
516 // Add template parameters.
517 for (const auto *Element : TParams) {
518 if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
519 constructTemplateTypeParameterDIE(Buffer, TTP);
520 else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
521 constructTemplateValueParameterDIE(Buffer, TVP);
522 }
523}
524
525/// Add thrown types.
526void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
527 for (const auto *Ty : ThrownTypes) {
528 DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
529 addType(TT, cast<DIType>(Ty));
530 }
531}
532
534 if ((Flags & DINode::FlagAccessibility) == DINode::FlagProtected)
535 addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
537 else if ((Flags & DINode::FlagAccessibility) == DINode::FlagPrivate)
538 addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
540 else if ((Flags & DINode::FlagAccessibility) == DINode::FlagPublic)
541 addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
543}
544
546 if (!Context || isa<DIFile>(Context) || isa<DICompileUnit>(Context))
547 return &getUnitDie();
548 if (auto *T = dyn_cast<DIType>(Context))
549 return getOrCreateTypeDIE(T);
550 if (auto *NS = dyn_cast<DINamespace>(Context))
551 return getOrCreateNameSpace(NS);
552 if (auto *SP = dyn_cast<DISubprogram>(Context))
553 return getOrCreateSubprogramDIE(SP);
554 if (auto *M = dyn_cast<DIModule>(Context))
555 return getOrCreateModule(M);
556 return getDIE(Context);
557}
558
560 auto *Context = Ty->getScope();
561 DIE *ContextDIE = getOrCreateContextDIE(Context);
562
563 if (DIE *TyDIE = getDIE(Ty))
564 return TyDIE;
565
566 // Create new type.
567 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
568
569 constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
570
571 updateAcceleratorTables(Context, Ty, TyDIE);
572 return &TyDIE;
573}
574
575DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
576 const DIType *Ty) {
577 // Create new type.
578 DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty);
579
580 updateAcceleratorTables(Context, Ty, TyDIE);
581
582 if (auto *BT = dyn_cast<DIBasicType>(Ty))
583 constructTypeDIE(TyDIE, BT);
584 else if (auto *ST = dyn_cast<DIStringType>(Ty))
585 constructTypeDIE(TyDIE, ST);
586 else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
587 constructTypeDIE(TyDIE, STy);
588 else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
589 if (DD->generateTypeUnits() && !Ty->isForwardDecl() &&
590 (Ty->getRawName() || CTy->getRawIdentifier())) {
591 // Skip updating the accelerator tables since this is not the full type.
592 if (MDString *TypeId = CTy->getRawIdentifier())
593 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
594 else
595 finishNonUnitTypeDIE(TyDIE, CTy);
596 return &TyDIE;
597 }
598 constructTypeDIE(TyDIE, CTy);
599 } else {
600 constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
601 }
602
603 return &TyDIE;
604}
605
607 if (!TyNode)
608 return nullptr;
609
610 auto *Ty = cast<DIType>(TyNode);
611
612 // DW_TAG_restrict_type is not supported in DWARF2
613 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
614 return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
615
616 // DW_TAG_atomic_type is not supported in DWARF < 5
617 if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
618 return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
619
620 // Construct the context before querying for the existence of the DIE in case
621 // such construction creates the DIE.
622 auto *Context = Ty->getScope();
623 DIE *ContextDIE = getOrCreateContextDIE(Context);
624 assert(ContextDIE);
625
626 if (DIE *TyDIE = getDIE(Ty))
627 return TyDIE;
628
629 return static_cast<DwarfUnit *>(ContextDIE->getUnit())
630 ->createTypeDIE(Context, *ContextDIE, Ty);
631}
632
633void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
634 const DIType *Ty, const DIE &TyDIE) {
635 if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
636 bool IsImplementation = false;
637 if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
638 // A runtime language of 0 actually means C/C++ and that any
639 // non-negative value is some version of Objective-C/C++.
640 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
641 }
642 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
643 DD->addAccelType(*this, CUNode->getNameTableKind(), Ty->getName(), TyDIE,
644 Flags);
645
646 if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
647 isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
648 addGlobalType(Ty, TyDIE, Context);
649 }
650}
651
652void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
654 assert(Ty && "Trying to add a type that doesn't exist?");
656}
657
658std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
659 if (!Context)
660 return "";
661
662 // FIXME: Decide whether to implement this for non-C++ languages.
664 return "";
665
666 std::string CS;
668 while (!isa<DICompileUnit>(Context)) {
669 Parents.push_back(Context);
670 if (const DIScope *S = Context->getScope())
671 Context = S;
672 else
673 // Structure, etc types will have a NULL context if they're at the top
674 // level.
675 break;
676 }
677
678 // Reverse iterate over our list to go from the outermost construct to the
679 // innermost.
680 for (const DIScope *Ctx : llvm::reverse(Parents)) {
681 StringRef Name = Ctx->getName();
682 if (Name.empty() && isa<DINamespace>(Ctx))
683 Name = "(anonymous namespace)";
684 if (!Name.empty()) {
685 CS += Name;
686 CS += "::";
687 }
688 }
689 return CS;
690}
691
692void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
693 // Get core information.
694 StringRef Name = BTy->getName();
695 // Add name if not anonymous or intermediate type.
696 if (!Name.empty())
697 addString(Buffer, dwarf::DW_AT_name, Name);
698
699 // An unspecified type only has a name attribute.
700 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
701 return;
702
703 if (BTy->getTag() != dwarf::DW_TAG_string_type)
704 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
705 BTy->getEncoding());
706
707 uint64_t Size = BTy->getSizeInBits() >> 3;
708 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt, Size);
709
710 if (BTy->isBigEndian())
711 addUInt(Buffer, dwarf::DW_AT_endianity, std::nullopt, dwarf::DW_END_big);
712 else if (BTy->isLittleEndian())
713 addUInt(Buffer, dwarf::DW_AT_endianity, std::nullopt, dwarf::DW_END_little);
714}
715
716void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
717 // Get core information.
718 StringRef Name = STy->getName();
719 // Add name if not anonymous or intermediate type.
720 if (!Name.empty())
721 addString(Buffer, dwarf::DW_AT_name, Name);
722
723 if (DIVariable *Var = STy->getStringLength()) {
724 if (auto *VarDIE = getDIE(Var))
725 addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
726 } else if (DIExpression *Expr = STy->getStringLengthExp()) {
727 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
728 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
729 // This is to describe the memory location of the
730 // length of a Fortran deferred length string, so
731 // lock it down as such.
732 DwarfExpr.setMemoryLocationKind();
733 DwarfExpr.addExpression(Expr);
734 addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
735 } else {
736 uint64_t Size = STy->getSizeInBits() >> 3;
737 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt, Size);
738 }
739
740 if (DIExpression *Expr = STy->getStringLocationExp()) {
741 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
742 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
743 // This is to describe the memory location of the
744 // string, so lock it down as such.
745 DwarfExpr.setMemoryLocationKind();
746 DwarfExpr.addExpression(Expr);
747 addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
748 }
749
750 if (STy->getEncoding()) {
751 // For eventual Unicode support.
752 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
753 STy->getEncoding());
754 }
755}
756
757void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
758 // Get core information.
759 StringRef Name = DTy->getName();
760 uint64_t Size = DTy->getSizeInBits() >> 3;
761 uint16_t Tag = Buffer.getTag();
762
763 // Map to main type, void will not have a type.
764 const DIType *FromTy = DTy->getBaseType();
765 if (FromTy)
766 addType(Buffer, FromTy);
767
768 // Add name if not anonymous or intermediate type.
769 if (!Name.empty())
770 addString(Buffer, dwarf::DW_AT_name, Name);
771
772 addAnnotation(Buffer, DTy->getAnnotations());
773
774 // If alignment is specified for a typedef , create and insert DW_AT_alignment
775 // attribute in DW_TAG_typedef DIE.
776 if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) {
777 uint32_t AlignInBytes = DTy->getAlignInBytes();
778 if (AlignInBytes > 0)
779 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
780 AlignInBytes);
781 }
782
783 // Add size if non-zero (derived types might be zero-sized.)
784 if (Size && Tag != dwarf::DW_TAG_pointer_type
785 && Tag != dwarf::DW_TAG_ptr_to_member_type
786 && Tag != dwarf::DW_TAG_reference_type
787 && Tag != dwarf::DW_TAG_rvalue_reference_type)
788 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt, Size);
789
790 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
791 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
792 *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType()));
793
794 addAccess(Buffer, DTy->getFlags());
795
796 // Add source line info if available and TyDesc is not a forward declaration.
797 if (!DTy->isForwardDecl())
798 addSourceLine(Buffer, DTy);
799
800 // If DWARF address space value is other than None, add it. The IR
801 // verifier checks that DWARF address space only exists for pointer
802 // or reference types.
803 if (DTy->getDWARFAddressSpace())
804 addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
805 *DTy->getDWARFAddressSpace());
806}
807
809 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
810 const DIType *Ty = Args[i];
811 if (!Ty) {
812 assert(i == N-1 && "Unspecified parameter must be the last argument");
813 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
814 } else {
815 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
816 addType(Arg, Ty);
817 if (Ty->isArtificial())
818 addFlag(Arg, dwarf::DW_AT_artificial);
819 }
820 }
821}
822
823void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
824 // Add return type. A void return won't have a type.
825 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
826 if (Elements.size())
827 if (auto RTy = Elements[0])
828 addType(Buffer, RTy);
829
830 bool isPrototyped = true;
831 if (Elements.size() == 2 && !Elements[1])
832 isPrototyped = false;
833
834 constructSubprogramArguments(Buffer, Elements);
835
836 // Add prototype flag if we're dealing with a C language and the function has
837 // been prototyped.
838 if (isPrototyped && dwarf::isC((dwarf::SourceLanguage)getLanguage()))
839 addFlag(Buffer, dwarf::DW_AT_prototyped);
840
841 // Add a DW_AT_calling_convention if this has an explicit convention.
842 if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
843 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
844 CTy->getCC());
845
846 if (CTy->isLValueReference())
847 addFlag(Buffer, dwarf::DW_AT_reference);
848
849 if (CTy->isRValueReference())
850 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
851}
852
853void DwarfUnit::addAnnotation(DIE &Buffer, DINodeArray Annotations) {
854 if (!Annotations)
855 return;
856
857 for (const Metadata *Annotation : Annotations->operands()) {
858 const MDNode *MD = cast<MDNode>(Annotation);
859 const MDString *Name = cast<MDString>(MD->getOperand(0));
860 const auto &Value = MD->getOperand(1);
861
862 DIE &AnnotationDie = createAndAddDIE(dwarf::DW_TAG_LLVM_annotation, Buffer);
863 addString(AnnotationDie, dwarf::DW_AT_name, Name->getString());
864 if (const auto *Data = dyn_cast<MDString>(Value))
865 addString(AnnotationDie, dwarf::DW_AT_const_value, Data->getString());
866 else if (const auto *Data = dyn_cast<ConstantAsMetadata>(Value))
867 addConstantValue(AnnotationDie, Data->getValue()->getUniqueInteger(),
868 /*Unsigned=*/true);
869 else
870 assert(false && "Unsupported annotation value type");
871 }
872}
873
875 // Add name if not anonymous or intermediate type.
876 StringRef Name = CTy->getName();
877
878 uint64_t Size = CTy->getSizeInBits() >> 3;
879 uint16_t Tag = Buffer.getTag();
880
881 switch (Tag) {
882 case dwarf::DW_TAG_array_type:
883 constructArrayTypeDIE(Buffer, CTy);
884 break;
885 case dwarf::DW_TAG_enumeration_type:
886 constructEnumTypeDIE(Buffer, CTy);
887 break;
888 case dwarf::DW_TAG_variant_part:
889 case dwarf::DW_TAG_structure_type:
890 case dwarf::DW_TAG_union_type:
891 case dwarf::DW_TAG_class_type:
892 case dwarf::DW_TAG_namelist: {
893 // Emit the discriminator for a variant part.
894 DIDerivedType *Discriminator = nullptr;
895 if (Tag == dwarf::DW_TAG_variant_part) {
896 Discriminator = CTy->getDiscriminator();
897 if (Discriminator) {
898 // DWARF says:
899 // If the variant part has a discriminant, the discriminant is
900 // represented by a separate debugging information entry which is
901 // a child of the variant part entry.
902 DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
903 addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
904 }
905 }
906
907 // Add template parameters to a class, structure or union types.
908 if (Tag == dwarf::DW_TAG_class_type ||
909 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
910 addTemplateParams(Buffer, CTy->getTemplateParams());
911
912 // Add elements to structure type.
913 DINodeArray Elements = CTy->getElements();
914 for (const auto *Element : Elements) {
915 if (!Element)
916 continue;
917 if (auto *SP = dyn_cast<DISubprogram>(Element))
919 else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
920 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
921 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
922 addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
923 } else if (DDTy->isStaticMember()) {
925 } else if (Tag == dwarf::DW_TAG_variant_part) {
926 // When emitting a variant part, wrap each member in
927 // DW_TAG_variant.
928 DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
929 if (const ConstantInt *CI =
930 dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
931 if (DD->isUnsignedDIType(Discriminator->getBaseType()))
932 addUInt(Variant, dwarf::DW_AT_discr_value, std::nullopt,
933 CI->getZExtValue());
934 else
935 addSInt(Variant, dwarf::DW_AT_discr_value, std::nullopt,
936 CI->getSExtValue());
937 }
938 constructMemberDIE(Variant, DDTy);
939 } else {
940 constructMemberDIE(Buffer, DDTy);
941 }
942 } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
943 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
944 StringRef PropertyName = Property->getName();
945 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
946 if (Property->getType())
947 addType(ElemDie, Property->getType());
948 addSourceLine(ElemDie, Property);
949 StringRef GetterName = Property->getGetterName();
950 if (!GetterName.empty())
951 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
952 StringRef SetterName = Property->getSetterName();
953 if (!SetterName.empty())
954 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
955 if (unsigned PropertyAttributes = Property->getAttributes())
956 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, std::nullopt,
957 PropertyAttributes);
958 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
959 if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
960 DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
961 constructTypeDIE(VariantPart, Composite);
962 }
963 } else if (Tag == dwarf::DW_TAG_namelist) {
964 auto *Var = dyn_cast<DINode>(Element);
965 auto *VarDIE = getDIE(Var);
966 if (VarDIE) {
967 DIE &ItemDie = createAndAddDIE(dwarf::DW_TAG_namelist_item, Buffer);
968 addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
969 }
970 }
971 }
972
973 if (CTy->isAppleBlockExtension())
974 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
975
976 if (CTy->getExportSymbols())
977 addFlag(Buffer, dwarf::DW_AT_export_symbols);
978
979 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
980 // inside C++ composite types to point to the base class with the vtable.
981 // Rust uses DW_AT_containing_type to link a vtable to the type
982 // for which it was created.
983 if (auto *ContainingType = CTy->getVTableHolder())
984 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
985 *getOrCreateTypeDIE(ContainingType));
986
987 if (CTy->isObjcClassComplete())
988 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
989
990 // Add the type's non-standard calling convention.
991 // DW_CC_pass_by_value/DW_CC_pass_by_reference are introduced in DWARF 5.
992 if (!Asm->TM.Options.DebugStrictDwarf || DD->getDwarfVersion() >= 5) {
993 uint8_t CC = 0;
994 if (CTy->isTypePassByValue())
995 CC = dwarf::DW_CC_pass_by_value;
996 else if (CTy->isTypePassByReference())
997 CC = dwarf::DW_CC_pass_by_reference;
998 if (CC)
999 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
1000 CC);
1001 }
1002 break;
1003 }
1004 default:
1005 break;
1006 }
1007
1008 // Add name if not anonymous or intermediate type.
1009 if (!Name.empty())
1010 addString(Buffer, dwarf::DW_AT_name, Name);
1011
1012 addAnnotation(Buffer, CTy->getAnnotations());
1013
1014 if (Tag == dwarf::DW_TAG_enumeration_type ||
1015 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1016 Tag == dwarf::DW_TAG_union_type) {
1017 // Add size if non-zero (derived types might be zero-sized.)
1018 // Ignore the size if it's a non-enum forward decl.
1019 // TODO: Do we care about size for enum forward declarations?
1020 if (Size &&
1021 (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
1022 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt, Size);
1023 else if (!CTy->isForwardDecl())
1024 // Add zero size if it is not a forward declaration.
1025 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt, 0);
1026
1027 // If we're a forward decl, say so.
1028 if (CTy->isForwardDecl())
1029 addFlag(Buffer, dwarf::DW_AT_declaration);
1030
1031 // Add accessibility info if available.
1032 addAccess(Buffer, CTy->getFlags());
1033
1034 // Add source line info if available.
1035 if (!CTy->isForwardDecl())
1036 addSourceLine(Buffer, CTy);
1037
1038 // No harm in adding the runtime language to the declaration.
1039 unsigned RLang = CTy->getRuntimeLang();
1040 if (RLang)
1041 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1042 RLang);
1043
1044 // Add align info if available.
1045 if (uint32_t AlignInBytes = CTy->getAlignInBytes())
1046 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1047 AlignInBytes);
1048 }
1049}
1050
1051void DwarfUnit::constructTemplateTypeParameterDIE(
1052 DIE &Buffer, const DITemplateTypeParameter *TP) {
1053 DIE &ParamDIE =
1054 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1055 // Add the type if it exists, it could be void and therefore no type.
1056 if (TP->getType())
1057 addType(ParamDIE, TP->getType());
1058 if (!TP->getName().empty())
1059 addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1060 if (TP->isDefault() && isCompatibleWithVersion(5))
1061 addFlag(ParamDIE, dwarf::DW_AT_default_value);
1062}
1063
1064void DwarfUnit::constructTemplateValueParameterDIE(
1065 DIE &Buffer, const DITemplateValueParameter *VP) {
1066 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1067
1068 // Add the type if there is one, template template and template parameter
1069 // packs will not have a type.
1070 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1071 addType(ParamDIE, VP->getType());
1072 if (!VP->getName().empty())
1073 addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1074 if (VP->isDefault() && isCompatibleWithVersion(5))
1075 addFlag(ParamDIE, dwarf::DW_AT_default_value);
1076 if (Metadata *Val = VP->getValue()) {
1077 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1078 addConstantValue(ParamDIE, CI, VP->getType());
1079 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1080 // We cannot describe the location of dllimport'd entities: the
1081 // computation of their address requires loads from the IAT.
1082 if (!GV->hasDLLImportStorageClass()) {
1083 // For declaration non-type template parameters (such as global values
1084 // and functions)
1085 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1086 addOpAddress(*Loc, Asm->getSymbol(GV));
1087 // Emit DW_OP_stack_value to use the address as the immediate value of
1088 // the parameter, rather than a pointer to it.
1089 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1090 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1091 }
1092 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1093 assert(isa<MDString>(Val));
1094 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1095 cast<MDString>(Val)->getString());
1096 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1097 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1098 }
1099 }
1100}
1101
1103 // Construct the context before querying for the existence of the DIE in case
1104 // such construction creates the DIE.
1105 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1106
1107 if (DIE *NDie = getDIE(NS))
1108 return NDie;
1109 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1110
1111 StringRef Name = NS->getName();
1112 if (!Name.empty())
1113 addString(NDie, dwarf::DW_AT_name, NS->getName());
1114 else
1115 Name = "(anonymous namespace)";
1116 DD->addAccelNamespace(*this, CUNode->getNameTableKind(), Name, NDie);
1117 addGlobalName(Name, NDie, NS->getScope());
1118 if (NS->getExportSymbols())
1119 addFlag(NDie, dwarf::DW_AT_export_symbols);
1120 return &NDie;
1121}
1122
1124 // Construct the context before querying for the existence of the DIE in case
1125 // such construction creates the DIE.
1126 DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1127
1128 if (DIE *MDie = getDIE(M))
1129 return MDie;
1130 DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1131
1132 if (!M->getName().empty()) {
1133 addString(MDie, dwarf::DW_AT_name, M->getName());
1134 addGlobalName(M->getName(), MDie, M->getScope());
1135 }
1136 if (!M->getConfigurationMacros().empty())
1137 addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1138 M->getConfigurationMacros());
1139 if (!M->getIncludePath().empty())
1140 addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1141 if (!M->getAPINotesFile().empty())
1142 addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
1143 if (M->getFile())
1144 addUInt(MDie, dwarf::DW_AT_decl_file, std::nullopt,
1145 getOrCreateSourceID(M->getFile()));
1146 if (M->getLineNo())
1147 addUInt(MDie, dwarf::DW_AT_decl_line, std::nullopt, M->getLineNo());
1148 if (M->getIsDecl())
1149 addFlag(MDie, dwarf::DW_AT_declaration);
1150
1151 return &MDie;
1152}
1153
1155 // Construct the context before querying for the existence of the DIE in case
1156 // such construction creates the DIE (as is the case for member function
1157 // declarations).
1158 DIE *ContextDIE =
1159 Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope());
1160
1161 if (DIE *SPDie = getDIE(SP))
1162 return SPDie;
1163
1164 if (auto *SPDecl = SP->getDeclaration()) {
1165 if (!Minimal) {
1166 // Add subprogram definitions to the CU die directly.
1167 ContextDIE = &getUnitDie();
1168 // Build the decl now to ensure it precedes the definition.
1170 }
1171 }
1172
1173 // DW_TAG_inlined_subroutine may refer to this DIE.
1174 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1175
1176 // Stop here and fill this in later, depending on whether or not this
1177 // subprogram turns out to have inlined instances or not.
1178 if (SP->isDefinition())
1179 return &SPDie;
1180
1181 static_cast<DwarfUnit *>(SPDie.getUnit())
1182 ->applySubprogramAttributes(SP, SPDie);
1183 return &SPDie;
1184}
1185
1187 DIE &SPDie, bool Minimal) {
1188 DIE *DeclDie = nullptr;
1189 StringRef DeclLinkageName;
1190 if (auto *SPDecl = SP->getDeclaration()) {
1191 if (!Minimal) {
1192 DITypeRefArray DeclArgs, DefinitionArgs;
1193 DeclArgs = SPDecl->getType()->getTypeArray();
1194 DefinitionArgs = SP->getType()->getTypeArray();
1195
1196 if (DeclArgs.size() && DefinitionArgs.size())
1197 if (DefinitionArgs[0] != nullptr && DeclArgs[0] != DefinitionArgs[0])
1198 addType(SPDie, DefinitionArgs[0]);
1199
1200 DeclDie = getDIE(SPDecl);
1201 assert(DeclDie && "This DIE should've already been constructed when the "
1202 "definition DIE was created in "
1203 "getOrCreateSubprogramDIE");
1204 // Look at the Decl's linkage name only if we emitted it.
1205 if (DD->useAllLinkageNames())
1206 DeclLinkageName = SPDecl->getLinkageName();
1207 unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1208 unsigned DefID = getOrCreateSourceID(SP->getFile());
1209 if (DeclID != DefID)
1210 addUInt(SPDie, dwarf::DW_AT_decl_file, std::nullopt, DefID);
1211
1212 if (SP->getLine() != SPDecl->getLine())
1213 addUInt(SPDie, dwarf::DW_AT_decl_line, std::nullopt, SP->getLine());
1214 }
1215 }
1216
1217 // Add function template parameters.
1218 addTemplateParams(SPDie, SP->getTemplateParams());
1219
1220 // Add the linkage name if we have one and it isn't in the Decl.
1221 StringRef LinkageName = SP->getLinkageName();
1222 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1223 LinkageName == DeclLinkageName) &&
1224 "decl has a linkage name and it is different");
1225 if (DeclLinkageName.empty() &&
1226 // Always emit it for abstract subprograms.
1227 (DD->useAllLinkageNames() || DU->getAbstractScopeDIEs().lookup(SP)))
1229
1230 if (!DeclDie)
1231 return false;
1232
1233 // Refer to the function declaration where all the other attributes will be
1234 // found.
1235 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1236 return true;
1237}
1238
1240 bool SkipSPAttributes) {
1241 // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1242 // and its source location.
1243 bool SkipSPSourceLocation = SkipSPAttributes &&
1245 if (!SkipSPSourceLocation)
1246 if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes))
1247 return;
1248
1249 // Constructors and operators for anonymous aggregates do not have names.
1250 if (!SP->getName().empty())
1251 addString(SPDie, dwarf::DW_AT_name, SP->getName());
1252
1253 addAnnotation(SPDie, SP->getAnnotations());
1254
1255 if (!SkipSPSourceLocation)
1256 addSourceLine(SPDie, SP);
1257
1258 // Skip the rest of the attributes under -gmlt to save space.
1259 if (SkipSPAttributes)
1260 return;
1261
1262 // Add the prototype if we have a prototype and we have a C like
1263 // language.
1264 if (SP->isPrototyped() && dwarf::isC((dwarf::SourceLanguage)getLanguage()))
1265 addFlag(SPDie, dwarf::DW_AT_prototyped);
1266
1267 if (SP->isObjCDirect())
1268 addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
1269
1270 unsigned CC = 0;
1271 DITypeRefArray Args;
1272 if (const DISubroutineType *SPTy = SP->getType()) {
1273 Args = SPTy->getTypeArray();
1274 CC = SPTy->getCC();
1275 }
1276
1277 // Add a DW_AT_calling_convention if this has an explicit convention.
1278 if (CC && CC != dwarf::DW_CC_normal)
1279 addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1280
1281 // Add a return type. If this is a type like a C/C++ void type we don't add a
1282 // return type.
1283 if (Args.size())
1284 if (auto Ty = Args[0])
1285 addType(SPDie, Ty);
1286
1287 unsigned VK = SP->getVirtuality();
1288 if (VK) {
1289 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1290 if (SP->getVirtualIndex() != -1u) {
1291 DIELoc *Block = getDIELoc();
1292 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1293 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1294 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1295 }
1296 ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType()));
1297 }
1298
1299 if (!SP->isDefinition()) {
1300 addFlag(SPDie, dwarf::DW_AT_declaration);
1301
1302 // Add arguments. Do not add arguments for subprogram definition. They will
1303 // be handled while processing variables.
1304 constructSubprogramArguments(SPDie, Args);
1305 }
1306
1307 addThrownTypes(SPDie, SP->getThrownTypes());
1308
1309 if (SP->isArtificial())
1310 addFlag(SPDie, dwarf::DW_AT_artificial);
1311
1312 if (!SP->isLocalToUnit())
1313 addFlag(SPDie, dwarf::DW_AT_external);
1314
1316 if (SP->isOptimized())
1317 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1318
1319 if (unsigned isa = Asm->getISAEncoding())
1320 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1321 }
1322
1323 if (SP->isLValueReference())
1324 addFlag(SPDie, dwarf::DW_AT_reference);
1325
1326 if (SP->isRValueReference())
1327 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1328
1329 if (SP->isNoReturn())
1330 addFlag(SPDie, dwarf::DW_AT_noreturn);
1331
1332 addAccess(SPDie, SP->getFlags());
1333
1334 if (SP->isExplicit())
1335 addFlag(SPDie, dwarf::DW_AT_explicit);
1336
1337 if (SP->isMainSubprogram())
1338 addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1339 if (SP->isPure())
1340 addFlag(SPDie, dwarf::DW_AT_pure);
1341 if (SP->isElemental())
1342 addFlag(SPDie, dwarf::DW_AT_elemental);
1343 if (SP->isRecursive())
1344 addFlag(SPDie, dwarf::DW_AT_recursive);
1345
1346 if (!SP->getTargetFuncName().empty())
1347 addString(SPDie, dwarf::DW_AT_trampoline, SP->getTargetFuncName());
1348
1349 if (DD->getDwarfVersion() >= 5 && SP->isDeleted())
1350 addFlag(SPDie, dwarf::DW_AT_deleted);
1351}
1352
1353void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1354 DIE *IndexTy) {
1355 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1356 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1357
1358 // The LowerBound value defines the lower bounds which is typically zero for
1359 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1360 // Count == -1 then the array is unbounded and we do not emit
1361 // DW_AT_lower_bound and DW_AT_count attributes.
1362 int64_t DefaultLowerBound = getDefaultLowerBound();
1363
1364 auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1365 DISubrange::BoundType Bound) -> void {
1366 if (auto *BV = dyn_cast_if_present<DIVariable *>(Bound)) {
1367 if (auto *VarDIE = getDIE(BV))
1368 addDIEEntry(DW_Subrange, Attr, *VarDIE);
1369 } else if (auto *BE = dyn_cast_if_present<DIExpression *>(Bound)) {
1370 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1371 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1372 DwarfExpr.setMemoryLocationKind();
1373 DwarfExpr.addExpression(BE);
1374 addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
1375 } else if (auto *BI = dyn_cast_if_present<ConstantInt *>(Bound)) {
1376 if (Attr == dwarf::DW_AT_count) {
1377 if (BI->getSExtValue() != -1)
1378 addUInt(DW_Subrange, Attr, std::nullopt, BI->getSExtValue());
1379 } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1380 BI->getSExtValue() != DefaultLowerBound)
1381 addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
1382 }
1383 };
1384
1385 AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
1386
1387 AddBoundTypeEntry(dwarf::DW_AT_count, SR->getCount());
1388
1389 AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound());
1390
1391 AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride());
1392}
1393
1394void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
1395 const DIGenericSubrange *GSR,
1396 DIE *IndexTy) {
1397 DIE &DwGenericSubrange =
1398 createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
1399 addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
1400
1401 int64_t DefaultLowerBound = getDefaultLowerBound();
1402
1403 auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1404 DIGenericSubrange::BoundType Bound) -> void {
1405 if (auto *BV = dyn_cast_if_present<DIVariable *>(Bound)) {
1406 if (auto *VarDIE = getDIE(BV))
1407 addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
1408 } else if (auto *BE = dyn_cast_if_present<DIExpression *>(Bound)) {
1409 if (BE->isConstant() &&
1411 *BE->isConstant()) {
1412 if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1413 static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
1414 addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
1415 BE->getElement(1));
1416 } else {
1417 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1418 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1419 DwarfExpr.setMemoryLocationKind();
1420 DwarfExpr.addExpression(BE);
1421 addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
1422 }
1423 }
1424 };
1425
1426 AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound());
1427 AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount());
1428 AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound());
1429 AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
1430}
1431
1432DIE *DwarfUnit::getIndexTyDie() {
1433 if (IndexTyDie)
1434 return IndexTyDie;
1435 // Construct an integer type to use for indexes.
1436 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1437 StringRef Name = "__ARRAY_SIZE_TYPE__";
1438 addString(*IndexTyDie, dwarf::DW_AT_name, Name);
1439 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, std::nullopt, sizeof(int64_t));
1440 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1444 /*Flags*/ 0);
1445 return IndexTyDie;
1446}
1447
1448/// Returns true if the vector's size differs from the sum of sizes of elements
1449/// the user specified. This can occur if the vector has been rounded up to
1450/// fit memory alignment constraints.
1451static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1452 assert(CTy && CTy->isVector() && "Composite type is not a vector");
1453 const uint64_t ActualSize = CTy->getSizeInBits();
1454
1455 // Obtain the size of each element in the vector.
1456 DIType *BaseTy = CTy->getBaseType();
1457 assert(BaseTy && "Unknown vector element type.");
1458 const uint64_t ElementSize = BaseTy->getSizeInBits();
1459
1460 // Locate the number of elements in the vector.
1461 const DINodeArray Elements = CTy->getElements();
1462 assert(Elements.size() == 1 &&
1463 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1464 "Invalid vector element array, expected one element of type subrange");
1465 const auto Subrange = cast<DISubrange>(Elements[0]);
1466 const auto NumVecElements =
1467 Subrange->getCount()
1468 ? cast<ConstantInt *>(Subrange->getCount())->getSExtValue()
1469 : 0;
1470
1471 // Ensure we found the element count and that the actual size is wide
1472 // enough to contain the requested size.
1473 assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
1474 return ActualSize != (NumVecElements * ElementSize);
1475}
1476
1477void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1478 if (CTy->isVector()) {
1479 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1480 if (hasVectorBeenPadded(CTy))
1481 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt,
1482 CTy->getSizeInBits() / CHAR_BIT);
1483 }
1484
1485 if (DIVariable *Var = CTy->getDataLocation()) {
1486 if (auto *VarDIE = getDIE(Var))
1487 addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
1488 } else if (DIExpression *Expr = CTy->getDataLocationExp()) {
1489 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1490 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1491 DwarfExpr.setMemoryLocationKind();
1492 DwarfExpr.addExpression(Expr);
1493 addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
1494 }
1495
1496 if (DIVariable *Var = CTy->getAssociated()) {
1497 if (auto *VarDIE = getDIE(Var))
1498 addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
1499 } else if (DIExpression *Expr = CTy->getAssociatedExp()) {
1500 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1501 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1502 DwarfExpr.setMemoryLocationKind();
1503 DwarfExpr.addExpression(Expr);
1504 addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
1505 }
1506
1507 if (DIVariable *Var = CTy->getAllocated()) {
1508 if (auto *VarDIE = getDIE(Var))
1509 addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
1510 } else if (DIExpression *Expr = CTy->getAllocatedExp()) {
1511 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1512 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1513 DwarfExpr.setMemoryLocationKind();
1514 DwarfExpr.addExpression(Expr);
1515 addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
1516 }
1517
1518 if (auto *RankConst = CTy->getRankConst()) {
1519 addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
1520 RankConst->getSExtValue());
1521 } else if (auto *RankExpr = CTy->getRankExp()) {
1522 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1523 DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1524 DwarfExpr.setMemoryLocationKind();
1525 DwarfExpr.addExpression(RankExpr);
1526 addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
1527 }
1528
1529 // Emit the element type.
1530 addType(Buffer, CTy->getBaseType());
1531
1532 // Get an anonymous type for index type.
1533 // FIXME: This type should be passed down from the front end
1534 // as different languages may have different sizes for indexes.
1535 DIE *IdxTy = getIndexTyDie();
1536
1537 // Add subranges to array type.
1538 DINodeArray Elements = CTy->getElements();
1539 for (DINode *E : Elements) {
1540 // FIXME: Should this really be such a loose cast?
1541 if (auto *Element = dyn_cast_or_null<DINode>(E)) {
1542 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1543 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1544 else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
1545 constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
1546 IdxTy);
1547 }
1548 }
1549}
1550
1551void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1552 const DIType *DTy = CTy->getBaseType();
1553 bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
1554 if (DTy) {
1555 if (DD->getDwarfVersion() >= 3)
1556 addType(Buffer, DTy);
1557 if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
1558 addFlag(Buffer, dwarf::DW_AT_enum_class);
1559 }
1560
1561 auto *Context = CTy->getScope();
1562 bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
1563 isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
1564 DINodeArray Elements = CTy->getElements();
1565
1566 // Add enumerators to enumeration type.
1567 for (const DINode *E : Elements) {
1568 auto *Enum = dyn_cast_or_null<DIEnumerator>(E);
1569 if (Enum) {
1570 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1571 StringRef Name = Enum->getName();
1572 addString(Enumerator, dwarf::DW_AT_name, Name);
1573 addConstantValue(Enumerator, Enum->getValue(), IsUnsigned);
1574 if (IndexEnumerators)
1575 addGlobalName(Name, Enumerator, Context);
1576 }
1577 }
1578}
1579
1581 for (auto &P : ContainingTypeMap) {
1582 DIE &SPDie = *P.first;
1583 const DINode *D = P.second;
1584 if (!D)
1585 continue;
1586 DIE *NDie = getDIE(D);
1587 if (!NDie)
1588 continue;
1589 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1590 }
1591}
1592
1593DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1594 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1595 StringRef Name = DT->getName();
1596 if (!Name.empty())
1597 addString(MemberDie, dwarf::DW_AT_name, Name);
1598
1599 addAnnotation(MemberDie, DT->getAnnotations());
1600
1601 if (DIType *Resolved = DT->getBaseType())
1602 addType(MemberDie, Resolved);
1603
1604 addSourceLine(MemberDie, DT);
1605
1606 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1607
1608 // For C++, virtual base classes are not at fixed offset. Use following
1609 // expression to extract appropriate offset from vtable.
1610 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1611
1612 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1613 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1614 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1615 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1616 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1617 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1618 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1619 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1620
1621 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1622 } else {
1623 uint64_t Size = DT->getSizeInBits();
1624 uint64_t FieldSize = DD->getBaseTypeSize(DT);
1625 uint32_t AlignInBytes = DT->getAlignInBytes();
1626 uint64_t OffsetInBytes;
1627
1628 bool IsBitfield = DT->isBitField();
1629 if (IsBitfield) {
1630 // Handle bitfield, assume bytes are 8 bits.
1631 if (DD->useDWARF2Bitfields())
1632 addUInt(MemberDie, dwarf::DW_AT_byte_size, std::nullopt, FieldSize / 8);
1633 addUInt(MemberDie, dwarf::DW_AT_bit_size, std::nullopt, Size);
1634
1635 uint64_t Offset = DT->getOffsetInBits();
1636 // We can't use DT->getAlignInBits() here: AlignInBits for member type
1637 // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1638 // which can't be done with bitfields. Thus we use FieldSize here.
1639 uint32_t AlignInBits = FieldSize;
1640 uint32_t AlignMask = ~(AlignInBits - 1);
1641 // The bits from the start of the storage unit to the start of the field.
1642 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1643 // The byte offset of the field's aligned storage unit inside the struct.
1644 OffsetInBytes = (Offset - StartBitOffset) / 8;
1645
1646 if (DD->useDWARF2Bitfields()) {
1647 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1648 uint64_t FieldOffset = (HiMark - FieldSize);
1649 Offset -= FieldOffset;
1650
1651 // Maybe we need to work from the other end.
1653 Offset = FieldSize - (Offset + Size);
1654
1655 addUInt(MemberDie, dwarf::DW_AT_bit_offset, std::nullopt, Offset);
1656 OffsetInBytes = FieldOffset >> 3;
1657 } else {
1658 addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, std::nullopt, Offset);
1659 }
1660 } else {
1661 // This is not a bitfield.
1662 OffsetInBytes = DT->getOffsetInBits() / 8;
1663 if (AlignInBytes)
1664 addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1665 AlignInBytes);
1666 }
1667
1668 if (DD->getDwarfVersion() <= 2) {
1669 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1670 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1671 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1672 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1673 } else if (!IsBitfield || DD->useDWARF2Bitfields()) {
1674 // In DWARF v3, DW_FORM_data4/8 in DW_AT_data_member_location are
1675 // interpreted as location-list pointers. Interpreting constants as
1676 // pointers is not expected, so we use DW_FORM_udata to encode the
1677 // constants here.
1678 if (DD->getDwarfVersion() == 3)
1679 addUInt(MemberDie, dwarf::DW_AT_data_member_location,
1680 dwarf::DW_FORM_udata, OffsetInBytes);
1681 else
1682 addUInt(MemberDie, dwarf::DW_AT_data_member_location, std::nullopt,
1683 OffsetInBytes);
1684 }
1685 }
1686
1687 addAccess(MemberDie, DT->getFlags());
1688
1689 if (DT->isVirtual())
1690 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1691 dwarf::DW_VIRTUALITY_virtual);
1692
1693 // Objective-C properties.
1694 if (DINode *PNode = DT->getObjCProperty())
1695 if (DIE *PDie = getDIE(PNode))
1696 addAttribute(MemberDie, dwarf::DW_AT_APPLE_property,
1697 dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1698
1699 if (DT->isArtificial())
1700 addFlag(MemberDie, dwarf::DW_AT_artificial);
1701
1702 return MemberDie;
1703}
1704
1706 if (!DT)
1707 return nullptr;
1708
1709 // Construct the context before querying for the existence of the DIE in case
1710 // such construction creates the DIE.
1711 DIE *ContextDIE = getOrCreateContextDIE(DT->getScope());
1712 assert(dwarf::isType(ContextDIE->getTag()) &&
1713 "Static member should belong to a type.");
1714
1715 if (DIE *StaticMemberDIE = getDIE(DT))
1716 return StaticMemberDIE;
1717
1718 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1719
1720 const DIType *Ty = DT->getBaseType();
1721
1722 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1723 addType(StaticMemberDIE, Ty);
1724 addSourceLine(StaticMemberDIE, DT);
1725 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1726 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1727
1728 // FIXME: We could omit private if the parent is a class_type, and
1729 // public if the parent is something else.
1730 addAccess(StaticMemberDIE, DT->getFlags());
1731
1732 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1733 addConstantValue(StaticMemberDIE, CI, Ty);
1734 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1735 addConstantFPValue(StaticMemberDIE, CFP);
1736
1737 if (uint32_t AlignInBytes = DT->getAlignInBytes())
1738 addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1739 AlignInBytes);
1740
1741 return &StaticMemberDIE;
1742}
1743
1745 // Emit size of content not including length itself
1748 isDwoUnit() ? "debug_info_dwo" : "debug_info", "Length of Unit");
1749 else
1751 "Length of Unit");
1752
1753 Asm->OutStreamer->AddComment("DWARF version number");
1754 unsigned Version = DD->getDwarfVersion();
1755 Asm->emitInt16(Version);
1756
1757 // DWARF v5 reorders the address size and adds a unit type.
1758 if (Version >= 5) {
1759 Asm->OutStreamer->AddComment("DWARF Unit Type");
1760 Asm->emitInt8(UT);
1761 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1763 }
1764
1765 // We share one abbreviations table across all units so it's always at the
1766 // start of the section. Use a relocatable offset where needed to ensure
1767 // linking doesn't invalidate that offset.
1768 Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1770 if (UseOffsets)
1772 else
1774 TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1775
1776 if (Version <= 4) {
1777 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1779 }
1780}
1781
1782void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1783 if (!DD->useSplitDwarf()) {
1784 LabelBegin = Asm->createTempSymbol("tu_begin");
1785 Asm->OutStreamer->emitLabel(LabelBegin);
1786 }
1787 DwarfUnit::emitCommonHeader(UseOffsets,
1788 DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1789 : dwarf::DW_UT_type);
1790 Asm->OutStreamer->AddComment("Type Signature");
1791 Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
1792 Asm->OutStreamer->AddComment("Type DIE Offset");
1793 // In a skeleton type unit there is no type DIE so emit a zero offset.
1794 Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
1795}
1796
1798 const MCSymbol *Hi, const MCSymbol *Lo) {
1801}
1802
1804 const MCSymbol *Label, const MCSymbol *Sec) {
1807 else
1808 addSectionDelta(Die, Attribute, Label, Sec);
1809}
1810
1811bool DwarfTypeUnit::isDwoUnit() const {
1812 // Since there are no skeleton type units, all type units are dwo type units
1813 // when split DWARF is being used.
1814 return DD->useSplitDwarf();
1815}
1816
1818 const DIScope *Context) {
1820}
1821
1822void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1823 const DIScope *Context) {
1825}
1826
1827const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1829 return nullptr;
1830 if (isDwoUnit())
1831 return nullptr;
1832 return getSection()->getBeginSymbol();
1833}
1834
1837 addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1840}
1841
1843 assert(DD->getDwarfVersion() >= 5 &&
1844 "DW_AT_rnglists_base requires DWARF version 5 or later");
1846 addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
1849}
1850
1851void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1853}
1854
1855bool DwarfUnit::isCompatibleWithVersion(uint16_t Version) const {
1856 return !Asm->TM.Options.DebugStrictDwarf || DD->getDwarfVersion() >= Version;
1857}
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static bool hasVectorBeenPadded(const DICompositeType *CTy)
Returns true if the vector's size differs from the sum of sizes of elements the user specified.
Definition: DwarfUnit.cpp:1451
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define G(x, y, z)
Definition: MD5.cpp:56
unsigned const TargetRegisterInfo * TRI
This file contains the declarations for metadata subclasses.
LLVMContext & Context
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static enum BaseType getBaseType(const Value *Val)
Return the baseType for Val which states whether Val is exclusively derived from constant/null,...
static unsigned getSize(unsigned Kind)
APInt bitcastToAPInt() const
Definition: APFloat.h:1210
Class for arbitrary precision integers.
Definition: APInt.h:76
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1491
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1439
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:547
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1513
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
Definition: AddressPool.cpp:20
void resetUsedFlag(bool HasBeenUsed=false)
Definition: AddressPool.h:51
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:53
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:398
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:700
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:87
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:90
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:102
void emitInt8(int Value) const
Emit a byte directive and value.
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:94
MCSymbol * createTempSymbol(const Twine &Name) const
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:99
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
Definition: AsmPrinter.h:755
void emitInt16(int Value) const
Emit a short directive and value.
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:402
dwarf::FormParams getDwarfFormParams() const
Returns information about the byte size of DW_FORM values.
bool doesDwarfUseRelocationsAcrossSections() const
Definition: AsmPrinter.h:330
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:267
const APFloat & getValueAPF() const
Definition: Constants.h:310
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:144
Basic type, like 'int' or 'float'.
unsigned getEncoding() const
bool getDebugInfoForProfiling() const
bool isDebugDirectivesOnly() const
static std::optional< DebugNameTableKind > getNameTableKind(StringRef Str)
DIExpression * getRankExp() const
DIExpression * getAssociatedExp() const
DIVariable * getAllocated() const
DIExpression * getDataLocationExp() const
DIVariable * getAssociated() const
DIDerivedType * getDiscriminator() const
DIVariable * getDataLocation() const
unsigned getRuntimeLang() const
DINodeArray getElements() const
DITemplateParameterArray getTemplateParams() const
DIExpression * getAllocatedExp() const
DIType * getVTableHolder() const
DINodeArray getAnnotations() const
ConstantInt * getRankConst() const
DIType * getBaseType() const
DIObjCProperty * getObjCProperty() const
Constant * getConstant() const
DIEBlock - Represents a block of values.
Definition: DIE.h:1046
A simple label difference DIE.
Definition: DIE.h:261
DwarfExpression implementation for singular DW_AT_location.
DIEDwarfExpression(const AsmPrinter &AP, DwarfCompileUnit &CU, DIELoc &DIE)
Definition: DwarfUnit.cpp:40
A pointer to another debug information entry.
Definition: DIE.h:319
A container for inline string values.
Definition: DIE.h:297
An integer value DIE.
Definition: DIE.h:168
static dwarf::Form BestForm(bool IsSigned, uint64_t Int)
Choose the best form for integer.
Definition: DIE.h:175
A label DIE.
Definition: DIE.h:223
DIELoc - Represents an expression location.
Definition: DIE.h:1010
unsigned computeSize(const dwarf::FormParams &FormParams) const
Calculate the size of the location expression.
Definition: DIE.cpp:710
dwarf::Form BestForm(unsigned DwarfVersion) const
BestForm - Choose the best form for data.
Definition: DIE.h:1024
A container for string pool string values.
Definition: DIE.h:278
Represents a compile or type unit.
Definition: DIE.h:960
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
Definition: DIE.h:996
DIE & getUnitDie()
Definition: DIE.h:999
A list of DIE values.
Definition: DIE.h:689
void takeValues(DIEValueList &Other)
Take ownership of the nodes in Other, and append them to the back of the list.
Definition: DIE.h:805
A structured debug information entry.
Definition: DIE.h:819
DIE & addChild(DIE *Child)
Add a child to the DIE.
Definition: DIE.h:934
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
Definition: DIE.h:849
DIEUnit * getUnit() const
Climb up the parent chain to get the compile unit or type unit that this DIE belongs to.
Definition: DIE.cpp:207
dwarf::Tag getTag() const
Definition: DIE.h:855
DWARF expression.
BoundType getLowerBound() const
BoundType getUpperBound() const
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Debug lexical block.
DIScope * getScope() const
StringRef getName() const
bool getExportSymbols() const
Tagged DWARF-like metadata node.
dwarf::Tag getTag() const
DIFlags
Debug info flags.
unsigned getLine() const
DIFile * getFile() const
Base class for scope-like contexts.
StringRef getName() const
DIFile * getFile() const
DIScope * getScope() const
String type, Fortran CHARACTER(n)
unsigned getEncoding() const
DIExpression * getStringLengthExp() const
DIVariable * getStringLength() const
DIExpression * getStringLocationExp() const
Subprogram description.
Array subrange.
BoundType getUpperBound() const
BoundType getStride() const
BoundType getLowerBound() const
BoundType getCount() const
Type array for a subprogram.
unsigned size() const
Base class for types.
bool isLittleEndian() const
bool isBigEndian() const
bool isLValueReference() const
bool isBitField() const
bool isVirtual() const
bool isObjcClassComplete() const
MDString * getRawName() const
bool isAppleBlockExtension() const
uint64_t getOffsetInBits() const
bool isVector() const
DIFlags getFlags() const
StringRef getName() const
bool isForwardDecl() const
bool isTypePassByValue() const
uint64_t getSizeInBits() const
uint32_t getAlignInBytes() const
unsigned getLine() const
bool isRValueReference() const
bool isArtificial() const
bool getExportSymbols() const
DIScope * getScope() const
bool isTypePassByReference() const
Base class for variables.
This class represents an Operation in the Expression.
bool isLittleEndian() const
Layout endianness...
Definition: DataLayout.h:238
static bool isUnsignedDIType(const DIType *Ty)
Return true if type encoding is unsigned.
static uint64_t getBaseTypeSize(const DIType *Ty)
If this type is derived from a base type then return base type size.
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:351
std::optional< MD5::MD5Result > getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
bool useAddrOffsetForm() const
Definition: DwarfDebug.h:777
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
void addAccelNamespace(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:749
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:800
bool useInlineStrings() const
Returns whether to use inline strings.
Definition: DwarfDebug.h:760
bool generateTypeUnits() const
Returns whether to generate DWARF v4 type units.
Definition: DwarfDebug.h:790
AddressPool & getAddressPool()
Definition: DwarfDebug.h:861
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:782
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:537
const MCSymbol * getSectionLabel(const MCSection *S)
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
Definition: DwarfDebug.h:806
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:757
bool useAddrOffsetExpressions() const
Definition: DwarfDebug.h:771
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we're going to pull into type units.
void addAccelType(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die, char Flags)
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
MCSymbol * getStringOffsetsStartSym() const
Definition: DwarfFile.h:147
MCSymbol * getRnglistsTableBaseSym() const
Definition: DwarfFile.h:150
DwarfStringPool & getStringPool()
Returns the string pool.
Definition: DwarfFile.h:145
DenseMap< const DILocalScope *, DIE * > & getAbstractScopeDIEs()
Definition: DwarfFile.h:165
void insertDIE(const MDNode *TypeMD, DIE *Die)
Definition: DwarfFile.h:173
DIE * getDIE(const MDNode *TypeMD)
Definition: DwarfFile.h:177
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
EntryRef getIndexedEntry(AsmPrinter &Asm, StringRef Str)
Same as getEntry, except that you can use EntryRef::getIndex to obtain a unique ID of this entry (e....
DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, unsigned UniqueID, MCDwarfDwoLineTable *SplitLineTable=nullptr)
Definition: DwarfUnit.cpp:88
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
Definition: DwarfUnit.cpp:1822
DwarfCompileUnit & getCU() override
Definition: DwarfUnit.h:402
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
Definition: DwarfUnit.cpp:1782
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
Definition: DwarfUnit.cpp:1817
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:35
virtual DIE * getOrCreateTypeDIE(const MDNode *TyNode)
Find existing DIE or create new DIE for the given type.
Definition: DwarfUnit.cpp:606
void addThrownTypes(DIE &Die, DINodeArray ThrownTypes)
Add thrown types.
Definition: DwarfUnit.cpp:526
void addStringOffsetsStart()
Add the DW_AT_str_offsets_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1835
void addAnnotation(DIE &Buffer, DINodeArray Annotations)
Add DW_TAG_LLVM_annotation.
Definition: DwarfUnit.cpp:853
std::vector< DIEBlock * > DIEBlocks
A list of all the DIEBlocks in use.
Definition: DwarfUnit.h:66
std::vector< DIELoc * > DIELocs
A list of all the DIELocs in use.
Definition: DwarfUnit.h:69
uint16_t getLanguage() const
Definition: DwarfUnit.h:110
void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc)
Add block data.
Definition: DwarfUnit.cpp:390
void addTemplateParams(DIE &Buffer, DINodeArray TParams)
Add template parameters in buffer.
Definition: DwarfUnit.cpp:515
virtual DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner's DIE.
Definition: DwarfUnit.cpp:545
bool useSegmentedStringOffsetsTable() const
Definition: DwarfUnit.h:275
bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie, bool Minimal)
Definition: DwarfUnit.cpp:1186
DIELoc * getDIELoc()
Returns a fresh newly allocated DIELoc.
Definition: DwarfUnit.h:142
void addAttribute(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, T &&Value)
Definition: DwarfUnit.h:84
void addOpAddress(DIELoc &Die, const MCSymbol *Sym)
Add a dwarf op address data and value using the form given and an op of either DW_FORM_addr or DW_FOR...
Definition: DwarfUnit.cpp:331
void addUInt(DIEValueList &Die, dwarf::Attribute Attribute, std::optional< dwarf::Form > Form, uint64_t Integer)
Add an unsigned integer attribute data and value.
Definition: DwarfUnit.cpp:220
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
Definition: DwarfUnit.cpp:246
void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:458
DIE * getOrCreateNameSpace(const DINamespace *NS)
Definition: DwarfUnit.cpp:1102
void insertDIE(const DINode *Desc, DIE *D)
Insert DIE into the map.
Definition: DwarfUnit.cpp:201
void addAccess(DIE &Die, DINode::DIFlags Flags)
Add the accessibility attribute.
Definition: DwarfUnit.cpp:533
void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:1797
DIE * createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty)
Creates type DIE with specific context.
Definition: DwarfUnit.cpp:575
DwarfDebug * DD
Definition: DwarfUnit.h:55
DenseMap< DIE *, const DINode * > ContainingTypeMap
This map is used to keep track of subprogram DIEs that need DW_AT_containing_type attribute.
Definition: DwarfUnit.h:74
const DICompileUnit * CUNode
MDNode for the compile unit.
Definition: DwarfUnit.h:40
virtual unsigned getOrCreateSourceID(const DIFile *File)=0
Look up the source ID for the given file.
void addDIETypeSignature(DIE &Die, uint64_t Signature)
Add a type's DW_AT_signature and set the declaration flag.
Definition: DwarfUnit.cpp:356
virtual void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context)=0
Add a new global type to the compile unit.
virtual DwarfCompileUnit & getCU()=0
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
Definition: DwarfUnit.cpp:195
virtual unsigned getHeaderSize() const
Compute the size of a header for this unit, not including the initial length field.
Definition: DwarfUnit.h:281
void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args)
Construct function argument DIEs.
Definition: DwarfUnit.cpp:808
MCSymbol * LabelBegin
The start of the unit within its section.
Definition: DwarfUnit.h:49
void addSInt(DIEValueList &Die, dwarf::Attribute Attribute, std::optional< dwarf::Form > Form, int64_t Integer)
Add an signed integer attribute data and value.
Definition: DwarfUnit.cpp:234
DwarfUnit(dwarf::Tag, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, unsigned UniqueID=0)
Definition: DwarfUnit.cpp:82
void addLabelDelta(DIEValueList &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
Add a label delta attribute data and value.
Definition: DwarfUnit.cpp:346
void addLinkageName(DIE &Die, StringRef LinkageName)
Add a linkage name, if it isn't empty.
Definition: DwarfUnit.cpp:507
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
Definition: DwarfUnit.cpp:658
void addSourceLine(DIE &Die, unsigned Line, const DIFile *File)
Add location information to specified debug information entry.
Definition: DwarfUnit.cpp:408
void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT)
Emit the common part of the header for this unit.
Definition: DwarfUnit.cpp:1744
BumpPtrAllocator DIEValueAllocator
Definition: DwarfUnit.h:43
DIE * IndexTyDie
An anonymous type for index type. Owned by DIEUnit.
Definition: DwarfUnit.h:59
void addRnglistsBase()
Add the DW_AT_rnglists_base attribute to the unit DIE.
Definition: DwarfUnit.cpp:1842
DIE * getOrCreateModule(const DIModule *M)
Definition: DwarfUnit.cpp:1123
DIE & createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N=nullptr)
Create a DIE with the given Tag, add the DIE to its parent, and call insertDIE if MD is not null.
Definition: DwarfUnit.cpp:383
DwarfFile * DU
Definition: DwarfUnit.h:56
void addSectionOffset(DIE &Die, dwarf::Attribute Attribute, uint64_t Integer)
Add an offset into a section attribute data and value.
Definition: DwarfUnit.cpp:288
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
Definition: DwarfUnit.cpp:1705
void addLabel(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, const MCSymbol *Label)
Add a Dwarf label attribute data and value.
Definition: DwarfUnit.cpp:279
void addConstantFPValue(DIE &Die, const ConstantFP *CFP)
Add constant value entry in variable DIE.
Definition: DwarfUnit.cpp:453
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
Definition: DwarfUnit.cpp:1580
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
Definition: DwarfUnit.cpp:1154
void addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
Add a Dwarf section label attribute data and value.
Definition: DwarfUnit.cpp:1803
bool isShareableAcrossCUs(const DINode *D) const
Check whether the DIE for this MDNode can be shared across CUs.
Definition: DwarfUnit.cpp:180
void addPoolOpAddress(DIEValueList &Die, const MCSymbol *Label)
Definition: DwarfUnit.cpp:306
DenseMap< const MDNode *, DIE * > MDNodeToDieMap
Tracks the mapping of unit level debug information variables to debug information entries.
Definition: DwarfUnit.h:63
void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy)
Definition: DwarfUnit.cpp:874
virtual void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context)=0
Add a new global name to the compile unit.
MCSymbol * EndLabel
Emitted at the end of the CU and used to compute the CU Length field.
Definition: DwarfUnit.h:52
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
Definition: DwarfUnit.cpp:213
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:46
void addType(DIE &Entity, const DIType *Ty, dwarf::Attribute Attribute=dwarf::DW_AT_type)
Add a new type attribute to the specified entity.
Definition: DwarfUnit.cpp:652
void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, bool SkipSPAttributes=false)
Definition: DwarfUnit.cpp:1239
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry)
Add a DIE attribute data and value.
Definition: DwarfUnit.cpp:352
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition: GlobalValue.h:566
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:546
uint16_t getDwarfVersion() const
Definition: MCContext.h:833
unsigned getFile(StringRef Directory, StringRef FileName, std::optional< MD5::MD5Result > Checksum, uint16_t DwarfVersion, std::optional< StringRef > Source)
Definition: MCDwarf.h:339
MCSection * getDwarfStrOffSection() const
MCSection * getDwarfRnglistsSection() const
MCSection * getDwarfAbbrevSection() const
MCSymbol * getBeginSymbol()
Definition: MCSection.h:129
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Metadata node.
Definition: Metadata.h:1067
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1428
A single uniqued string.
Definition: Metadata.h:720
Root of the metadata hierarchy.
Definition: Metadata.h:62
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:118
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
TargetOptions Options
unsigned DebugStrictDwarf
When set to true, don't use DWARF extensions in later DWARF versions.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
LLVM Value Representation.
Definition: Value.h:74
@ DW_ACCESS_private
Definition: Dwarf.h:182
@ DW_ACCESS_protected
Definition: Dwarf.h:181
@ DW_ACCESS_public
Definition: Dwarf.h:180
Attribute
Attributes.
Definition: Dwarf.h:123
UnitType
Constants for unit types in DWARF v5.
Definition: Dwarf.h:551
bool isType(Tag T)
Definition: Dwarf.h:111
SourceLanguage
Definition: Dwarf.h:204
bool isCPlusPlus(SourceLanguage S)
Definition: Dwarf.h:212
TypeKind getArrayIndexTypeEncoding(SourceLanguage S)
Definition: Dwarf.h:409
@ DW_FLAG_type_implementation
Definition: Dwarf.h:608
bool isC(SourceLanguage S)
Definition: Dwarf.h:346
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:428
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition: Casting.h:548
#define N
Description of the encoding of one expression Op.