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