1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for constructing a dwarf compile unit.
12 //===----------------------------------------------------------------------===//
14 #include "DwarfUnit.h"
15 #include "DwarfAccelTable.h"
16 #include "DwarfCompileUnit.h"
17 #include "DwarfDebug.h"
18 #include "DwarfExpression.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/CodeGen/MachineFunction.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DIBuilder.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/GlobalVariable.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/Mangler.h"
27 #include "llvm/MC/MCAsmInfo.h"
28 #include "llvm/MC/MCContext.h"
29 #include "llvm/MC/MCSection.h"
30 #include "llvm/MC/MCStreamer.h"
31 #include "llvm/Support/CommandLine.h"
32 #include "llvm/Target/TargetFrameLowering.h"
33 #include "llvm/Target/TargetLoweringObjectFile.h"
34 #include "llvm/Target/TargetMachine.h"
35 #include "llvm/Target/TargetRegisterInfo.h"
36 #include "llvm/Target/TargetSubtargetInfo.h"
40 #define DEBUG_TYPE "dwarfdebug"
43 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
44 cl::desc("Generate DWARF4 type units."),
47 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
49 : DwarfExpression(*AP.MF->getSubtarget().getRegisterInfo(),
50 AP.getDwarfDebug()->getDwarfVersion()),
51 AP(AP), DU(DU), DIE(DIE) {}
53 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
54 DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
56 void DIEDwarfExpression::EmitSigned(int64_t Value) {
57 DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
59 void DIEDwarfExpression::EmitUnsigned(uint64_t Value) {
60 DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
62 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
63 return MachineReg == TRI.getFrameRegister(*AP.MF);
66 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag,
67 const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
69 : UniqueID(UID), CUNode(Node),
70 UnitDie(*DIE::get(DIEValueAllocator, UnitTag)), DebugInfoOffset(0),
71 Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
72 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
73 UnitTag == dwarf::DW_TAG_type_unit);
76 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
77 DwarfDebug *DW, DwarfFile *DWU,
78 MCDwarfDwoLineTable *SplitLineTable)
79 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
80 CU(CU), SplitLineTable(SplitLineTable) {
82 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
85 DwarfUnit::~DwarfUnit() {
86 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
87 DIEBlocks[j]->~DIEBlock();
88 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
89 DIELocs[j]->~DIELoc();
92 int64_t DwarfUnit::getDefaultLowerBound() const {
93 switch (getLanguage()) {
97 case dwarf::DW_LANG_C89:
98 case dwarf::DW_LANG_C99:
99 case dwarf::DW_LANG_C:
100 case dwarf::DW_LANG_C_plus_plus:
101 case dwarf::DW_LANG_ObjC:
102 case dwarf::DW_LANG_ObjC_plus_plus:
105 case dwarf::DW_LANG_Fortran77:
106 case dwarf::DW_LANG_Fortran90:
107 case dwarf::DW_LANG_Fortran95:
110 // The languages below have valid values only if the DWARF version >= 4.
111 case dwarf::DW_LANG_Java:
112 case dwarf::DW_LANG_Python:
113 case dwarf::DW_LANG_UPC:
114 case dwarf::DW_LANG_D:
115 if (dwarf::DWARF_VERSION >= 4)
119 case dwarf::DW_LANG_Ada83:
120 case dwarf::DW_LANG_Ada95:
121 case dwarf::DW_LANG_Cobol74:
122 case dwarf::DW_LANG_Cobol85:
123 case dwarf::DW_LANG_Modula2:
124 case dwarf::DW_LANG_Pascal83:
125 case dwarf::DW_LANG_PLI:
126 if (dwarf::DWARF_VERSION >= 4)
130 // The languages below have valid values only if the DWARF version >= 5.
131 case dwarf::DW_LANG_OpenCL:
132 case dwarf::DW_LANG_Go:
133 case dwarf::DW_LANG_Haskell:
134 case dwarf::DW_LANG_C_plus_plus_03:
135 case dwarf::DW_LANG_C_plus_plus_11:
136 case dwarf::DW_LANG_OCaml:
137 case dwarf::DW_LANG_Rust:
138 case dwarf::DW_LANG_C11:
139 case dwarf::DW_LANG_Swift:
140 case dwarf::DW_LANG_Dylan:
141 case dwarf::DW_LANG_C_plus_plus_14:
142 if (dwarf::DWARF_VERSION >= 5)
146 case dwarf::DW_LANG_Modula3:
147 case dwarf::DW_LANG_Julia:
148 case dwarf::DW_LANG_Fortran03:
149 case dwarf::DW_LANG_Fortran08:
150 if (dwarf::DWARF_VERSION >= 5)
158 /// Check whether the DIE for this MDNode can be shared across CUs.
159 static bool isShareableAcrossCUs(const DINode *D) {
160 // When the MDNode can be part of the type system, the DIE can be shared
162 // Combining type units and cross-CU DIE sharing is lower value (since
163 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
164 // level already) but may be implementable for some value in projects
165 // building multiple independent libraries with LTO and then linking those
167 return (isa<DIType>(D) ||
168 (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
169 !GenerateDwarfTypeUnits;
172 DIE *DwarfUnit::getDIE(const DINode *D) const {
173 if (isShareableAcrossCUs(D))
174 return DU->getDIE(D);
175 return MDNodeToDieMap.lookup(D);
178 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
179 if (isShareableAcrossCUs(Desc)) {
180 DU->insertDIE(Desc, D);
183 MDNodeToDieMap.insert(std::make_pair(Desc, D));
186 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
187 if (DD->getDwarfVersion() >= 4)
188 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
191 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
195 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
196 Optional<dwarf::Form> Form, uint64_t Integer) {
198 Form = DIEInteger::BestForm(false, Integer);
199 Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
202 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
203 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
206 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
207 Optional<dwarf::Form> Form, int64_t Integer) {
209 Form = DIEInteger::BestForm(true, Integer);
210 Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
213 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
215 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
218 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
220 Die.addValue(DIEValueAllocator, Attribute,
221 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
222 DIEString(DU->getStringPool().getEntry(*Asm, String)));
225 DIE::value_iterator DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute,
227 const MCSymbol *Label) {
228 return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
231 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
232 addLabel(Die, (dwarf::Attribute)0, Form, Label);
235 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
237 if (DD->getDwarfVersion() >= 4)
238 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
240 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
243 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
244 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
245 : getCU().getOrCreateSourceID(FileName, DirName);
248 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
249 if (!DD->useSplitDwarf()) {
250 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
251 addLabel(Die, dwarf::DW_FORM_udata, Sym);
253 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
254 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
255 DD->getAddressPool().getIndex(Sym));
259 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
260 const MCSymbol *Hi, const MCSymbol *Lo) {
261 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
262 new (DIEValueAllocator) DIEDelta(Hi, Lo));
265 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
266 addDIEEntry(Die, Attribute, DIEEntry(Entry));
269 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
270 // Flag the type unit reference as a declaration so that if it contains
271 // members (implicit special members, static data member definitions, member
272 // declarations for definitions in this CU, etc) consumers don't get confused
273 // and think this is a full definition.
274 addFlag(Die, dwarf::DW_AT_declaration);
276 Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
277 dwarf::DW_FORM_ref_sig8, DIETypeSignature(Type));
280 void DwarfUnit::addDIETypeSignature(DIE &Die, dwarf::Attribute Attribute,
281 StringRef Identifier) {
282 uint64_t Signature = DD->makeTypeSignature(Identifier);
283 Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_ref_sig8,
284 DIEInteger(Signature));
287 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
289 const DIE *DieCU = Die.getUnitOrNull();
290 const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
292 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
293 DieCU = &getUnitDie();
295 EntryCU = &getUnitDie();
296 Die.addValue(DIEValueAllocator, Attribute,
297 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
301 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
302 assert(Tag != dwarf::DW_TAG_auto_variable &&
303 Tag != dwarf::DW_TAG_arg_variable);
304 DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
310 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
311 Loc->ComputeSize(Asm);
312 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
313 Die.addValue(DIEValueAllocator, Attribute,
314 Loc->BestForm(DD->getDwarfVersion()), Loc);
317 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
319 Block->ComputeSize(Asm);
320 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
321 Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
324 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
325 StringRef Directory) {
329 unsigned FileID = getOrCreateSourceID(File, Directory);
330 assert(FileID && "Invalid file id");
331 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
332 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
335 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
338 addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
339 V->getScope()->getDirectory());
342 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
345 addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
348 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
351 addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
354 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
357 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
360 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
363 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
366 void DwarfUnit::addSourceLine(DIE &Die, const DINamespace *NS) {
367 addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
370 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
371 unsigned SizeInBits, unsigned OffsetInBits) {
372 DIEDwarfExpression Expr(*Asm, *this, TheDie);
373 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
377 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
379 DIEDwarfExpression Expr(*Asm, *this, TheDie);
380 return Expr.AddMachineRegIndirect(Reg, Offset);
383 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
384 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
385 gives the variable VarName either the struct, or a pointer to the struct, as
386 its type. This is necessary for various behind-the-scenes things the
387 compiler needs to do with by-reference variables in Blocks.
389 However, as far as the original *programmer* is concerned, the variable
390 should still have type 'SomeType', as originally declared.
392 The function getBlockByrefType dives into the __Block_byref_x_VarName
393 struct to find the original type of the variable, which is then assigned to
394 the variable's Debug Information Entry as its real type. So far, so good.
395 However now the debugger will expect the variable VarName to have the type
396 SomeType. So we need the location attribute for the variable to be an
397 expression that explains to the debugger how to navigate through the
398 pointers and struct to find the actual variable of type SomeType.
400 The following function does just that. We start by getting
401 the "normal" location for the variable. This will be the location
402 of either the struct __Block_byref_x_VarName or the pointer to the
403 struct __Block_byref_x_VarName.
405 The struct will look something like:
407 struct __Block_byref_x_VarName {
409 struct __Block_byref_x_VarName *forwarding;
410 ... <various other fields>
412 ... <maybe more fields>
415 If we are given the struct directly (as our starting point) we
416 need to tell the debugger to:
418 1). Add the offset of the forwarding field.
420 2). Follow that pointer to get the real __Block_byref_x_VarName
421 struct to use (the real one may have been copied onto the heap).
423 3). Add the offset for the field VarName, to find the actual variable.
425 If we started with a pointer to the struct, then we need to
426 dereference that pointer first, before the other steps.
427 Translating this into DWARF ops, we will need to append the following
428 to the current location description for the variable:
430 DW_OP_deref -- optional, if we start with a pointer
431 DW_OP_plus_uconst <forward_fld_offset>
433 DW_OP_plus_uconst <varName_fld_offset>
435 That is what this function does. */
437 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
438 dwarf::Attribute Attribute,
439 const MachineLocation &Location) {
440 const DIType *Ty = DV.getType();
441 const DIType *TmpTy = Ty;
442 uint16_t Tag = Ty->getTag();
443 bool isPointer = false;
445 StringRef varName = DV.getName();
447 if (Tag == dwarf::DW_TAG_pointer_type) {
448 auto *DTy = cast<DIDerivedType>(Ty);
449 TmpTy = resolve(DTy->getBaseType());
453 // Find the __forwarding field and the variable field in the __Block_byref
455 DINodeArray Fields = cast<DICompositeType>(TmpTy)->getElements();
456 const DIDerivedType *varField = nullptr;
457 const DIDerivedType *forwardingField = nullptr;
459 for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
460 auto *DT = cast<DIDerivedType>(Fields[i]);
461 StringRef fieldName = DT->getName();
462 if (fieldName == "__forwarding")
463 forwardingField = DT;
464 else if (fieldName == varName)
468 // Get the offsets for the forwarding field and the variable field.
469 unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
470 unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
472 // Decode the original location, and use that as the start of the byref
473 // variable's location.
474 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
477 if (Location.isReg())
478 validReg = addRegisterOpPiece(*Loc, Location.getReg());
480 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
485 // If we started with a pointer to the __Block_byref... struct, then
486 // the first thing we need to do is dereference the pointer (DW_OP_deref).
488 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
490 // Next add the offset for the '__forwarding' field:
491 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
492 // adding the offset if it's 0.
493 if (forwardingFieldOffset > 0) {
494 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
495 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
498 // Now dereference the __forwarding field to get to the real __Block_byref
499 // struct: DW_OP_deref.
500 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
502 // Now that we've got the real __Block_byref... struct, add the offset
503 // for the variable's field to get to the location of the actual variable:
504 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
505 if (varFieldOffset > 0) {
506 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
507 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
510 // Now attach the location information to the DIE.
511 addBlock(Die, Attribute, Loc);
514 /// Return true if type encoding is unsigned.
515 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
516 if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
517 // FIXME: Enums without a fixed underlying type have unknown signedness
518 // here, leading to incorrectly emitted constants.
519 if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
522 // (Pieces of) aggregate types that get hacked apart by SROA may be
523 // represented by a constant. Encode them as unsigned bytes.
527 if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
528 dwarf::Tag T = (dwarf::Tag)Ty->getTag();
529 // Encode pointer constants as unsigned bytes. This is used at least for
530 // null pointer constant emission.
531 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
532 // here, but accept them for now due to a bug in SROA producing bogus
534 if (T == dwarf::DW_TAG_pointer_type ||
535 T == dwarf::DW_TAG_ptr_to_member_type ||
536 T == dwarf::DW_TAG_reference_type ||
537 T == dwarf::DW_TAG_rvalue_reference_type)
539 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
540 T == dwarf::DW_TAG_volatile_type ||
541 T == dwarf::DW_TAG_restrict_type);
542 DITypeRef Deriv = DTy->getBaseType();
543 assert(Deriv && "Expected valid base type");
544 return isUnsignedDIType(DD, DD->resolve(Deriv));
547 auto *BTy = cast<DIBasicType>(Ty);
548 unsigned Encoding = BTy->getEncoding();
549 assert((Encoding == dwarf::DW_ATE_unsigned ||
550 Encoding == dwarf::DW_ATE_unsigned_char ||
551 Encoding == dwarf::DW_ATE_signed ||
552 Encoding == dwarf::DW_ATE_signed_char ||
553 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
554 Encoding == dwarf::DW_ATE_boolean ||
555 (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
556 Ty->getName() == "decltype(nullptr)")) &&
557 "Unsupported encoding");
558 return Encoding == dwarf::DW_ATE_unsigned ||
559 Encoding == dwarf::DW_ATE_unsigned_char ||
560 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
561 Ty->getTag() == dwarf::DW_TAG_unspecified_type;
564 /// If this type is derived from a base type then return base type size.
565 static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
566 unsigned Tag = Ty->getTag();
568 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
569 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
570 Tag != dwarf::DW_TAG_restrict_type)
571 return Ty->getSizeInBits();
573 auto *BaseType = DD->resolve(Ty->getBaseType());
575 assert(BaseType && "Unexpected invalid base type");
577 // If this is a derived type, go ahead and get the base type, unless it's a
578 // reference then it's just the size of the field. Pointer types have no need
579 // of this since they're a different type of qualification on the type.
580 if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
581 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
582 return Ty->getSizeInBits();
584 if (auto *DT = dyn_cast<DIDerivedType>(BaseType))
585 return getBaseTypeSize(DD, DT);
587 return BaseType->getSizeInBits();
590 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
591 assert(MO.isFPImm() && "Invalid machine operand!");
592 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
593 APFloat FPImm = MO.getFPImm()->getValueAPF();
595 // Get the raw data form of the floating point.
596 const APInt FltVal = FPImm.bitcastToAPInt();
597 const char *FltPtr = (const char *)FltVal.getRawData();
599 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
600 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
601 int Incr = (LittleEndian ? 1 : -1);
602 int Start = (LittleEndian ? 0 : NumBytes - 1);
603 int Stop = (LittleEndian ? NumBytes : -1);
605 // Output the constant to DWARF one byte at a time.
606 for (; Start != Stop; Start += Incr)
607 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
609 addBlock(Die, dwarf::DW_AT_const_value, Block);
612 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
613 // Pass this down to addConstantValue as an unsigned bag of bits.
614 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
617 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
619 addConstantValue(Die, CI->getValue(), Ty);
622 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
624 assert(MO.isImm() && "Invalid machine operand!");
626 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
629 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
630 // FIXME: This is a bit conservative/simple - it emits negative values always
631 // sign extended to 64 bits rather than minimizing the number of bytes.
632 addUInt(Die, dwarf::DW_AT_const_value,
633 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
636 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
637 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
640 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
641 unsigned CIBitWidth = Val.getBitWidth();
642 if (CIBitWidth <= 64) {
643 addConstantValue(Die, Unsigned,
644 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
648 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
650 // Get the raw data form of the large APInt.
651 const uint64_t *Ptr64 = Val.getRawData();
653 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
654 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
656 // Output the constant to DWARF one byte at a time.
657 for (int i = 0; i < NumBytes; i++) {
660 c = Ptr64[i / 8] >> (8 * (i & 7));
662 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
663 addUInt(*Block, dwarf::DW_FORM_data1, c);
666 addBlock(Die, dwarf::DW_AT_const_value, Block);
669 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
670 if (!LinkageName.empty())
672 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
673 : dwarf::DW_AT_MIPS_linkage_name,
674 GlobalValue::getRealLinkageName(LinkageName));
677 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
678 // Add template parameters.
679 for (const auto *Element : TParams) {
680 if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
681 constructTemplateTypeParameterDIE(Buffer, TTP);
682 else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
683 constructTemplateValueParameterDIE(Buffer, TVP);
687 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
688 if (!Context || isa<DIFile>(Context))
689 return &getUnitDie();
690 if (auto *T = dyn_cast<DIType>(Context))
691 return getOrCreateTypeDIE(T);
692 if (auto *NS = dyn_cast<DINamespace>(Context))
693 return getOrCreateNameSpace(NS);
694 if (auto *SP = dyn_cast<DISubprogram>(Context))
695 return getOrCreateSubprogramDIE(SP);
696 return getDIE(Context);
699 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
700 auto *Context = resolve(Ty->getScope());
701 DIE *ContextDIE = getOrCreateContextDIE(Context);
703 if (DIE *TyDIE = getDIE(Ty))
707 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
709 constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
711 if (!Ty->isExternalTypeRef())
712 updateAcceleratorTables(Context, Ty, TyDIE);
716 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
720 auto *Ty = cast<DIType>(TyNode);
721 assert(Ty == resolve(Ty->getRef()) &&
722 "type was not uniqued, possible ODR violation.");
724 // DW_TAG_restrict_type is not supported in DWARF2
725 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
726 return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
728 // Construct the context before querying for the existence of the DIE in case
729 // such construction creates the DIE.
730 auto *Context = resolve(Ty->getScope());
731 DIE *ContextDIE = getOrCreateContextDIE(Context);
734 if (DIE *TyDIE = getDIE(Ty))
738 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
740 updateAcceleratorTables(Context, Ty, TyDIE);
742 if (auto *BT = dyn_cast<DIBasicType>(Ty))
743 constructTypeDIE(TyDIE, BT);
744 else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
745 constructTypeDIE(TyDIE, STy);
746 else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
747 if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
748 if (MDString *TypeId = CTy->getRawIdentifier()) {
749 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
750 // Skip updating the accelerator tables since this is not the full type.
753 constructTypeDIE(TyDIE, CTy);
755 constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
761 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
762 const DIType *Ty, const DIE &TyDIE) {
763 if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
764 bool IsImplementation = 0;
765 if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
766 // A runtime language of 0 actually means C/C++ and that any
767 // non-negative value is some version of Objective-C/C++.
768 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
770 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
771 DD->addAccelType(Ty->getName(), TyDIE, Flags);
773 if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
774 isa<DINamespace>(Context))
775 addGlobalType(Ty, TyDIE, Context);
779 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
780 dwarf::Attribute Attribute) {
781 assert(Ty && "Trying to add a type that doesn't exist?");
782 addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
785 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
789 // FIXME: Decide whether to implement this for non-C++ languages.
790 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
794 SmallVector<const DIScope *, 1> Parents;
795 while (!isa<DICompileUnit>(Context)) {
796 Parents.push_back(Context);
797 if (Context->getScope())
798 Context = resolve(Context->getScope());
800 // Structure, etc types will have a NULL context if they're at the top
805 // Reverse iterate over our list to go from the outermost construct to the
807 for (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
808 const DIScope *Ctx = *I;
809 StringRef Name = Ctx->getName();
810 if (Name.empty() && isa<DINamespace>(Ctx))
811 Name = "(anonymous namespace)";
820 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
821 // Get core information.
822 StringRef Name = BTy->getName();
823 // Add name if not anonymous or intermediate type.
825 addString(Buffer, dwarf::DW_AT_name, Name);
827 // An unspecified type only has a name attribute.
828 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
831 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
834 uint64_t Size = BTy->getSizeInBits() >> 3;
835 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
838 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
839 // Get core information.
840 StringRef Name = DTy->getName();
841 uint64_t Size = DTy->getSizeInBits() >> 3;
842 uint16_t Tag = Buffer.getTag();
844 // Map to main type, void will not have a type.
845 const DIType *FromTy = resolve(DTy->getBaseType());
847 addType(Buffer, FromTy);
849 // Add name if not anonymous or intermediate type.
851 addString(Buffer, dwarf::DW_AT_name, Name);
853 // Add size if non-zero (derived types might be zero-sized.)
854 if (Size && Tag != dwarf::DW_TAG_pointer_type
855 && Tag != dwarf::DW_TAG_ptr_to_member_type)
856 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
858 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
860 Buffer, dwarf::DW_AT_containing_type,
861 *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
862 // Add source line info if available and TyDesc is not a forward declaration.
863 if (!DTy->isForwardDecl())
864 addSourceLine(Buffer, DTy);
867 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
868 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
869 const DIType *Ty = resolve(Args[i]);
871 assert(i == N-1 && "Unspecified parameter must be the last argument");
872 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
874 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
876 if (Ty->isArtificial())
877 addFlag(Arg, dwarf::DW_AT_artificial);
882 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
883 // Add return type. A void return won't have a type.
884 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
886 if (auto RTy = resolve(Elements[0]))
887 addType(Buffer, RTy);
889 bool isPrototyped = true;
890 if (Elements.size() == 2 && !Elements[1])
891 isPrototyped = false;
893 constructSubprogramArguments(Buffer, Elements);
895 // Add prototype flag if we're dealing with a C language and the function has
897 uint16_t Language = getLanguage();
899 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
900 Language == dwarf::DW_LANG_ObjC))
901 addFlag(Buffer, dwarf::DW_AT_prototyped);
903 if (CTy->isLValueReference())
904 addFlag(Buffer, dwarf::DW_AT_reference);
906 if (CTy->isRValueReference())
907 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
910 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
911 if (CTy->isExternalTypeRef()) {
912 StringRef Identifier = CTy->getIdentifier();
913 assert(!Identifier.empty() && "external type ref without identifier");
914 addFlag(Buffer, dwarf::DW_AT_declaration);
915 return addDIETypeSignature(Buffer, dwarf::DW_AT_signature, Identifier);
918 // Add name if not anonymous or intermediate type.
919 StringRef Name = CTy->getName();
921 uint64_t Size = CTy->getSizeInBits() >> 3;
922 uint16_t Tag = Buffer.getTag();
925 case dwarf::DW_TAG_array_type:
926 constructArrayTypeDIE(Buffer, CTy);
928 case dwarf::DW_TAG_enumeration_type:
929 constructEnumTypeDIE(Buffer, CTy);
931 case dwarf::DW_TAG_structure_type:
932 case dwarf::DW_TAG_union_type:
933 case dwarf::DW_TAG_class_type: {
934 // Add elements to structure type.
935 DINodeArray Elements = CTy->getElements();
936 for (const auto *Element : Elements) {
939 if (auto *SP = dyn_cast<DISubprogram>(Element))
940 getOrCreateSubprogramDIE(SP);
941 else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
942 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
943 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
944 addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
945 } else if (DDTy->isStaticMember()) {
946 getOrCreateStaticMemberDIE(DDTy);
948 constructMemberDIE(Buffer, DDTy);
950 } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
951 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
952 StringRef PropertyName = Property->getName();
953 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
954 if (Property->getType())
955 addType(ElemDie, resolve(Property->getType()));
956 addSourceLine(ElemDie, Property);
957 StringRef GetterName = Property->getGetterName();
958 if (!GetterName.empty())
959 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
960 StringRef SetterName = Property->getSetterName();
961 if (!SetterName.empty())
962 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
963 if (unsigned PropertyAttributes = Property->getAttributes())
964 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
969 if (CTy->isAppleBlockExtension())
970 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
972 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
973 // inside C++ composite types to point to the base class with the vtable.
974 if (auto *ContainingType =
975 dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
976 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
977 *getOrCreateTypeDIE(ContainingType));
979 if (CTy->isObjcClassComplete())
980 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
982 // Add template parameters to a class, structure or union types.
983 // FIXME: The support isn't in the metadata for this yet.
984 if (Tag == dwarf::DW_TAG_class_type ||
985 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
986 addTemplateParams(Buffer, CTy->getTemplateParams());
994 // Add name if not anonymous or intermediate type.
996 addString(Buffer, dwarf::DW_AT_name, Name);
998 if (Tag == dwarf::DW_TAG_enumeration_type ||
999 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1000 Tag == dwarf::DW_TAG_union_type) {
1001 // Add size if non-zero (derived types might be zero-sized.)
1002 // TODO: Do we care about size for enum forward declarations?
1004 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1005 else if (!CTy->isForwardDecl())
1006 // Add zero size if it is not a forward declaration.
1007 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1009 // If we're a forward decl, say so.
1010 if (CTy->isForwardDecl())
1011 addFlag(Buffer, dwarf::DW_AT_declaration);
1013 // Add source line info if available.
1014 if (!CTy->isForwardDecl())
1015 addSourceLine(Buffer, CTy);
1017 // No harm in adding the runtime language to the declaration.
1018 unsigned RLang = CTy->getRuntimeLang();
1020 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1025 void DwarfUnit::constructTemplateTypeParameterDIE(
1026 DIE &Buffer, const DITemplateTypeParameter *TP) {
1028 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1029 // Add the type if it exists, it could be void and therefore no type.
1031 addType(ParamDIE, resolve(TP->getType()));
1032 if (!TP->getName().empty())
1033 addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1036 void DwarfUnit::constructTemplateValueParameterDIE(
1037 DIE &Buffer, const DITemplateValueParameter *VP) {
1038 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1040 // Add the type if there is one, template template and template parameter
1041 // packs will not have a type.
1042 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1043 addType(ParamDIE, resolve(VP->getType()));
1044 if (!VP->getName().empty())
1045 addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1046 if (Metadata *Val = VP->getValue()) {
1047 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1048 addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1049 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1050 // For declaration non-type template parameters (such as global values and
1052 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1053 addOpAddress(*Loc, Asm->getSymbol(GV));
1054 // Emit DW_OP_stack_value to use the address as the immediate value of the
1055 // parameter, rather than a pointer to it.
1056 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1057 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1058 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1059 assert(isa<MDString>(Val));
1060 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1061 cast<MDString>(Val)->getString());
1062 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1063 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1068 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1069 // Construct the context before querying for the existence of the DIE in case
1070 // such construction creates the DIE.
1071 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1073 if (DIE *NDie = getDIE(NS))
1075 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1077 StringRef Name = NS->getName();
1079 addString(NDie, dwarf::DW_AT_name, NS->getName());
1081 Name = "(anonymous namespace)";
1082 DD->addAccelNamespace(Name, NDie);
1083 addGlobalName(Name, NDie, NS->getScope());
1084 addSourceLine(NDie, NS);
1088 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1089 // Construct the context before querying for the existence of the DIE in case
1090 // such construction creates the DIE.
1091 DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1093 if (DIE *MDie = getDIE(M))
1095 DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1097 if (!M->getName().empty()) {
1098 addString(MDie, dwarf::DW_AT_name, M->getName());
1099 addGlobalName(M->getName(), MDie, M->getScope());
1101 if (!M->getConfigurationMacros().empty())
1102 addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1103 M->getConfigurationMacros());
1104 if (!M->getIncludePath().empty())
1105 addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1106 if (!M->getISysRoot().empty())
1107 addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1112 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1113 // Construct the context before querying for the existence of the DIE in case
1114 // such construction creates the DIE (as is the case for member function
1117 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1119 if (DIE *SPDie = getDIE(SP))
1122 if (auto *SPDecl = SP->getDeclaration()) {
1124 // Add subprogram definitions to the CU die directly.
1125 ContextDIE = &getUnitDie();
1126 // Build the decl now to ensure it precedes the definition.
1127 getOrCreateSubprogramDIE(SPDecl);
1131 // DW_TAG_inlined_subroutine may refer to this DIE.
1132 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1134 // Stop here and fill this in later, depending on whether or not this
1135 // subprogram turns out to have inlined instances or not.
1136 if (SP->isDefinition())
1139 applySubprogramAttributes(SP, SPDie);
1143 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1145 DIE *DeclDie = nullptr;
1146 StringRef DeclLinkageName;
1147 if (auto *SPDecl = SP->getDeclaration()) {
1148 DeclDie = getDIE(SPDecl);
1149 assert(DeclDie && "This DIE should've already been constructed when the "
1150 "definition DIE was created in "
1151 "getOrCreateSubprogramDIE");
1152 DeclLinkageName = SPDecl->getLinkageName();
1155 // Add function template parameters.
1156 addTemplateParams(SPDie, SP->getTemplateParams());
1158 // Add the linkage name if we have one and it isn't in the Decl.
1159 StringRef LinkageName = SP->getLinkageName();
1160 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1161 LinkageName == DeclLinkageName) &&
1162 "decl has a linkage name and it is different");
1163 if (DeclLinkageName.empty())
1164 addLinkageName(SPDie, LinkageName);
1169 // Refer to the function declaration where all the other attributes will be
1171 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1175 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1178 if (applySubprogramDefinitionAttributes(SP, SPDie))
1181 // Constructors and operators for anonymous aggregates do not have names.
1182 if (!SP->getName().empty())
1183 addString(SPDie, dwarf::DW_AT_name, SP->getName());
1185 // Skip the rest of the attributes under -gmlt to save space.
1189 addSourceLine(SPDie, SP);
1191 // Add the prototype if we have a prototype and we have a C like
1193 uint16_t Language = getLanguage();
1194 if (SP->isPrototyped() &&
1195 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1196 Language == dwarf::DW_LANG_ObjC))
1197 addFlag(SPDie, dwarf::DW_AT_prototyped);
1199 const DISubroutineType *SPTy = SP->getType();
1200 assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1201 "the type of a subprogram should be a subroutine");
1203 auto Args = SPTy->getTypeArray();
1204 // Add a return type. If this is a type like a C/C++ void type we don't add a
1207 if (auto Ty = resolve(Args[0]))
1210 unsigned VK = SP->getVirtuality();
1212 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1213 DIELoc *Block = getDIELoc();
1214 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1215 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1216 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1217 ContainingTypeMap.insert(
1218 std::make_pair(&SPDie, resolve(SP->getContainingType())));
1221 if (!SP->isDefinition()) {
1222 addFlag(SPDie, dwarf::DW_AT_declaration);
1224 // Add arguments. Do not add arguments for subprogram definition. They will
1225 // be handled while processing variables.
1226 constructSubprogramArguments(SPDie, Args);
1229 if (SP->isArtificial())
1230 addFlag(SPDie, dwarf::DW_AT_artificial);
1232 if (!SP->isLocalToUnit())
1233 addFlag(SPDie, dwarf::DW_AT_external);
1235 if (SP->isOptimized())
1236 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1238 if (unsigned isa = Asm->getISAEncoding())
1239 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1241 if (SP->isLValueReference())
1242 addFlag(SPDie, dwarf::DW_AT_reference);
1244 if (SP->isRValueReference())
1245 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1247 if (SP->isProtected())
1248 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1249 dwarf::DW_ACCESS_protected);
1250 else if (SP->isPrivate())
1251 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1252 dwarf::DW_ACCESS_private);
1253 else if (SP->isPublic())
1254 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1255 dwarf::DW_ACCESS_public);
1257 if (SP->isExplicit())
1258 addFlag(SPDie, dwarf::DW_AT_explicit);
1261 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1263 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1264 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1266 // The LowerBound value defines the lower bounds which is typically zero for
1267 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1268 // Count == -1 then the array is unbounded and we do not emit
1269 // DW_AT_lower_bound and DW_AT_count attributes.
1270 int64_t LowerBound = SR->getLowerBound();
1271 int64_t DefaultLowerBound = getDefaultLowerBound();
1272 int64_t Count = SR->getCount();
1274 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1275 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1278 // FIXME: An unbounded array should reference the expression that defines
1280 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1283 DIE *DwarfUnit::getIndexTyDie() {
1286 // Construct an integer type to use for indexes.
1287 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1288 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1289 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1290 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1291 dwarf::DW_ATE_unsigned);
1295 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1296 if (CTy->isVector())
1297 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1299 // Emit the element type.
1300 addType(Buffer, resolve(CTy->getBaseType()));
1302 // Get an anonymous type for index type.
1303 // FIXME: This type should be passed down from the front end
1304 // as different languages may have different sizes for indexes.
1305 DIE *IdxTy = getIndexTyDie();
1307 // Add subranges to array type.
1308 DINodeArray Elements = CTy->getElements();
1309 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1310 // FIXME: Should this really be such a loose cast?
1311 if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1312 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1313 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1317 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1318 DINodeArray Elements = CTy->getElements();
1320 // Add enumerators to enumeration type.
1321 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1322 auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1324 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1325 StringRef Name = Enum->getName();
1326 addString(Enumerator, dwarf::DW_AT_name, Name);
1327 int64_t Value = Enum->getValue();
1328 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1332 const DIType *DTy = resolve(CTy->getBaseType());
1334 addType(Buffer, DTy);
1335 addFlag(Buffer, dwarf::DW_AT_enum_class);
1339 void DwarfUnit::constructContainingTypeDIEs() {
1340 for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1342 DIE &SPDie = *CI->first;
1343 const DINode *D = CI->second;
1346 DIE *NDie = getDIE(D);
1349 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1353 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1354 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1355 StringRef Name = DT->getName();
1357 addString(MemberDie, dwarf::DW_AT_name, Name);
1359 addType(MemberDie, resolve(DT->getBaseType()));
1361 addSourceLine(MemberDie, DT);
1363 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1365 // For C++, virtual base classes are not at fixed offset. Use following
1366 // expression to extract appropriate offset from vtable.
1367 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1369 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1370 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1371 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1372 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1373 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1374 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1375 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1376 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1378 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1380 uint64_t Size = DT->getSizeInBits();
1381 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1382 uint64_t OffsetInBytes;
1384 if (FieldSize && Size != FieldSize) {
1385 // Handle bitfield, assume bytes are 8 bits.
1386 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1387 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1389 // The DWARF 2 DW_AT_bit_offset is counting the bits between the most
1390 // significant bit of the aligned storage unit containing the bit field to
1391 // the most significan bit of the bit field.
1393 // FIXME: DWARF 4 states that DW_AT_data_bit_offset (which
1394 // counts from the beginning, regardless of endianness) should
1398 // Struct Align Align Align
1400 // +-----------+-----*-----+-----*-----+--
1401 // | ... |b1|b2|b3|b4|
1402 // +-----------+-----*-----+-----*-----+--
1403 // | | |<-- Size ->| |
1404 // |<---- Offset --->| |<--->|
1405 // | | | \_ DW_AT_bit_offset (little endian)
1407 // |<--------->| \_ StartBitOffset = DW_AT_bit_offset (big endian)
1408 // \ = DW_AT_data_bit_offset (biendian)
1410 uint64_t Offset = DT->getOffsetInBits();
1411 uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1412 uint64_t AlignMask = ~(Align - 1);
1413 // The bits from the start of the storage unit to the start of the field.
1414 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1415 // The endian-dependent DWARF 2 offset.
1416 uint64_t DwarfBitOffset = Asm->getDataLayout().isLittleEndian()
1417 ? OffsetToAlignment(Offset + Size, Align)
1420 // The byte offset of the field's aligned storage unit inside the struct.
1421 OffsetInBytes = (Offset - StartBitOffset) / 8;
1422 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, DwarfBitOffset);
1424 // This is not a bitfield.
1425 OffsetInBytes = DT->getOffsetInBits() / 8;
1427 if (DD->getDwarfVersion() <= 2) {
1428 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1429 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1430 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1431 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1433 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1437 if (DT->isProtected())
1438 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1439 dwarf::DW_ACCESS_protected);
1440 else if (DT->isPrivate())
1441 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1442 dwarf::DW_ACCESS_private);
1443 // Otherwise C++ member and base classes are considered public.
1444 else if (DT->isPublic())
1445 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1446 dwarf::DW_ACCESS_public);
1447 if (DT->isVirtual())
1448 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1449 dwarf::DW_VIRTUALITY_virtual);
1451 // Objective-C properties.
1452 if (DINode *PNode = DT->getObjCProperty())
1453 if (DIE *PDie = getDIE(PNode))
1454 MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1455 dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1457 if (DT->isArtificial())
1458 addFlag(MemberDie, dwarf::DW_AT_artificial);
1461 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1465 // Construct the context before querying for the existence of the DIE in case
1466 // such construction creates the DIE.
1467 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1468 assert(dwarf::isType(ContextDIE->getTag()) &&
1469 "Static member should belong to a type.");
1471 if (DIE *StaticMemberDIE = getDIE(DT))
1472 return StaticMemberDIE;
1474 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1476 const DIType *Ty = resolve(DT->getBaseType());
1478 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1479 addType(StaticMemberDIE, Ty);
1480 addSourceLine(StaticMemberDIE, DT);
1481 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1482 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1484 // FIXME: We could omit private if the parent is a class_type, and
1485 // public if the parent is something else.
1486 if (DT->isProtected())
1487 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1488 dwarf::DW_ACCESS_protected);
1489 else if (DT->isPrivate())
1490 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1491 dwarf::DW_ACCESS_private);
1492 else if (DT->isPublic())
1493 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1494 dwarf::DW_ACCESS_public);
1496 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1497 addConstantValue(StaticMemberDIE, CI, Ty);
1498 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1499 addConstantFPValue(StaticMemberDIE, CFP);
1501 return &StaticMemberDIE;
1504 void DwarfUnit::emitHeader(bool UseOffsets) {
1505 // Emit size of content not including length itself
1506 Asm->OutStreamer->AddComment("Length of Unit");
1507 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1509 Asm->OutStreamer->AddComment("DWARF version number");
1510 Asm->EmitInt16(DD->getDwarfVersion());
1511 Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1513 // We share one abbreviations table across all units so it's always at the
1514 // start of the section. Use a relocatable offset where needed to ensure
1515 // linking doesn't invalidate that offset.
1516 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1517 Asm->emitDwarfSymbolReference(TLOF.getDwarfAbbrevSection()->getBeginSymbol(),
1520 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1521 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1524 void DwarfUnit::initSection(MCSection *Section) {
1525 assert(!this->Section);
1526 this->Section = Section;
1529 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1530 DwarfUnit::emitHeader(UseOffsets);
1531 Asm->OutStreamer->AddComment("Type Signature");
1532 Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1533 Asm->OutStreamer->AddComment("Type DIE Offset");
1534 // In a skeleton type unit there is no type DIE so emit a zero offset.
1535 Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1536 sizeof(Ty->getOffset()));
1539 bool DwarfTypeUnit::isDwoUnit() const {
1540 // Since there are no skeleton type units, all type units are dwo type units
1541 // when split DWARF is being used.
1542 return DD->useSplitDwarf();