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 MDCompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
69 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
70 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
71 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
72 UnitTag == dwarf::DW_TAG_type_unit);
73 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
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 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
93 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
97 int64_t DwarfUnit::getDefaultLowerBound() const {
98 switch (getLanguage()) {
102 case dwarf::DW_LANG_C89:
103 case dwarf::DW_LANG_C99:
104 case dwarf::DW_LANG_C:
105 case dwarf::DW_LANG_C_plus_plus:
106 case dwarf::DW_LANG_ObjC:
107 case dwarf::DW_LANG_ObjC_plus_plus:
110 case dwarf::DW_LANG_Fortran77:
111 case dwarf::DW_LANG_Fortran90:
112 case dwarf::DW_LANG_Fortran95:
115 // The languages below have valid values only if the DWARF version >= 4.
116 case dwarf::DW_LANG_Java:
117 case dwarf::DW_LANG_Python:
118 case dwarf::DW_LANG_UPC:
119 case dwarf::DW_LANG_D:
120 if (dwarf::DWARF_VERSION >= 4)
124 case dwarf::DW_LANG_Ada83:
125 case dwarf::DW_LANG_Ada95:
126 case dwarf::DW_LANG_Cobol74:
127 case dwarf::DW_LANG_Cobol85:
128 case dwarf::DW_LANG_Modula2:
129 case dwarf::DW_LANG_Pascal83:
130 case dwarf::DW_LANG_PLI:
131 if (dwarf::DWARF_VERSION >= 4)
135 // The languages below have valid values only if the DWARF version >= 5.
136 case dwarf::DW_LANG_OpenCL:
137 case dwarf::DW_LANG_Go:
138 case dwarf::DW_LANG_Haskell:
139 case dwarf::DW_LANG_C_plus_plus_03:
140 case dwarf::DW_LANG_C_plus_plus_11:
141 case dwarf::DW_LANG_OCaml:
142 case dwarf::DW_LANG_Rust:
143 case dwarf::DW_LANG_C11:
144 case dwarf::DW_LANG_Swift:
145 case dwarf::DW_LANG_Dylan:
146 case dwarf::DW_LANG_C_plus_plus_14:
147 if (dwarf::DWARF_VERSION >= 5)
151 case dwarf::DW_LANG_Modula3:
152 case dwarf::DW_LANG_Julia:
153 case dwarf::DW_LANG_Fortran03:
154 case dwarf::DW_LANG_Fortran08:
155 if (dwarf::DWARF_VERSION >= 5)
163 /// Check whether the DIE for this MDNode can be shared across CUs.
164 static bool isShareableAcrossCUs(const DebugNode *D) {
165 // When the MDNode can be part of the type system, the DIE can be shared
167 // Combining type units and cross-CU DIE sharing is lower value (since
168 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
169 // level already) but may be implementable for some value in projects
170 // building multiple independent libraries with LTO and then linking those
172 return (isa<MDType>(D) ||
173 (isa<MDSubprogram>(D) && !cast<MDSubprogram>(D)->isDefinition())) &&
174 !GenerateDwarfTypeUnits;
177 DIE *DwarfUnit::getDIE(const DebugNode *D) const {
178 if (isShareableAcrossCUs(D))
179 return DU->getDIE(D);
180 return MDNodeToDieMap.lookup(D);
183 void DwarfUnit::insertDIE(const DebugNode *Desc, DIE *D) {
184 if (isShareableAcrossCUs(Desc)) {
185 DU->insertDIE(Desc, D);
188 MDNodeToDieMap.insert(std::make_pair(Desc, D));
191 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
192 if (DD->getDwarfVersion() >= 4)
193 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
195 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
198 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
199 Optional<dwarf::Form> Form, uint64_t Integer) {
201 Form = DIEInteger::BestForm(false, Integer);
202 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
204 Die.addValue(Attribute, *Form, Value);
207 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
208 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
211 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
212 Optional<dwarf::Form> Form, int64_t Integer) {
214 Form = DIEInteger::BestForm(true, Integer);
215 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
216 Die.addValue(Attribute, *Form, Value);
219 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
221 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
224 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
227 return addLocalString(Die, Attribute, String);
229 addIndexedString(Die, Attribute, String);
232 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
234 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
235 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
236 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
237 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
240 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
242 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
243 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
245 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
246 Value = new (DIEValueAllocator) DIELabel(Symb);
248 Value = new (DIEValueAllocator)
249 DIEDelta(Symb, TLOF.getDwarfStrSection()->getBeginSymbol());
250 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
251 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
254 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
255 const MCSymbol *Label) {
256 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
257 Die.addValue(Attribute, Form, Value);
260 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
261 addLabel(Die, (dwarf::Attribute)0, Form, Label);
264 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
266 if (DD->getDwarfVersion() >= 4)
267 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
269 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
272 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
273 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
274 : getCU().getOrCreateSourceID(FileName, DirName);
277 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
278 if (!DD->useSplitDwarf()) {
279 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
280 addLabel(Die, dwarf::DW_FORM_udata, Sym);
282 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
283 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
284 DD->getAddressPool().getIndex(Sym));
288 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
289 const MCSymbol *Hi, const MCSymbol *Lo) {
290 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
291 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
294 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
295 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
298 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
299 // Flag the type unit reference as a declaration so that if it contains
300 // members (implicit special members, static data member definitions, member
301 // declarations for definitions in this CU, etc) consumers don't get confused
302 // and think this is a full definition.
303 addFlag(Die, dwarf::DW_AT_declaration);
305 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
306 new (DIEValueAllocator) DIETypeSignature(Type));
309 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
311 const DIE *DieCU = Die.getUnitOrNull();
312 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
314 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
315 DieCU = &getUnitDie();
317 EntryCU = &getUnitDie();
318 Die.addValue(Attribute,
319 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
323 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DebugNode *N) {
324 assert(Tag != dwarf::DW_TAG_auto_variable &&
325 Tag != dwarf::DW_TAG_arg_variable);
326 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
327 DIE &Die = *Parent.getChildren().back();
333 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
334 Loc->ComputeSize(Asm);
335 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
336 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
339 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
341 Block->ComputeSize(Asm);
342 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
343 Die.addValue(Attribute, Block->BestForm(), Block);
346 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
347 StringRef Directory) {
351 unsigned FileID = getOrCreateSourceID(File, Directory);
352 assert(FileID && "Invalid file id");
353 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
354 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
357 void DwarfUnit::addSourceLine(DIE &Die, const MDLocalVariable *V) {
360 addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
361 V->getScope()->getDirectory());
364 void DwarfUnit::addSourceLine(DIE &Die, const MDGlobalVariable *G) {
367 addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
370 void DwarfUnit::addSourceLine(DIE &Die, const MDSubprogram *SP) {
373 addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
376 void DwarfUnit::addSourceLine(DIE &Die, const MDType *Ty) {
379 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
382 void DwarfUnit::addSourceLine(DIE &Die, const MDObjCProperty *Ty) {
385 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
388 void DwarfUnit::addSourceLine(DIE &Die, const MDNamespace *NS) {
389 addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
392 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
393 unsigned SizeInBits, unsigned OffsetInBits) {
394 DIEDwarfExpression Expr(*Asm, *this, TheDie);
395 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
399 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
401 DIEDwarfExpression Expr(*Asm, *this, TheDie);
402 return Expr.AddMachineRegIndirect(Reg, Offset);
405 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
406 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
407 gives the variable VarName either the struct, or a pointer to the struct, as
408 its type. This is necessary for various behind-the-scenes things the
409 compiler needs to do with by-reference variables in Blocks.
411 However, as far as the original *programmer* is concerned, the variable
412 should still have type 'SomeType', as originally declared.
414 The function getBlockByrefType dives into the __Block_byref_x_VarName
415 struct to find the original type of the variable, which is then assigned to
416 the variable's Debug Information Entry as its real type. So far, so good.
417 However now the debugger will expect the variable VarName to have the type
418 SomeType. So we need the location attribute for the variable to be an
419 expression that explains to the debugger how to navigate through the
420 pointers and struct to find the actual variable of type SomeType.
422 The following function does just that. We start by getting
423 the "normal" location for the variable. This will be the location
424 of either the struct __Block_byref_x_VarName or the pointer to the
425 struct __Block_byref_x_VarName.
427 The struct will look something like:
429 struct __Block_byref_x_VarName {
431 struct __Block_byref_x_VarName *forwarding;
432 ... <various other fields>
434 ... <maybe more fields>
437 If we are given the struct directly (as our starting point) we
438 need to tell the debugger to:
440 1). Add the offset of the forwarding field.
442 2). Follow that pointer to get the real __Block_byref_x_VarName
443 struct to use (the real one may have been copied onto the heap).
445 3). Add the offset for the field VarName, to find the actual variable.
447 If we started with a pointer to the struct, then we need to
448 dereference that pointer first, before the other steps.
449 Translating this into DWARF ops, we will need to append the following
450 to the current location description for the variable:
452 DW_OP_deref -- optional, if we start with a pointer
453 DW_OP_plus_uconst <forward_fld_offset>
455 DW_OP_plus_uconst <varName_fld_offset>
457 That is what this function does. */
459 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
460 dwarf::Attribute Attribute,
461 const MachineLocation &Location) {
462 const MDType *Ty = DV.getType();
463 const MDType *TmpTy = Ty;
464 uint16_t Tag = Ty->getTag();
465 bool isPointer = false;
467 StringRef varName = DV.getName();
469 if (Tag == dwarf::DW_TAG_pointer_type) {
470 auto *DTy = cast<MDDerivedType>(Ty);
471 TmpTy = resolve(DTy->getBaseType());
475 // Find the __forwarding field and the variable field in the __Block_byref
477 DIArray Fields = cast<MDCompositeTypeBase>(TmpTy)->getElements();
478 const MDDerivedType *varField = nullptr;
479 const MDDerivedType *forwardingField = nullptr;
481 for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
482 auto *DT = cast<MDDerivedType>(Fields[i]);
483 StringRef fieldName = DT->getName();
484 if (fieldName == "__forwarding")
485 forwardingField = DT;
486 else if (fieldName == varName)
490 // Get the offsets for the forwarding field and the variable field.
491 unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
492 unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
494 // Decode the original location, and use that as the start of the byref
495 // variable's location.
496 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
499 if (Location.isReg())
500 validReg = addRegisterOpPiece(*Loc, Location.getReg());
502 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
507 // If we started with a pointer to the __Block_byref... struct, then
508 // the first thing we need to do is dereference the pointer (DW_OP_deref).
510 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
512 // Next add the offset for the '__forwarding' field:
513 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
514 // adding the offset if it's 0.
515 if (forwardingFieldOffset > 0) {
516 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
517 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
520 // Now dereference the __forwarding field to get to the real __Block_byref
521 // struct: DW_OP_deref.
522 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
524 // Now that we've got the real __Block_byref... struct, add the offset
525 // for the variable's field to get to the location of the actual variable:
526 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
527 if (varFieldOffset > 0) {
528 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
529 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
532 // Now attach the location information to the DIE.
533 addBlock(Die, Attribute, Loc);
536 /// Return true if type encoding is unsigned.
537 static bool isUnsignedDIType(DwarfDebug *DD, const MDType *Ty) {
538 if (auto *DTy = dyn_cast<MDDerivedTypeBase>(Ty)) {
539 dwarf::Tag T = (dwarf::Tag)Ty->getTag();
540 // Encode pointer constants as unsigned bytes. This is used at least for
541 // null pointer constant emission.
542 // (Pieces of) aggregate types that get hacked apart by SROA may also be
543 // represented by a constant. Encode them as unsigned bytes.
544 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
545 // here, but accept them for now due to a bug in SROA producing bogus
547 if (T == dwarf::DW_TAG_array_type ||
548 T == dwarf::DW_TAG_class_type ||
549 T == dwarf::DW_TAG_pointer_type ||
550 T == dwarf::DW_TAG_ptr_to_member_type ||
551 T == dwarf::DW_TAG_reference_type ||
552 T == dwarf::DW_TAG_rvalue_reference_type ||
553 T == dwarf::DW_TAG_structure_type ||
554 T == dwarf::DW_TAG_union_type)
556 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
557 T == dwarf::DW_TAG_volatile_type ||
558 T == dwarf::DW_TAG_restrict_type ||
559 T == dwarf::DW_TAG_enumeration_type);
560 if (MDTypeRef Deriv = DTy->getBaseType())
561 return isUnsignedDIType(DD, DD->resolve(Deriv));
562 // FIXME: Enums without a fixed underlying type have unknown signedness
563 // here, leading to incorrectly emitted constants.
564 assert(DTy->getTag() == dwarf::DW_TAG_enumeration_type);
568 auto *BTy = cast<MDBasicType>(Ty);
569 unsigned Encoding = BTy->getEncoding();
570 assert((Encoding == dwarf::DW_ATE_unsigned ||
571 Encoding == dwarf::DW_ATE_unsigned_char ||
572 Encoding == dwarf::DW_ATE_signed ||
573 Encoding == dwarf::DW_ATE_signed_char ||
574 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
575 Encoding == dwarf::DW_ATE_boolean ||
576 (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
577 Ty->getName() == "decltype(nullptr)")) &&
578 "Unsupported encoding");
579 return Encoding == dwarf::DW_ATE_unsigned ||
580 Encoding == dwarf::DW_ATE_unsigned_char ||
581 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
582 Ty->getTag() == dwarf::DW_TAG_unspecified_type;
585 /// If this type is derived from a base type then return base type size.
586 static uint64_t getBaseTypeSize(DwarfDebug *DD, const MDDerivedType *Ty) {
587 unsigned Tag = Ty->getTag();
589 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
590 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
591 Tag != dwarf::DW_TAG_restrict_type)
592 return Ty->getSizeInBits();
594 auto *BaseType = DD->resolve(Ty->getBaseType());
596 assert(BaseType && "Unexpected invalid base type");
598 // If this is a derived type, go ahead and get the base type, unless it's a
599 // reference then it's just the size of the field. Pointer types have no need
600 // of this since they're a different type of qualification on the type.
601 if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
602 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
603 return Ty->getSizeInBits();
605 if (auto *DT = dyn_cast<MDDerivedType>(BaseType))
606 return getBaseTypeSize(DD, DT);
608 return BaseType->getSizeInBits();
611 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
612 assert(MO.isFPImm() && "Invalid machine operand!");
613 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
614 APFloat FPImm = MO.getFPImm()->getValueAPF();
616 // Get the raw data form of the floating point.
617 const APInt FltVal = FPImm.bitcastToAPInt();
618 const char *FltPtr = (const char *)FltVal.getRawData();
620 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
621 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
622 int Incr = (LittleEndian ? 1 : -1);
623 int Start = (LittleEndian ? 0 : NumBytes - 1);
624 int Stop = (LittleEndian ? NumBytes : -1);
626 // Output the constant to DWARF one byte at a time.
627 for (; Start != Stop; Start += Incr)
628 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
630 addBlock(Die, dwarf::DW_AT_const_value, Block);
633 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
634 // Pass this down to addConstantValue as an unsigned bag of bits.
635 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
638 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
640 addConstantValue(Die, CI->getValue(), Ty);
643 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
645 assert(MO.isImm() && "Invalid machine operand!");
647 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
650 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
651 // FIXME: This is a bit conservative/simple - it emits negative values always
652 // sign extended to 64 bits rather than minimizing the number of bytes.
653 addUInt(Die, dwarf::DW_AT_const_value,
654 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
657 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const MDType *Ty) {
658 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
661 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
662 unsigned CIBitWidth = Val.getBitWidth();
663 if (CIBitWidth <= 64) {
664 addConstantValue(Die, Unsigned,
665 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
669 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
671 // Get the raw data form of the large APInt.
672 const uint64_t *Ptr64 = Val.getRawData();
674 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
675 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
677 // Output the constant to DWARF one byte at a time.
678 for (int i = 0; i < NumBytes; i++) {
681 c = Ptr64[i / 8] >> (8 * (i & 7));
683 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
684 addUInt(*Block, dwarf::DW_FORM_data1, c);
687 addBlock(Die, dwarf::DW_AT_const_value, Block);
690 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
691 if (!LinkageName.empty())
693 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
694 : dwarf::DW_AT_MIPS_linkage_name,
695 GlobalValue::getRealLinkageName(LinkageName));
698 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
699 // Add template parameters.
700 for (const auto *Element : TParams) {
701 if (auto *TTP = dyn_cast<MDTemplateTypeParameter>(Element))
702 constructTemplateTypeParameterDIE(Buffer, TTP);
703 else if (auto *TVP = dyn_cast<MDTemplateValueParameter>(Element))
704 constructTemplateValueParameterDIE(Buffer, TVP);
708 DIE *DwarfUnit::getOrCreateContextDIE(const MDScope *Context) {
709 if (!Context || isa<MDFile>(Context))
710 return &getUnitDie();
711 if (auto *T = dyn_cast<MDType>(Context))
712 return getOrCreateTypeDIE(T);
713 if (auto *NS = dyn_cast<MDNamespace>(Context))
714 return getOrCreateNameSpace(NS);
715 if (auto *SP = dyn_cast<MDSubprogram>(Context))
716 return getOrCreateSubprogramDIE(SP);
717 return getDIE(Context);
720 DIE *DwarfUnit::createTypeDIE(const MDCompositeType *Ty) {
721 auto *Context = resolve(Ty->getScope());
722 DIE *ContextDIE = getOrCreateContextDIE(Context);
724 if (DIE *TyDIE = getDIE(Ty))
728 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
730 constructTypeDIE(TyDIE, cast<MDCompositeType>(Ty));
732 updateAcceleratorTables(Context, Ty, TyDIE);
736 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
740 auto *Ty = cast<MDType>(TyNode);
741 assert(Ty == resolve(Ty->getRef()) &&
742 "type was not uniqued, possible ODR violation.");
744 // DW_TAG_restrict_type is not supported in DWARF2
745 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
746 return getOrCreateTypeDIE(
747 resolve(cast<MDDerivedType>(Ty)->getBaseType()));
749 // Construct the context before querying for the existence of the DIE in case
750 // such construction creates the DIE.
751 auto *Context = resolve(Ty->getScope());
752 DIE *ContextDIE = getOrCreateContextDIE(Context);
755 if (DIE *TyDIE = getDIE(Ty))
759 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
761 updateAcceleratorTables(Context, Ty, TyDIE);
763 if (auto *BT = dyn_cast<MDBasicType>(Ty))
764 constructTypeDIE(TyDIE, BT);
765 else if (auto *STy = dyn_cast<MDSubroutineType>(Ty))
766 constructTypeDIE(TyDIE, STy);
767 else if (auto *CTy = dyn_cast<MDCompositeType>(Ty)) {
768 if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
769 if (MDString *TypeId = CTy->getRawIdentifier()) {
770 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
771 // Skip updating the accelerator tables since this is not the full type.
774 constructTypeDIE(TyDIE, CTy);
776 constructTypeDIE(TyDIE, cast<MDDerivedType>(Ty));
782 void DwarfUnit::updateAcceleratorTables(const MDScope *Context,
783 const MDType *Ty, const DIE &TyDIE) {
784 if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
785 bool IsImplementation = 0;
786 if (auto *CT = dyn_cast<MDCompositeTypeBase>(Ty)) {
787 // A runtime language of 0 actually means C/C++ and that any
788 // non-negative value is some version of Objective-C/C++.
789 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
791 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
792 DD->addAccelType(Ty->getName(), TyDIE, Flags);
794 if (!Context || isa<MDCompileUnit>(Context) || isa<MDFile>(Context) ||
795 isa<MDNamespace>(Context))
796 addGlobalType(Ty, TyDIE, Context);
800 void DwarfUnit::addType(DIE &Entity, const MDType *Ty,
801 dwarf::Attribute Attribute) {
802 assert(Ty && "Trying to add a type that doesn't exist?");
804 // Check for pre-existence.
805 DIEEntry *Entry = getDIEEntry(Ty);
806 // If it exists then use the existing value.
808 addDIEEntry(Entity, Attribute, Entry);
813 DIE *Buffer = getOrCreateTypeDIE(Ty);
816 Entry = createDIEEntry(*Buffer);
817 insertDIEEntry(Ty, Entry);
818 addDIEEntry(Entity, Attribute, Entry);
821 std::string DwarfUnit::getParentContextString(const MDScope *Context) const {
825 // FIXME: Decide whether to implement this for non-C++ languages.
826 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
830 SmallVector<const MDScope *, 1> Parents;
831 while (!isa<MDCompileUnit>(Context)) {
832 Parents.push_back(Context);
833 if (Context->getScope())
834 Context = resolve(Context->getScope());
836 // Structure, etc types will have a NULL context if they're at the top
841 // Reverse iterate over our list to go from the outermost construct to the
843 for (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
844 const MDScope *Ctx = *I;
845 StringRef Name = Ctx->getName();
846 if (Name.empty() && isa<MDNamespace>(Ctx))
847 Name = "(anonymous namespace)";
856 void DwarfUnit::constructTypeDIE(DIE &Buffer, const MDBasicType *BTy) {
857 // Get core information.
858 StringRef Name = BTy->getName();
859 // Add name if not anonymous or intermediate type.
861 addString(Buffer, dwarf::DW_AT_name, Name);
863 // An unspecified type only has a name attribute.
864 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
867 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
870 uint64_t Size = BTy->getSizeInBits() >> 3;
871 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
874 void DwarfUnit::constructTypeDIE(DIE &Buffer, const MDDerivedType *DTy) {
875 // Get core information.
876 StringRef Name = DTy->getName();
877 uint64_t Size = DTy->getSizeInBits() >> 3;
878 uint16_t Tag = Buffer.getTag();
880 // Map to main type, void will not have a type.
881 const MDType *FromTy = resolve(DTy->getBaseType());
883 addType(Buffer, FromTy);
885 // Add name if not anonymous or intermediate type.
887 addString(Buffer, dwarf::DW_AT_name, Name);
889 // Add size if non-zero (derived types might be zero-sized.)
890 if (Size && Tag != dwarf::DW_TAG_pointer_type
891 && Tag != dwarf::DW_TAG_ptr_to_member_type)
892 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
894 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
896 Buffer, dwarf::DW_AT_containing_type,
897 *getOrCreateTypeDIE(resolve(cast<MDDerivedType>(DTy)->getClassType())));
898 // Add source line info if available and TyDesc is not a forward declaration.
899 if (!DTy->isForwardDecl())
900 addSourceLine(Buffer, DTy);
903 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
904 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
905 const MDType *Ty = resolve(Args[i]);
907 assert(i == N-1 && "Unspecified parameter must be the last argument");
908 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
910 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
912 if (Ty->isArtificial())
913 addFlag(Arg, dwarf::DW_AT_artificial);
918 void DwarfUnit::constructTypeDIE(DIE &Buffer, const MDSubroutineType *CTy) {
919 // Add return type. A void return won't have a type.
920 auto Elements = cast<MDSubroutineType>(CTy)->getTypeArray();
922 if (auto RTy = resolve(Elements[0]))
923 addType(Buffer, RTy);
925 bool isPrototyped = true;
926 if (Elements.size() == 2 && !Elements[1])
927 isPrototyped = false;
929 constructSubprogramArguments(Buffer, Elements);
931 // Add prototype flag if we're dealing with a C language and the function has
933 uint16_t Language = getLanguage();
935 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
936 Language == dwarf::DW_LANG_ObjC))
937 addFlag(Buffer, dwarf::DW_AT_prototyped);
939 if (CTy->isLValueReference())
940 addFlag(Buffer, dwarf::DW_AT_reference);
942 if (CTy->isRValueReference())
943 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
946 void DwarfUnit::constructTypeDIE(DIE &Buffer, const MDCompositeType *CTy) {
947 // Add name if not anonymous or intermediate type.
948 StringRef Name = CTy->getName();
950 uint64_t Size = CTy->getSizeInBits() >> 3;
951 uint16_t Tag = Buffer.getTag();
954 case dwarf::DW_TAG_array_type:
955 constructArrayTypeDIE(Buffer, CTy);
957 case dwarf::DW_TAG_enumeration_type:
958 constructEnumTypeDIE(Buffer, CTy);
960 case dwarf::DW_TAG_structure_type:
961 case dwarf::DW_TAG_union_type:
962 case dwarf::DW_TAG_class_type: {
963 // Add elements to structure type.
964 DIArray Elements = CTy->getElements();
965 for (const auto *Element : Elements) {
968 if (auto *SP = dyn_cast<MDSubprogram>(Element))
969 getOrCreateSubprogramDIE(SP);
970 else if (auto *DDTy = dyn_cast<MDDerivedType>(Element)) {
971 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
972 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
973 addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
974 } else if (DDTy->isStaticMember()) {
975 getOrCreateStaticMemberDIE(DDTy);
977 constructMemberDIE(Buffer, DDTy);
979 } else if (auto *Property = dyn_cast<MDObjCProperty>(Element)) {
980 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
981 StringRef PropertyName = Property->getName();
982 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
983 if (Property->getType())
984 addType(ElemDie, Property->getType());
985 addSourceLine(ElemDie, Property);
986 StringRef GetterName = Property->getGetterName();
987 if (!GetterName.empty())
988 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
989 StringRef SetterName = Property->getSetterName();
990 if (!SetterName.empty())
991 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
992 if (unsigned PropertyAttributes = Property->getAttributes())
993 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
996 DIEEntry *Entry = getDIEEntry(Element);
998 Entry = createDIEEntry(ElemDie);
999 insertDIEEntry(Element, Entry);
1004 if (CTy->isAppleBlockExtension())
1005 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1007 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1008 // inside C++ composite types to point to the base class with the vtable.
1009 if (auto *ContainingType =
1010 dyn_cast_or_null<MDCompositeType>(resolve(CTy->getVTableHolder())))
1011 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1012 *getOrCreateTypeDIE(ContainingType));
1014 if (CTy->isObjcClassComplete())
1015 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1017 // Add template parameters to a class, structure or union types.
1018 // FIXME: The support isn't in the metadata for this yet.
1019 if (Tag == dwarf::DW_TAG_class_type ||
1020 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1021 addTemplateParams(Buffer, CTy->getTemplateParams());
1029 // Add name if not anonymous or intermediate type.
1031 addString(Buffer, dwarf::DW_AT_name, Name);
1033 if (Tag == dwarf::DW_TAG_enumeration_type ||
1034 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1035 Tag == dwarf::DW_TAG_union_type) {
1036 // Add size if non-zero (derived types might be zero-sized.)
1037 // TODO: Do we care about size for enum forward declarations?
1039 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1040 else if (!CTy->isForwardDecl())
1041 // Add zero size if it is not a forward declaration.
1042 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1044 // If we're a forward decl, say so.
1045 if (CTy->isForwardDecl())
1046 addFlag(Buffer, dwarf::DW_AT_declaration);
1048 // Add source line info if available.
1049 if (!CTy->isForwardDecl())
1050 addSourceLine(Buffer, CTy);
1052 // No harm in adding the runtime language to the declaration.
1053 unsigned RLang = CTy->getRuntimeLang();
1055 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1060 void DwarfUnit::constructTemplateTypeParameterDIE(
1061 DIE &Buffer, const MDTemplateTypeParameter *TP) {
1063 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1064 // Add the type if it exists, it could be void and therefore no type.
1066 addType(ParamDIE, resolve(TP->getType()));
1067 if (!TP->getName().empty())
1068 addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1071 void DwarfUnit::constructTemplateValueParameterDIE(
1072 DIE &Buffer, const MDTemplateValueParameter *VP) {
1073 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1075 // Add the type if there is one, template template and template parameter
1076 // packs will not have a type.
1077 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1078 addType(ParamDIE, resolve(VP->getType()));
1079 if (!VP->getName().empty())
1080 addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1081 if (Metadata *Val = VP->getValue()) {
1082 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1083 addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1084 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1085 // For declaration non-type template parameters (such as global values and
1087 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1088 addOpAddress(*Loc, Asm->getSymbol(GV));
1089 // Emit DW_OP_stack_value to use the address as the immediate value of the
1090 // parameter, rather than a pointer to it.
1091 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1092 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1093 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1094 assert(isa<MDString>(Val));
1095 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1096 cast<MDString>(Val)->getString());
1097 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1098 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1103 DIE *DwarfUnit::getOrCreateNameSpace(const MDNamespace *NS) {
1104 // Construct the context before querying for the existence of the DIE in case
1105 // such construction creates the DIE.
1106 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1108 if (DIE *NDie = getDIE(NS))
1110 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1112 StringRef Name = NS->getName();
1114 addString(NDie, dwarf::DW_AT_name, NS->getName());
1116 Name = "(anonymous namespace)";
1117 DD->addAccelNamespace(Name, NDie);
1118 addGlobalName(Name, NDie, NS->getScope());
1119 addSourceLine(NDie, NS);
1123 DIE *DwarfUnit::getOrCreateSubprogramDIE(const MDSubprogram *SP, bool Minimal) {
1124 // Construct the context before querying for the existence of the DIE in case
1125 // such construction creates the DIE (as is the case for member function
1128 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1130 if (DIE *SPDie = getDIE(SP))
1133 if (auto *SPDecl = SP->getDeclaration()) {
1135 // Add subprogram definitions to the CU die directly.
1136 ContextDIE = &getUnitDie();
1137 // Build the decl now to ensure it precedes the definition.
1138 getOrCreateSubprogramDIE(SPDecl);
1142 // DW_TAG_inlined_subroutine may refer to this DIE.
1143 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1145 // Stop here and fill this in later, depending on whether or not this
1146 // subprogram turns out to have inlined instances or not.
1147 if (SP->isDefinition())
1150 applySubprogramAttributes(SP, SPDie);
1154 bool DwarfUnit::applySubprogramDefinitionAttributes(const MDSubprogram *SP,
1156 DIE *DeclDie = nullptr;
1157 StringRef DeclLinkageName;
1158 if (auto *SPDecl = SP->getDeclaration()) {
1159 DeclDie = getDIE(SPDecl);
1160 assert(DeclDie && "This DIE should've already been constructed when the "
1161 "definition DIE was created in "
1162 "getOrCreateSubprogramDIE");
1163 DeclLinkageName = SPDecl->getLinkageName();
1166 // Add function template parameters.
1167 addTemplateParams(SPDie, SP->getTemplateParams());
1169 // Add the linkage name if we have one and it isn't in the Decl.
1170 StringRef LinkageName = SP->getLinkageName();
1171 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1172 LinkageName == DeclLinkageName) &&
1173 "decl has a linkage name and it is different");
1174 if (DeclLinkageName.empty())
1175 addLinkageName(SPDie, LinkageName);
1180 // Refer to the function declaration where all the other attributes will be
1182 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1186 void DwarfUnit::applySubprogramAttributes(const MDSubprogram *SP, DIE &SPDie,
1189 if (applySubprogramDefinitionAttributes(SP, SPDie))
1192 // Constructors and operators for anonymous aggregates do not have names.
1193 if (!SP->getName().empty())
1194 addString(SPDie, dwarf::DW_AT_name, SP->getName());
1196 // Skip the rest of the attributes under -gmlt to save space.
1200 addSourceLine(SPDie, SP);
1202 // Add the prototype if we have a prototype and we have a C like
1204 uint16_t Language = getLanguage();
1205 if (SP->isPrototyped() &&
1206 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1207 Language == dwarf::DW_LANG_ObjC))
1208 addFlag(SPDie, dwarf::DW_AT_prototyped);
1210 const MDSubroutineType *SPTy = SP->getType();
1211 assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1212 "the type of a subprogram should be a subroutine");
1214 auto Args = SPTy->getTypeArray();
1215 // Add a return type. If this is a type like a C/C++ void type we don't add a
1218 if (auto Ty = resolve(Args[0]))
1221 unsigned VK = SP->getVirtuality();
1223 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1224 DIELoc *Block = getDIELoc();
1225 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1226 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1227 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1228 ContainingTypeMap.insert(
1229 std::make_pair(&SPDie, resolve(SP->getContainingType())));
1232 if (!SP->isDefinition()) {
1233 addFlag(SPDie, dwarf::DW_AT_declaration);
1235 // Add arguments. Do not add arguments for subprogram definition. They will
1236 // be handled while processing variables.
1237 constructSubprogramArguments(SPDie, Args);
1240 if (SP->isArtificial())
1241 addFlag(SPDie, dwarf::DW_AT_artificial);
1243 if (!SP->isLocalToUnit())
1244 addFlag(SPDie, dwarf::DW_AT_external);
1246 if (SP->isOptimized())
1247 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1249 if (unsigned isa = Asm->getISAEncoding())
1250 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1252 if (SP->isLValueReference())
1253 addFlag(SPDie, dwarf::DW_AT_reference);
1255 if (SP->isRValueReference())
1256 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1258 if (SP->isProtected())
1259 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1260 dwarf::DW_ACCESS_protected);
1261 else if (SP->isPrivate())
1262 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1263 dwarf::DW_ACCESS_private);
1264 else if (SP->isPublic())
1265 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1266 dwarf::DW_ACCESS_public);
1268 if (SP->isExplicit())
1269 addFlag(SPDie, dwarf::DW_AT_explicit);
1272 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const MDSubrange *SR,
1274 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1275 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1277 // The LowerBound value defines the lower bounds which is typically zero for
1278 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1279 // Count == -1 then the array is unbounded and we do not emit
1280 // DW_AT_lower_bound and DW_AT_count attributes.
1281 int64_t LowerBound = SR->getLowerBound();
1282 int64_t DefaultLowerBound = getDefaultLowerBound();
1283 int64_t Count = SR->getCount();
1285 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1286 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1289 // FIXME: An unbounded array should reference the expression that defines
1291 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1294 DIE *DwarfUnit::getIndexTyDie() {
1297 // Construct an integer type to use for indexes.
1298 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1299 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1300 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1301 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1302 dwarf::DW_ATE_unsigned);
1306 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const MDCompositeType *CTy) {
1307 if (CTy->isVector())
1308 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1310 // Emit the element type.
1311 addType(Buffer, resolve(CTy->getBaseType()));
1313 // Get an anonymous type for index type.
1314 // FIXME: This type should be passed down from the front end
1315 // as different languages may have different sizes for indexes.
1316 DIE *IdxTy = getIndexTyDie();
1318 // Add subranges to array type.
1319 DIArray Elements = CTy->getElements();
1320 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1321 // FIXME: Should this really be such a loose cast?
1322 if (auto *Element = dyn_cast_or_null<DebugNode>(Elements[i]))
1323 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1324 constructSubrangeDIE(Buffer, cast<MDSubrange>(Element), IdxTy);
1328 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const MDCompositeType *CTy) {
1329 DIArray Elements = CTy->getElements();
1331 // Add enumerators to enumeration type.
1332 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1333 auto *Enum = dyn_cast_or_null<MDEnumerator>(Elements[i]);
1335 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1336 StringRef Name = Enum->getName();
1337 addString(Enumerator, dwarf::DW_AT_name, Name);
1338 int64_t Value = Enum->getValue();
1339 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1343 const MDType *DTy = resolve(CTy->getBaseType());
1345 addType(Buffer, DTy);
1346 addFlag(Buffer, dwarf::DW_AT_enum_class);
1350 void DwarfUnit::constructContainingTypeDIEs() {
1351 for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1353 DIE &SPDie = *CI->first;
1354 const DebugNode *D = CI->second;
1357 DIE *NDie = getDIE(D);
1360 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1364 void DwarfUnit::constructMemberDIE(DIE &Buffer, const MDDerivedType *DT) {
1365 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1366 StringRef Name = DT->getName();
1368 addString(MemberDie, dwarf::DW_AT_name, Name);
1370 addType(MemberDie, resolve(DT->getBaseType()));
1372 addSourceLine(MemberDie, DT);
1374 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1376 // For C++, virtual base classes are not at fixed offset. Use following
1377 // expression to extract appropriate offset from vtable.
1378 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1380 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1381 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1382 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1383 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1384 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1385 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1386 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1387 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1389 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1391 uint64_t Size = DT->getSizeInBits();
1392 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1393 uint64_t OffsetInBytes;
1395 if (FieldSize && Size != FieldSize) {
1396 // Handle bitfield, assume bytes are 8 bits.
1397 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1398 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1400 uint64_t Offset = DT->getOffsetInBits();
1401 uint64_t AlignMask = ~(DT->getAlignInBits() - 1);
1402 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1403 uint64_t FieldOffset = (HiMark - FieldSize);
1404 Offset -= FieldOffset;
1406 // Maybe we need to work from the other end.
1407 if (Asm->getDataLayout().isLittleEndian())
1408 Offset = FieldSize - (Offset + Size);
1409 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1411 // Here DW_AT_data_member_location points to the anonymous
1412 // field that includes this bit field.
1413 OffsetInBytes = FieldOffset >> 3;
1415 // This is not a bitfield.
1416 OffsetInBytes = DT->getOffsetInBits() >> 3;
1418 if (DD->getDwarfVersion() <= 2) {
1419 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1420 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1421 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1422 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1424 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1428 if (DT->isProtected())
1429 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1430 dwarf::DW_ACCESS_protected);
1431 else if (DT->isPrivate())
1432 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1433 dwarf::DW_ACCESS_private);
1434 // Otherwise C++ member and base classes are considered public.
1435 else if (DT->isPublic())
1436 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1437 dwarf::DW_ACCESS_public);
1438 if (DT->isVirtual())
1439 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1440 dwarf::DW_VIRTUALITY_virtual);
1442 // Objective-C properties.
1443 if (MDNode *PNode = DT->getObjCProperty())
1444 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1445 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1448 if (DT->isArtificial())
1449 addFlag(MemberDie, dwarf::DW_AT_artificial);
1452 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const MDDerivedType *DT) {
1456 // Construct the context before querying for the existence of the DIE in case
1457 // such construction creates the DIE.
1458 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1459 assert(dwarf::isType(ContextDIE->getTag()) &&
1460 "Static member should belong to a type.");
1462 if (DIE *StaticMemberDIE = getDIE(DT))
1463 return StaticMemberDIE;
1465 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1467 const MDType *Ty = resolve(DT->getBaseType());
1469 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1470 addType(StaticMemberDIE, Ty);
1471 addSourceLine(StaticMemberDIE, DT);
1472 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1473 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1475 // FIXME: We could omit private if the parent is a class_type, and
1476 // public if the parent is something else.
1477 if (DT->isProtected())
1478 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1479 dwarf::DW_ACCESS_protected);
1480 else if (DT->isPrivate())
1481 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1482 dwarf::DW_ACCESS_private);
1483 else if (DT->isPublic())
1484 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1485 dwarf::DW_ACCESS_public);
1487 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1488 addConstantValue(StaticMemberDIE, CI, Ty);
1489 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1490 addConstantFPValue(StaticMemberDIE, CFP);
1492 return &StaticMemberDIE;
1495 void DwarfUnit::emitHeader(bool UseOffsets) {
1496 // Emit size of content not including length itself
1497 Asm->OutStreamer.AddComment("Length of Unit");
1498 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1500 Asm->OutStreamer.AddComment("DWARF version number");
1501 Asm->EmitInt16(DD->getDwarfVersion());
1502 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1504 // We share one abbreviations table across all units so it's always at the
1505 // start of the section. Use a relocatable offset where needed to ensure
1506 // linking doesn't invalidate that offset.
1507 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1509 Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1513 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1514 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1517 void DwarfUnit::initSection(const MCSection *Section) {
1518 assert(!this->Section);
1519 this->Section = Section;
1522 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1523 DwarfUnit::emitHeader(UseOffsets);
1524 Asm->OutStreamer.AddComment("Type Signature");
1525 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1526 Asm->OutStreamer.AddComment("Type DIE Offset");
1527 // In a skeleton type unit there is no type DIE so emit a zero offset.
1528 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1529 sizeof(Ty->getOffset()));
1532 bool DwarfTypeUnit::isDwoUnit() const {
1533 // Since there are no skeleton type units, all type units are dwo type units
1534 // when split DWARF is being used.
1535 return DD->useSplitDwarf();