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 *DTy = dyn_cast<DIDerivedTypeBase>(Ty)) {
517 dwarf::Tag T = (dwarf::Tag)Ty->getTag();
518 // Encode pointer constants as unsigned bytes. This is used at least for
519 // null pointer constant emission.
520 // (Pieces of) aggregate types that get hacked apart by SROA may also be
521 // represented by a constant. Encode them as unsigned bytes.
522 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
523 // here, but accept them for now due to a bug in SROA producing bogus
525 if (T == dwarf::DW_TAG_array_type ||
526 T == dwarf::DW_TAG_class_type ||
527 T == dwarf::DW_TAG_pointer_type ||
528 T == dwarf::DW_TAG_ptr_to_member_type ||
529 T == dwarf::DW_TAG_reference_type ||
530 T == dwarf::DW_TAG_rvalue_reference_type ||
531 T == dwarf::DW_TAG_structure_type ||
532 T == dwarf::DW_TAG_union_type)
534 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
535 T == dwarf::DW_TAG_volatile_type ||
536 T == dwarf::DW_TAG_restrict_type ||
537 T == dwarf::DW_TAG_enumeration_type);
538 if (DITypeRef Deriv = DTy->getBaseType())
539 return isUnsignedDIType(DD, DD->resolve(Deriv));
540 // FIXME: Enums without a fixed underlying type have unknown signedness
541 // here, leading to incorrectly emitted constants.
542 assert(DTy->getTag() == dwarf::DW_TAG_enumeration_type);
546 auto *BTy = cast<DIBasicType>(Ty);
547 unsigned Encoding = BTy->getEncoding();
548 assert((Encoding == dwarf::DW_ATE_unsigned ||
549 Encoding == dwarf::DW_ATE_unsigned_char ||
550 Encoding == dwarf::DW_ATE_signed ||
551 Encoding == dwarf::DW_ATE_signed_char ||
552 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
553 Encoding == dwarf::DW_ATE_boolean ||
554 (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
555 Ty->getName() == "decltype(nullptr)")) &&
556 "Unsupported encoding");
557 return Encoding == dwarf::DW_ATE_unsigned ||
558 Encoding == dwarf::DW_ATE_unsigned_char ||
559 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
560 Ty->getTag() == dwarf::DW_TAG_unspecified_type;
563 /// If this type is derived from a base type then return base type size.
564 static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
565 unsigned Tag = Ty->getTag();
567 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
568 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
569 Tag != dwarf::DW_TAG_restrict_type)
570 return Ty->getSizeInBits();
572 auto *BaseType = DD->resolve(Ty->getBaseType());
574 assert(BaseType && "Unexpected invalid base type");
576 // If this is a derived type, go ahead and get the base type, unless it's a
577 // reference then it's just the size of the field. Pointer types have no need
578 // of this since they're a different type of qualification on the type.
579 if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
580 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
581 return Ty->getSizeInBits();
583 if (auto *DT = dyn_cast<DIDerivedType>(BaseType))
584 return getBaseTypeSize(DD, DT);
586 return BaseType->getSizeInBits();
589 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
590 assert(MO.isFPImm() && "Invalid machine operand!");
591 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
592 APFloat FPImm = MO.getFPImm()->getValueAPF();
594 // Get the raw data form of the floating point.
595 const APInt FltVal = FPImm.bitcastToAPInt();
596 const char *FltPtr = (const char *)FltVal.getRawData();
598 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
599 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
600 int Incr = (LittleEndian ? 1 : -1);
601 int Start = (LittleEndian ? 0 : NumBytes - 1);
602 int Stop = (LittleEndian ? NumBytes : -1);
604 // Output the constant to DWARF one byte at a time.
605 for (; Start != Stop; Start += Incr)
606 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
608 addBlock(Die, dwarf::DW_AT_const_value, Block);
611 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
612 // Pass this down to addConstantValue as an unsigned bag of bits.
613 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
616 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
618 addConstantValue(Die, CI->getValue(), Ty);
621 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
623 assert(MO.isImm() && "Invalid machine operand!");
625 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
628 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
629 // FIXME: This is a bit conservative/simple - it emits negative values always
630 // sign extended to 64 bits rather than minimizing the number of bytes.
631 addUInt(Die, dwarf::DW_AT_const_value,
632 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
635 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
636 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
639 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
640 unsigned CIBitWidth = Val.getBitWidth();
641 if (CIBitWidth <= 64) {
642 addConstantValue(Die, Unsigned,
643 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
647 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
649 // Get the raw data form of the large APInt.
650 const uint64_t *Ptr64 = Val.getRawData();
652 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
653 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
655 // Output the constant to DWARF one byte at a time.
656 for (int i = 0; i < NumBytes; i++) {
659 c = Ptr64[i / 8] >> (8 * (i & 7));
661 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
662 addUInt(*Block, dwarf::DW_FORM_data1, c);
665 addBlock(Die, dwarf::DW_AT_const_value, Block);
668 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
669 if (!LinkageName.empty())
671 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
672 : dwarf::DW_AT_MIPS_linkage_name,
673 GlobalValue::getRealLinkageName(LinkageName));
676 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
677 // Add template parameters.
678 for (const auto *Element : TParams) {
679 if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
680 constructTemplateTypeParameterDIE(Buffer, TTP);
681 else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
682 constructTemplateValueParameterDIE(Buffer, TVP);
686 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
687 if (!Context || isa<DIFile>(Context))
688 return &getUnitDie();
689 if (auto *T = dyn_cast<DIType>(Context))
690 return getOrCreateTypeDIE(T);
691 if (auto *NS = dyn_cast<DINamespace>(Context))
692 return getOrCreateNameSpace(NS);
693 if (auto *SP = dyn_cast<DISubprogram>(Context))
694 return getOrCreateSubprogramDIE(SP);
695 return getDIE(Context);
698 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
699 auto *Context = resolve(Ty->getScope());
700 DIE *ContextDIE = getOrCreateContextDIE(Context);
702 if (DIE *TyDIE = getDIE(Ty))
706 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
708 constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
710 if (!Ty->isExternalTypeRef())
711 updateAcceleratorTables(Context, Ty, TyDIE);
715 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
719 auto *Ty = cast<DIType>(TyNode);
720 assert(Ty == resolve(Ty->getRef()) &&
721 "type was not uniqued, possible ODR violation.");
723 // DW_TAG_restrict_type is not supported in DWARF2
724 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
725 return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
727 // Construct the context before querying for the existence of the DIE in case
728 // such construction creates the DIE.
729 auto *Context = resolve(Ty->getScope());
730 DIE *ContextDIE = getOrCreateContextDIE(Context);
733 if (DIE *TyDIE = getDIE(Ty))
737 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
739 updateAcceleratorTables(Context, Ty, TyDIE);
741 if (auto *BT = dyn_cast<DIBasicType>(Ty))
742 constructTypeDIE(TyDIE, BT);
743 else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
744 constructTypeDIE(TyDIE, STy);
745 else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
746 if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
747 if (MDString *TypeId = CTy->getRawIdentifier()) {
748 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
749 // Skip updating the accelerator tables since this is not the full type.
752 constructTypeDIE(TyDIE, CTy);
754 constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
760 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
761 const DIType *Ty, const DIE &TyDIE) {
762 if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
763 bool IsImplementation = 0;
764 if (auto *CT = dyn_cast<DICompositeTypeBase>(Ty)) {
765 // A runtime language of 0 actually means C/C++ and that any
766 // non-negative value is some version of Objective-C/C++.
767 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
769 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
770 DD->addAccelType(Ty->getName(), TyDIE, Flags);
772 if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
773 isa<DINamespace>(Context))
774 addGlobalType(Ty, TyDIE, Context);
778 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
779 dwarf::Attribute Attribute) {
780 assert(Ty && "Trying to add a type that doesn't exist?");
781 addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
784 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
788 // FIXME: Decide whether to implement this for non-C++ languages.
789 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
793 SmallVector<const DIScope *, 1> Parents;
794 while (!isa<DICompileUnit>(Context)) {
795 Parents.push_back(Context);
796 if (Context->getScope())
797 Context = resolve(Context->getScope());
799 // Structure, etc types will have a NULL context if they're at the top
804 // Reverse iterate over our list to go from the outermost construct to the
806 for (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
807 const DIScope *Ctx = *I;
808 StringRef Name = Ctx->getName();
809 if (Name.empty() && isa<DINamespace>(Ctx))
810 Name = "(anonymous namespace)";
819 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
820 // Get core information.
821 StringRef Name = BTy->getName();
822 // Add name if not anonymous or intermediate type.
824 addString(Buffer, dwarf::DW_AT_name, Name);
826 // An unspecified type only has a name attribute.
827 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
830 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
833 uint64_t Size = BTy->getSizeInBits() >> 3;
834 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
837 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
838 // Get core information.
839 StringRef Name = DTy->getName();
840 uint64_t Size = DTy->getSizeInBits() >> 3;
841 uint16_t Tag = Buffer.getTag();
843 // Map to main type, void will not have a type.
844 const DIType *FromTy = resolve(DTy->getBaseType());
846 addType(Buffer, FromTy);
848 // Add name if not anonymous or intermediate type.
850 addString(Buffer, dwarf::DW_AT_name, Name);
852 // Add size if non-zero (derived types might be zero-sized.)
853 if (Size && Tag != dwarf::DW_TAG_pointer_type
854 && Tag != dwarf::DW_TAG_ptr_to_member_type)
855 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
857 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
859 Buffer, dwarf::DW_AT_containing_type,
860 *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
861 // Add source line info if available and TyDesc is not a forward declaration.
862 if (!DTy->isForwardDecl())
863 addSourceLine(Buffer, DTy);
866 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
867 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
868 const DIType *Ty = resolve(Args[i]);
870 assert(i == N-1 && "Unspecified parameter must be the last argument");
871 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
873 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
875 if (Ty->isArtificial())
876 addFlag(Arg, dwarf::DW_AT_artificial);
881 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
882 // Add return type. A void return won't have a type.
883 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
885 if (auto RTy = resolve(Elements[0]))
886 addType(Buffer, RTy);
888 bool isPrototyped = true;
889 if (Elements.size() == 2 && !Elements[1])
890 isPrototyped = false;
892 constructSubprogramArguments(Buffer, Elements);
894 // Add prototype flag if we're dealing with a C language and the function has
896 uint16_t Language = getLanguage();
898 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
899 Language == dwarf::DW_LANG_ObjC))
900 addFlag(Buffer, dwarf::DW_AT_prototyped);
902 if (CTy->isLValueReference())
903 addFlag(Buffer, dwarf::DW_AT_reference);
905 if (CTy->isRValueReference())
906 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
909 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
910 if (CTy->isExternalTypeRef()) {
911 StringRef Identifier = CTy->getIdentifier();
912 assert(!Identifier.empty() && "external type ref without identifier");
913 addFlag(Buffer, dwarf::DW_AT_declaration);
914 return addDIETypeSignature(Buffer, dwarf::DW_AT_signature, Identifier);
917 // Add name if not anonymous or intermediate type.
918 StringRef Name = CTy->getName();
920 uint64_t Size = CTy->getSizeInBits() >> 3;
921 uint16_t Tag = Buffer.getTag();
924 case dwarf::DW_TAG_array_type:
925 constructArrayTypeDIE(Buffer, CTy);
927 case dwarf::DW_TAG_enumeration_type:
928 constructEnumTypeDIE(Buffer, CTy);
930 case dwarf::DW_TAG_structure_type:
931 case dwarf::DW_TAG_union_type:
932 case dwarf::DW_TAG_class_type: {
933 // Add elements to structure type.
934 DINodeArray Elements = CTy->getElements();
935 for (const auto *Element : Elements) {
938 if (auto *SP = dyn_cast<DISubprogram>(Element))
939 getOrCreateSubprogramDIE(SP);
940 else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
941 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
942 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
943 addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
944 } else if (DDTy->isStaticMember()) {
945 getOrCreateStaticMemberDIE(DDTy);
947 constructMemberDIE(Buffer, DDTy);
949 } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
950 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
951 StringRef PropertyName = Property->getName();
952 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
953 if (Property->getType())
954 addType(ElemDie, resolve(Property->getType()));
955 addSourceLine(ElemDie, Property);
956 StringRef GetterName = Property->getGetterName();
957 if (!GetterName.empty())
958 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
959 StringRef SetterName = Property->getSetterName();
960 if (!SetterName.empty())
961 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
962 if (unsigned PropertyAttributes = Property->getAttributes())
963 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
968 if (CTy->isAppleBlockExtension())
969 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
971 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
972 // inside C++ composite types to point to the base class with the vtable.
973 if (auto *ContainingType =
974 dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
975 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
976 *getOrCreateTypeDIE(ContainingType));
978 if (CTy->isObjcClassComplete())
979 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
981 // Add template parameters to a class, structure or union types.
982 // FIXME: The support isn't in the metadata for this yet.
983 if (Tag == dwarf::DW_TAG_class_type ||
984 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
985 addTemplateParams(Buffer, CTy->getTemplateParams());
993 // Add name if not anonymous or intermediate type.
995 addString(Buffer, dwarf::DW_AT_name, Name);
997 if (Tag == dwarf::DW_TAG_enumeration_type ||
998 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
999 Tag == dwarf::DW_TAG_union_type) {
1000 // Add size if non-zero (derived types might be zero-sized.)
1001 // TODO: Do we care about size for enum forward declarations?
1003 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1004 else if (!CTy->isForwardDecl())
1005 // Add zero size if it is not a forward declaration.
1006 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1008 // If we're a forward decl, say so.
1009 if (CTy->isForwardDecl())
1010 addFlag(Buffer, dwarf::DW_AT_declaration);
1012 // Add source line info if available.
1013 if (!CTy->isForwardDecl())
1014 addSourceLine(Buffer, CTy);
1016 // No harm in adding the runtime language to the declaration.
1017 unsigned RLang = CTy->getRuntimeLang();
1019 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1024 void DwarfUnit::constructTemplateTypeParameterDIE(
1025 DIE &Buffer, const DITemplateTypeParameter *TP) {
1027 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1028 // Add the type if it exists, it could be void and therefore no type.
1030 addType(ParamDIE, resolve(TP->getType()));
1031 if (!TP->getName().empty())
1032 addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1035 void DwarfUnit::constructTemplateValueParameterDIE(
1036 DIE &Buffer, const DITemplateValueParameter *VP) {
1037 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1039 // Add the type if there is one, template template and template parameter
1040 // packs will not have a type.
1041 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1042 addType(ParamDIE, resolve(VP->getType()));
1043 if (!VP->getName().empty())
1044 addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1045 if (Metadata *Val = VP->getValue()) {
1046 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1047 addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1048 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1049 // For declaration non-type template parameters (such as global values and
1051 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1052 addOpAddress(*Loc, Asm->getSymbol(GV));
1053 // Emit DW_OP_stack_value to use the address as the immediate value of the
1054 // parameter, rather than a pointer to it.
1055 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1056 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1057 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1058 assert(isa<MDString>(Val));
1059 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1060 cast<MDString>(Val)->getString());
1061 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1062 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1067 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1068 // Construct the context before querying for the existence of the DIE in case
1069 // such construction creates the DIE.
1070 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1072 if (DIE *NDie = getDIE(NS))
1074 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1076 StringRef Name = NS->getName();
1078 addString(NDie, dwarf::DW_AT_name, NS->getName());
1080 Name = "(anonymous namespace)";
1081 DD->addAccelNamespace(Name, NDie);
1082 addGlobalName(Name, NDie, NS->getScope());
1083 addSourceLine(NDie, NS);
1087 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1088 // Construct the context before querying for the existence of the DIE in case
1089 // such construction creates the DIE.
1090 DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1092 if (DIE *MDie = getDIE(M))
1094 DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1096 if (!M->getName().empty()) {
1097 addString(MDie, dwarf::DW_AT_name, M->getName());
1098 addGlobalName(M->getName(), MDie, M->getScope());
1100 if (!M->getConfigurationMacros().empty())
1101 addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1102 M->getConfigurationMacros());
1103 if (!M->getIncludePath().empty())
1104 addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1105 if (!M->getISysRoot().empty())
1106 addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1111 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1112 // Construct the context before querying for the existence of the DIE in case
1113 // such construction creates the DIE (as is the case for member function
1116 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1118 if (DIE *SPDie = getDIE(SP))
1121 if (auto *SPDecl = SP->getDeclaration()) {
1123 // Add subprogram definitions to the CU die directly.
1124 ContextDIE = &getUnitDie();
1125 // Build the decl now to ensure it precedes the definition.
1126 getOrCreateSubprogramDIE(SPDecl);
1130 // DW_TAG_inlined_subroutine may refer to this DIE.
1131 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1133 // Stop here and fill this in later, depending on whether or not this
1134 // subprogram turns out to have inlined instances or not.
1135 if (SP->isDefinition())
1138 applySubprogramAttributes(SP, SPDie);
1142 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1144 DIE *DeclDie = nullptr;
1145 StringRef DeclLinkageName;
1146 if (auto *SPDecl = SP->getDeclaration()) {
1147 DeclDie = getDIE(SPDecl);
1148 assert(DeclDie && "This DIE should've already been constructed when the "
1149 "definition DIE was created in "
1150 "getOrCreateSubprogramDIE");
1151 DeclLinkageName = SPDecl->getLinkageName();
1154 // Add function template parameters.
1155 addTemplateParams(SPDie, SP->getTemplateParams());
1157 // Add the linkage name if we have one and it isn't in the Decl.
1158 StringRef LinkageName = SP->getLinkageName();
1159 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1160 LinkageName == DeclLinkageName) &&
1161 "decl has a linkage name and it is different");
1162 if (DeclLinkageName.empty())
1163 addLinkageName(SPDie, LinkageName);
1168 // Refer to the function declaration where all the other attributes will be
1170 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1174 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1177 if (applySubprogramDefinitionAttributes(SP, SPDie))
1180 // Constructors and operators for anonymous aggregates do not have names.
1181 if (!SP->getName().empty())
1182 addString(SPDie, dwarf::DW_AT_name, SP->getName());
1184 // Skip the rest of the attributes under -gmlt to save space.
1188 addSourceLine(SPDie, SP);
1190 // Add the prototype if we have a prototype and we have a C like
1192 uint16_t Language = getLanguage();
1193 if (SP->isPrototyped() &&
1194 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1195 Language == dwarf::DW_LANG_ObjC))
1196 addFlag(SPDie, dwarf::DW_AT_prototyped);
1198 const DISubroutineType *SPTy = SP->getType();
1199 assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1200 "the type of a subprogram should be a subroutine");
1202 auto Args = SPTy->getTypeArray();
1203 // Add a return type. If this is a type like a C/C++ void type we don't add a
1206 if (auto Ty = resolve(Args[0]))
1209 unsigned VK = SP->getVirtuality();
1211 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1212 DIELoc *Block = getDIELoc();
1213 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1214 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1215 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1216 ContainingTypeMap.insert(
1217 std::make_pair(&SPDie, resolve(SP->getContainingType())));
1220 if (!SP->isDefinition()) {
1221 addFlag(SPDie, dwarf::DW_AT_declaration);
1223 // Add arguments. Do not add arguments for subprogram definition. They will
1224 // be handled while processing variables.
1225 constructSubprogramArguments(SPDie, Args);
1228 if (SP->isArtificial())
1229 addFlag(SPDie, dwarf::DW_AT_artificial);
1231 if (!SP->isLocalToUnit())
1232 addFlag(SPDie, dwarf::DW_AT_external);
1234 if (SP->isOptimized())
1235 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1237 if (unsigned isa = Asm->getISAEncoding())
1238 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1240 if (SP->isLValueReference())
1241 addFlag(SPDie, dwarf::DW_AT_reference);
1243 if (SP->isRValueReference())
1244 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1246 if (SP->isProtected())
1247 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1248 dwarf::DW_ACCESS_protected);
1249 else if (SP->isPrivate())
1250 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1251 dwarf::DW_ACCESS_private);
1252 else if (SP->isPublic())
1253 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1254 dwarf::DW_ACCESS_public);
1256 if (SP->isExplicit())
1257 addFlag(SPDie, dwarf::DW_AT_explicit);
1260 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1262 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1263 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1265 // The LowerBound value defines the lower bounds which is typically zero for
1266 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1267 // Count == -1 then the array is unbounded and we do not emit
1268 // DW_AT_lower_bound and DW_AT_count attributes.
1269 int64_t LowerBound = SR->getLowerBound();
1270 int64_t DefaultLowerBound = getDefaultLowerBound();
1271 int64_t Count = SR->getCount();
1273 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1274 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1277 // FIXME: An unbounded array should reference the expression that defines
1279 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1282 DIE *DwarfUnit::getIndexTyDie() {
1285 // Construct an integer type to use for indexes.
1286 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1287 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1288 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1289 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1290 dwarf::DW_ATE_unsigned);
1294 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1295 if (CTy->isVector())
1296 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1298 // Emit the element type.
1299 addType(Buffer, resolve(CTy->getBaseType()));
1301 // Get an anonymous type for index type.
1302 // FIXME: This type should be passed down from the front end
1303 // as different languages may have different sizes for indexes.
1304 DIE *IdxTy = getIndexTyDie();
1306 // Add subranges to array type.
1307 DINodeArray Elements = CTy->getElements();
1308 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1309 // FIXME: Should this really be such a loose cast?
1310 if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1311 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1312 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1316 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1317 DINodeArray Elements = CTy->getElements();
1319 // Add enumerators to enumeration type.
1320 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1321 auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1323 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1324 StringRef Name = Enum->getName();
1325 addString(Enumerator, dwarf::DW_AT_name, Name);
1326 int64_t Value = Enum->getValue();
1327 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1331 const DIType *DTy = resolve(CTy->getBaseType());
1333 addType(Buffer, DTy);
1334 addFlag(Buffer, dwarf::DW_AT_enum_class);
1338 void DwarfUnit::constructContainingTypeDIEs() {
1339 for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1341 DIE &SPDie = *CI->first;
1342 const DINode *D = CI->second;
1345 DIE *NDie = getDIE(D);
1348 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1352 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1353 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1354 StringRef Name = DT->getName();
1356 addString(MemberDie, dwarf::DW_AT_name, Name);
1358 addType(MemberDie, resolve(DT->getBaseType()));
1360 addSourceLine(MemberDie, DT);
1362 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1364 // For C++, virtual base classes are not at fixed offset. Use following
1365 // expression to extract appropriate offset from vtable.
1366 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1368 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1369 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1370 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1371 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1372 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1373 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1374 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1375 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1377 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1379 uint64_t Size = DT->getSizeInBits();
1380 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1381 uint64_t OffsetInBytes;
1383 if (FieldSize && Size != FieldSize) {
1384 // Handle bitfield, assume bytes are 8 bits.
1385 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1386 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1388 // The DWARF 2 DW_AT_bit_offset is counting the bits between the most
1389 // significant bit of the aligned storage unit containing the bit field to
1390 // the most significan bit of the bit field.
1392 // FIXME: DWARF 4 states that DW_AT_data_bit_offset (which
1393 // counts from the beginning, regardless of endianness) should
1397 // Struct Align Align Align
1399 // +-----------+-----*-----+-----*-----+--
1400 // | ... |b1|b2|b3|b4|
1401 // +-----------+-----*-----+-----*-----+--
1402 // | | |<-- Size ->| |
1403 // |<---- Offset --->| |<--->|
1404 // | | | \_ DW_AT_bit_offset (little endian)
1406 // |<--------->| \_ StartBitOffset = DW_AT_bit_offset (big endian)
1407 // \ = DW_AT_data_bit_offset (biendian)
1409 uint64_t Offset = DT->getOffsetInBits();
1410 uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1411 uint64_t AlignMask = ~(Align - 1);
1412 // The bits from the start of the storage unit to the start of the field.
1413 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1414 // The endian-dependent DWARF 2 offset.
1415 uint64_t DwarfBitOffset = Asm->getDataLayout().isLittleEndian()
1416 ? OffsetToAlignment(Offset + Size, Align)
1419 // The byte offset of the field's aligned storage unit inside the struct.
1420 OffsetInBytes = (Offset - StartBitOffset) / 8;
1421 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, DwarfBitOffset);
1423 // This is not a bitfield.
1424 OffsetInBytes = DT->getOffsetInBits() / 8;
1426 if (DD->getDwarfVersion() <= 2) {
1427 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1428 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1429 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1430 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1432 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1436 if (DT->isProtected())
1437 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1438 dwarf::DW_ACCESS_protected);
1439 else if (DT->isPrivate())
1440 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1441 dwarf::DW_ACCESS_private);
1442 // Otherwise C++ member and base classes are considered public.
1443 else if (DT->isPublic())
1444 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1445 dwarf::DW_ACCESS_public);
1446 if (DT->isVirtual())
1447 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1448 dwarf::DW_VIRTUALITY_virtual);
1450 // Objective-C properties.
1451 if (DINode *PNode = DT->getObjCProperty())
1452 if (DIE *PDie = getDIE(PNode))
1453 MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1454 dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1456 if (DT->isArtificial())
1457 addFlag(MemberDie, dwarf::DW_AT_artificial);
1460 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1464 // Construct the context before querying for the existence of the DIE in case
1465 // such construction creates the DIE.
1466 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1467 assert(dwarf::isType(ContextDIE->getTag()) &&
1468 "Static member should belong to a type.");
1470 if (DIE *StaticMemberDIE = getDIE(DT))
1471 return StaticMemberDIE;
1473 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1475 const DIType *Ty = resolve(DT->getBaseType());
1477 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1478 addType(StaticMemberDIE, Ty);
1479 addSourceLine(StaticMemberDIE, DT);
1480 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1481 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1483 // FIXME: We could omit private if the parent is a class_type, and
1484 // public if the parent is something else.
1485 if (DT->isProtected())
1486 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1487 dwarf::DW_ACCESS_protected);
1488 else if (DT->isPrivate())
1489 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1490 dwarf::DW_ACCESS_private);
1491 else if (DT->isPublic())
1492 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1493 dwarf::DW_ACCESS_public);
1495 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1496 addConstantValue(StaticMemberDIE, CI, Ty);
1497 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1498 addConstantFPValue(StaticMemberDIE, CFP);
1500 return &StaticMemberDIE;
1503 void DwarfUnit::emitHeader(bool UseOffsets) {
1504 // Emit size of content not including length itself
1505 Asm->OutStreamer->AddComment("Length of Unit");
1506 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1508 Asm->OutStreamer->AddComment("DWARF version number");
1509 Asm->EmitInt16(DD->getDwarfVersion());
1510 Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1512 // We share one abbreviations table across all units so it's always at the
1513 // start of the section. Use a relocatable offset where needed to ensure
1514 // linking doesn't invalidate that offset.
1515 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1516 Asm->emitDwarfSymbolReference(TLOF.getDwarfAbbrevSection()->getBeginSymbol(),
1519 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1520 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1523 void DwarfUnit::initSection(MCSection *Section) {
1524 assert(!this->Section);
1525 this->Section = Section;
1528 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1529 DwarfUnit::emitHeader(UseOffsets);
1530 Asm->OutStreamer->AddComment("Type Signature");
1531 Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1532 Asm->OutStreamer->AddComment("Type DIE Offset");
1533 // In a skeleton type unit there is no type DIE so emit a zero offset.
1534 Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1535 sizeof(Ty->getOffset()));
1538 bool DwarfTypeUnit::isDwoUnit() const {
1539 // Since there are no skeleton type units, all type units are dwo type units
1540 // when split DWARF is being used.
1541 return DD->useSplitDwarf();