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), 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);
75 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
76 DwarfDebug *DW, DwarfFile *DWU,
77 MCDwarfDwoLineTable *SplitLineTable)
78 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
79 CU(CU), SplitLineTable(SplitLineTable) {
81 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
84 DwarfUnit::~DwarfUnit() {
85 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
86 DIEBlocks[j]->~DIEBlock();
87 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
88 DIELocs[j]->~DIELoc();
91 int64_t DwarfUnit::getDefaultLowerBound() const {
92 switch (getLanguage()) {
96 case dwarf::DW_LANG_C89:
97 case dwarf::DW_LANG_C99:
98 case dwarf::DW_LANG_C:
99 case dwarf::DW_LANG_C_plus_plus:
100 case dwarf::DW_LANG_ObjC:
101 case dwarf::DW_LANG_ObjC_plus_plus:
104 case dwarf::DW_LANG_Fortran77:
105 case dwarf::DW_LANG_Fortran90:
106 case dwarf::DW_LANG_Fortran95:
109 // The languages below have valid values only if the DWARF version >= 4.
110 case dwarf::DW_LANG_Java:
111 case dwarf::DW_LANG_Python:
112 case dwarf::DW_LANG_UPC:
113 case dwarf::DW_LANG_D:
114 if (dwarf::DWARF_VERSION >= 4)
118 case dwarf::DW_LANG_Ada83:
119 case dwarf::DW_LANG_Ada95:
120 case dwarf::DW_LANG_Cobol74:
121 case dwarf::DW_LANG_Cobol85:
122 case dwarf::DW_LANG_Modula2:
123 case dwarf::DW_LANG_Pascal83:
124 case dwarf::DW_LANG_PLI:
125 if (dwarf::DWARF_VERSION >= 4)
129 // The languages below have valid values only if the DWARF version >= 5.
130 case dwarf::DW_LANG_OpenCL:
131 case dwarf::DW_LANG_Go:
132 case dwarf::DW_LANG_Haskell:
133 case dwarf::DW_LANG_C_plus_plus_03:
134 case dwarf::DW_LANG_C_plus_plus_11:
135 case dwarf::DW_LANG_OCaml:
136 case dwarf::DW_LANG_Rust:
137 case dwarf::DW_LANG_C11:
138 case dwarf::DW_LANG_Swift:
139 case dwarf::DW_LANG_Dylan:
140 case dwarf::DW_LANG_C_plus_plus_14:
141 if (dwarf::DWARF_VERSION >= 5)
145 case dwarf::DW_LANG_Modula3:
146 case dwarf::DW_LANG_Julia:
147 case dwarf::DW_LANG_Fortran03:
148 case dwarf::DW_LANG_Fortran08:
149 if (dwarf::DWARF_VERSION >= 5)
157 /// Check whether the DIE for this MDNode can be shared across CUs.
158 static bool isShareableAcrossCUs(const DINode *D) {
159 // When the MDNode can be part of the type system, the DIE can be shared
161 // Combining type units and cross-CU DIE sharing is lower value (since
162 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
163 // level already) but may be implementable for some value in projects
164 // building multiple independent libraries with LTO and then linking those
166 return (isa<DIType>(D) ||
167 (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
168 !GenerateDwarfTypeUnits;
171 DIE *DwarfUnit::getDIE(const DINode *D) const {
172 if (isShareableAcrossCUs(D))
173 return DU->getDIE(D);
174 return MDNodeToDieMap.lookup(D);
177 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
178 if (isShareableAcrossCUs(Desc)) {
179 DU->insertDIE(Desc, D);
182 MDNodeToDieMap.insert(std::make_pair(Desc, D));
185 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
186 if (DD->getDwarfVersion() >= 4)
187 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
189 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
192 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
193 Optional<dwarf::Form> Form, uint64_t Integer) {
195 Form = DIEInteger::BestForm(false, Integer);
196 Die.addValue(Attribute, *Form, DIEInteger(Integer));
199 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
200 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
203 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
204 Optional<dwarf::Form> Form, int64_t Integer) {
206 Form = DIEInteger::BestForm(true, Integer);
207 Die.addValue(Attribute, *Form, DIEInteger(Integer));
210 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
212 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
215 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
217 Die.addValue(Attribute,
218 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
219 DIEString(DU->getStringPool().getEntry(*Asm, String)));
222 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
223 const MCSymbol *Label) {
224 Die.addValue(Attribute, Form, DIELabel(Label));
227 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
228 addLabel(Die, (dwarf::Attribute)0, Form, Label);
231 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
233 if (DD->getDwarfVersion() >= 4)
234 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
236 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
239 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
240 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
241 : getCU().getOrCreateSourceID(FileName, DirName);
244 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
245 if (!DD->useSplitDwarf()) {
246 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
247 addLabel(Die, dwarf::DW_FORM_udata, Sym);
249 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
250 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
251 DD->getAddressPool().getIndex(Sym));
255 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
256 const MCSymbol *Hi, const MCSymbol *Lo) {
257 Die.addValue(Attribute, dwarf::DW_FORM_data4,
258 new (DIEValueAllocator) DIEDelta(Hi, Lo));
261 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
262 addDIEEntry(Die, Attribute, DIEEntry(Entry));
265 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
266 // Flag the type unit reference as a declaration so that if it contains
267 // members (implicit special members, static data member definitions, member
268 // declarations for definitions in this CU, etc) consumers don't get confused
269 // and think this is a full definition.
270 addFlag(Die, dwarf::DW_AT_declaration);
272 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
273 DIETypeSignature(Type));
276 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
278 const DIE *DieCU = Die.getUnitOrNull();
279 const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
281 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
282 DieCU = &getUnitDie();
284 EntryCU = &getUnitDie();
285 Die.addValue(Attribute,
286 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
290 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
291 assert(Tag != dwarf::DW_TAG_auto_variable &&
292 Tag != dwarf::DW_TAG_arg_variable);
293 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
294 DIE &Die = *Parent.getChildren().back();
300 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
301 Loc->ComputeSize(Asm);
302 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
303 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
306 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
308 Block->ComputeSize(Asm);
309 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
310 Die.addValue(Attribute, Block->BestForm(), Block);
313 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
314 StringRef Directory) {
318 unsigned FileID = getOrCreateSourceID(File, Directory);
319 assert(FileID && "Invalid file id");
320 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
321 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
324 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
327 addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
328 V->getScope()->getDirectory());
331 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
334 addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
337 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
340 addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
343 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
346 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
349 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
352 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
355 void DwarfUnit::addSourceLine(DIE &Die, const DINamespace *NS) {
356 addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
359 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
360 unsigned SizeInBits, unsigned OffsetInBits) {
361 DIEDwarfExpression Expr(*Asm, *this, TheDie);
362 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
366 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
368 DIEDwarfExpression Expr(*Asm, *this, TheDie);
369 return Expr.AddMachineRegIndirect(Reg, Offset);
372 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
373 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
374 gives the variable VarName either the struct, or a pointer to the struct, as
375 its type. This is necessary for various behind-the-scenes things the
376 compiler needs to do with by-reference variables in Blocks.
378 However, as far as the original *programmer* is concerned, the variable
379 should still have type 'SomeType', as originally declared.
381 The function getBlockByrefType dives into the __Block_byref_x_VarName
382 struct to find the original type of the variable, which is then assigned to
383 the variable's Debug Information Entry as its real type. So far, so good.
384 However now the debugger will expect the variable VarName to have the type
385 SomeType. So we need the location attribute for the variable to be an
386 expression that explains to the debugger how to navigate through the
387 pointers and struct to find the actual variable of type SomeType.
389 The following function does just that. We start by getting
390 the "normal" location for the variable. This will be the location
391 of either the struct __Block_byref_x_VarName or the pointer to the
392 struct __Block_byref_x_VarName.
394 The struct will look something like:
396 struct __Block_byref_x_VarName {
398 struct __Block_byref_x_VarName *forwarding;
399 ... <various other fields>
401 ... <maybe more fields>
404 If we are given the struct directly (as our starting point) we
405 need to tell the debugger to:
407 1). Add the offset of the forwarding field.
409 2). Follow that pointer to get the real __Block_byref_x_VarName
410 struct to use (the real one may have been copied onto the heap).
412 3). Add the offset for the field VarName, to find the actual variable.
414 If we started with a pointer to the struct, then we need to
415 dereference that pointer first, before the other steps.
416 Translating this into DWARF ops, we will need to append the following
417 to the current location description for the variable:
419 DW_OP_deref -- optional, if we start with a pointer
420 DW_OP_plus_uconst <forward_fld_offset>
422 DW_OP_plus_uconst <varName_fld_offset>
424 That is what this function does. */
426 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
427 dwarf::Attribute Attribute,
428 const MachineLocation &Location) {
429 const DIType *Ty = DV.getType();
430 const DIType *TmpTy = Ty;
431 uint16_t Tag = Ty->getTag();
432 bool isPointer = false;
434 StringRef varName = DV.getName();
436 if (Tag == dwarf::DW_TAG_pointer_type) {
437 auto *DTy = cast<DIDerivedType>(Ty);
438 TmpTy = resolve(DTy->getBaseType());
442 // Find the __forwarding field and the variable field in the __Block_byref
444 DINodeArray Fields = cast<DICompositeTypeBase>(TmpTy)->getElements();
445 const DIDerivedType *varField = nullptr;
446 const DIDerivedType *forwardingField = nullptr;
448 for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
449 auto *DT = cast<DIDerivedType>(Fields[i]);
450 StringRef fieldName = DT->getName();
451 if (fieldName == "__forwarding")
452 forwardingField = DT;
453 else if (fieldName == varName)
457 // Get the offsets for the forwarding field and the variable field.
458 unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
459 unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
461 // Decode the original location, and use that as the start of the byref
462 // variable's location.
463 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
466 if (Location.isReg())
467 validReg = addRegisterOpPiece(*Loc, Location.getReg());
469 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
474 // If we started with a pointer to the __Block_byref... struct, then
475 // the first thing we need to do is dereference the pointer (DW_OP_deref).
477 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
479 // Next add the offset for the '__forwarding' field:
480 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
481 // adding the offset if it's 0.
482 if (forwardingFieldOffset > 0) {
483 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
484 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
487 // Now dereference the __forwarding field to get to the real __Block_byref
488 // struct: DW_OP_deref.
489 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
491 // Now that we've got the real __Block_byref... struct, add the offset
492 // for the variable's field to get to the location of the actual variable:
493 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
494 if (varFieldOffset > 0) {
495 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
496 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
499 // Now attach the location information to the DIE.
500 addBlock(Die, Attribute, Loc);
503 /// Return true if type encoding is unsigned.
504 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
505 if (auto *DTy = dyn_cast<DIDerivedTypeBase>(Ty)) {
506 dwarf::Tag T = (dwarf::Tag)Ty->getTag();
507 // Encode pointer constants as unsigned bytes. This is used at least for
508 // null pointer constant emission.
509 // (Pieces of) aggregate types that get hacked apart by SROA may also be
510 // represented by a constant. Encode them as unsigned bytes.
511 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
512 // here, but accept them for now due to a bug in SROA producing bogus
514 if (T == dwarf::DW_TAG_array_type ||
515 T == dwarf::DW_TAG_class_type ||
516 T == dwarf::DW_TAG_pointer_type ||
517 T == dwarf::DW_TAG_ptr_to_member_type ||
518 T == dwarf::DW_TAG_reference_type ||
519 T == dwarf::DW_TAG_rvalue_reference_type ||
520 T == dwarf::DW_TAG_structure_type ||
521 T == dwarf::DW_TAG_union_type)
523 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
524 T == dwarf::DW_TAG_volatile_type ||
525 T == dwarf::DW_TAG_restrict_type ||
526 T == dwarf::DW_TAG_enumeration_type);
527 if (DITypeRef Deriv = DTy->getBaseType())
528 return isUnsignedDIType(DD, DD->resolve(Deriv));
529 // FIXME: Enums without a fixed underlying type have unknown signedness
530 // here, leading to incorrectly emitted constants.
531 assert(DTy->getTag() == dwarf::DW_TAG_enumeration_type);
535 auto *BTy = cast<DIBasicType>(Ty);
536 unsigned Encoding = BTy->getEncoding();
537 assert((Encoding == dwarf::DW_ATE_unsigned ||
538 Encoding == dwarf::DW_ATE_unsigned_char ||
539 Encoding == dwarf::DW_ATE_signed ||
540 Encoding == dwarf::DW_ATE_signed_char ||
541 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
542 Encoding == dwarf::DW_ATE_boolean ||
543 (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
544 Ty->getName() == "decltype(nullptr)")) &&
545 "Unsupported encoding");
546 return Encoding == dwarf::DW_ATE_unsigned ||
547 Encoding == dwarf::DW_ATE_unsigned_char ||
548 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
549 Ty->getTag() == dwarf::DW_TAG_unspecified_type;
552 /// If this type is derived from a base type then return base type size.
553 static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
554 unsigned Tag = Ty->getTag();
556 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
557 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
558 Tag != dwarf::DW_TAG_restrict_type)
559 return Ty->getSizeInBits();
561 auto *BaseType = DD->resolve(Ty->getBaseType());
563 assert(BaseType && "Unexpected invalid base type");
565 // If this is a derived type, go ahead and get the base type, unless it's a
566 // reference then it's just the size of the field. Pointer types have no need
567 // of this since they're a different type of qualification on the type.
568 if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
569 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
570 return Ty->getSizeInBits();
572 if (auto *DT = dyn_cast<DIDerivedType>(BaseType))
573 return getBaseTypeSize(DD, DT);
575 return BaseType->getSizeInBits();
578 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
579 assert(MO.isFPImm() && "Invalid machine operand!");
580 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
581 APFloat FPImm = MO.getFPImm()->getValueAPF();
583 // Get the raw data form of the floating point.
584 const APInt FltVal = FPImm.bitcastToAPInt();
585 const char *FltPtr = (const char *)FltVal.getRawData();
587 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
588 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
589 int Incr = (LittleEndian ? 1 : -1);
590 int Start = (LittleEndian ? 0 : NumBytes - 1);
591 int Stop = (LittleEndian ? NumBytes : -1);
593 // Output the constant to DWARF one byte at a time.
594 for (; Start != Stop; Start += Incr)
595 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
597 addBlock(Die, dwarf::DW_AT_const_value, Block);
600 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
601 // Pass this down to addConstantValue as an unsigned bag of bits.
602 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
605 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
607 addConstantValue(Die, CI->getValue(), Ty);
610 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
612 assert(MO.isImm() && "Invalid machine operand!");
614 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
617 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
618 // FIXME: This is a bit conservative/simple - it emits negative values always
619 // sign extended to 64 bits rather than minimizing the number of bytes.
620 addUInt(Die, dwarf::DW_AT_const_value,
621 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
624 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
625 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
628 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
629 unsigned CIBitWidth = Val.getBitWidth();
630 if (CIBitWidth <= 64) {
631 addConstantValue(Die, Unsigned,
632 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
636 DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
638 // Get the raw data form of the large APInt.
639 const uint64_t *Ptr64 = Val.getRawData();
641 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
642 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
644 // Output the constant to DWARF one byte at a time.
645 for (int i = 0; i < NumBytes; i++) {
648 c = Ptr64[i / 8] >> (8 * (i & 7));
650 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
651 addUInt(*Block, dwarf::DW_FORM_data1, c);
654 addBlock(Die, dwarf::DW_AT_const_value, Block);
657 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
658 if (!LinkageName.empty())
660 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
661 : dwarf::DW_AT_MIPS_linkage_name,
662 GlobalValue::getRealLinkageName(LinkageName));
665 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
666 // Add template parameters.
667 for (const auto *Element : TParams) {
668 if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
669 constructTemplateTypeParameterDIE(Buffer, TTP);
670 else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
671 constructTemplateValueParameterDIE(Buffer, TVP);
675 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
676 if (!Context || isa<DIFile>(Context))
677 return &getUnitDie();
678 if (auto *T = dyn_cast<DIType>(Context))
679 return getOrCreateTypeDIE(T);
680 if (auto *NS = dyn_cast<DINamespace>(Context))
681 return getOrCreateNameSpace(NS);
682 if (auto *SP = dyn_cast<DISubprogram>(Context))
683 return getOrCreateSubprogramDIE(SP);
684 return getDIE(Context);
687 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
688 auto *Context = resolve(Ty->getScope());
689 DIE *ContextDIE = getOrCreateContextDIE(Context);
691 if (DIE *TyDIE = getDIE(Ty))
695 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
697 constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
699 updateAcceleratorTables(Context, Ty, TyDIE);
703 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
707 auto *Ty = cast<DIType>(TyNode);
708 assert(Ty == resolve(Ty->getRef()) &&
709 "type was not uniqued, possible ODR violation.");
711 // DW_TAG_restrict_type is not supported in DWARF2
712 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
713 return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
715 // Construct the context before querying for the existence of the DIE in case
716 // such construction creates the DIE.
717 auto *Context = resolve(Ty->getScope());
718 DIE *ContextDIE = getOrCreateContextDIE(Context);
721 if (DIE *TyDIE = getDIE(Ty))
725 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
727 updateAcceleratorTables(Context, Ty, TyDIE);
729 if (auto *BT = dyn_cast<DIBasicType>(Ty))
730 constructTypeDIE(TyDIE, BT);
731 else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
732 constructTypeDIE(TyDIE, STy);
733 else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
734 if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
735 if (MDString *TypeId = CTy->getRawIdentifier()) {
736 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
737 // Skip updating the accelerator tables since this is not the full type.
740 constructTypeDIE(TyDIE, CTy);
742 constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
748 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
749 const DIType *Ty, const DIE &TyDIE) {
750 if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
751 bool IsImplementation = 0;
752 if (auto *CT = dyn_cast<DICompositeTypeBase>(Ty)) {
753 // A runtime language of 0 actually means C/C++ and that any
754 // non-negative value is some version of Objective-C/C++.
755 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
757 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
758 DD->addAccelType(Ty->getName(), TyDIE, Flags);
760 if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
761 isa<DINamespace>(Context))
762 addGlobalType(Ty, TyDIE, Context);
766 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
767 dwarf::Attribute Attribute) {
768 assert(Ty && "Trying to add a type that doesn't exist?");
769 addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
772 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
776 // FIXME: Decide whether to implement this for non-C++ languages.
777 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
781 SmallVector<const DIScope *, 1> Parents;
782 while (!isa<DICompileUnit>(Context)) {
783 Parents.push_back(Context);
784 if (Context->getScope())
785 Context = resolve(Context->getScope());
787 // Structure, etc types will have a NULL context if they're at the top
792 // Reverse iterate over our list to go from the outermost construct to the
794 for (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
795 const DIScope *Ctx = *I;
796 StringRef Name = Ctx->getName();
797 if (Name.empty() && isa<DINamespace>(Ctx))
798 Name = "(anonymous namespace)";
807 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
808 // Get core information.
809 StringRef Name = BTy->getName();
810 // Add name if not anonymous or intermediate type.
812 addString(Buffer, dwarf::DW_AT_name, Name);
814 // An unspecified type only has a name attribute.
815 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
818 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
821 uint64_t Size = BTy->getSizeInBits() >> 3;
822 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
825 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
826 // Get core information.
827 StringRef Name = DTy->getName();
828 uint64_t Size = DTy->getSizeInBits() >> 3;
829 uint16_t Tag = Buffer.getTag();
831 // Map to main type, void will not have a type.
832 const DIType *FromTy = resolve(DTy->getBaseType());
834 addType(Buffer, FromTy);
836 // Add name if not anonymous or intermediate type.
838 addString(Buffer, dwarf::DW_AT_name, Name);
840 // Add size if non-zero (derived types might be zero-sized.)
841 if (Size && Tag != dwarf::DW_TAG_pointer_type
842 && Tag != dwarf::DW_TAG_ptr_to_member_type)
843 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
845 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
847 Buffer, dwarf::DW_AT_containing_type,
848 *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
849 // Add source line info if available and TyDesc is not a forward declaration.
850 if (!DTy->isForwardDecl())
851 addSourceLine(Buffer, DTy);
854 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
855 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
856 const DIType *Ty = resolve(Args[i]);
858 assert(i == N-1 && "Unspecified parameter must be the last argument");
859 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
861 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
863 if (Ty->isArtificial())
864 addFlag(Arg, dwarf::DW_AT_artificial);
869 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
870 // Add return type. A void return won't have a type.
871 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
873 if (auto RTy = resolve(Elements[0]))
874 addType(Buffer, RTy);
876 bool isPrototyped = true;
877 if (Elements.size() == 2 && !Elements[1])
878 isPrototyped = false;
880 constructSubprogramArguments(Buffer, Elements);
882 // Add prototype flag if we're dealing with a C language and the function has
884 uint16_t Language = getLanguage();
886 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
887 Language == dwarf::DW_LANG_ObjC))
888 addFlag(Buffer, dwarf::DW_AT_prototyped);
890 if (CTy->isLValueReference())
891 addFlag(Buffer, dwarf::DW_AT_reference);
893 if (CTy->isRValueReference())
894 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
897 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
898 // Add name if not anonymous or intermediate type.
899 StringRef Name = CTy->getName();
901 uint64_t Size = CTy->getSizeInBits() >> 3;
902 uint16_t Tag = Buffer.getTag();
905 case dwarf::DW_TAG_array_type:
906 constructArrayTypeDIE(Buffer, CTy);
908 case dwarf::DW_TAG_enumeration_type:
909 constructEnumTypeDIE(Buffer, CTy);
911 case dwarf::DW_TAG_structure_type:
912 case dwarf::DW_TAG_union_type:
913 case dwarf::DW_TAG_class_type: {
914 // Add elements to structure type.
915 DINodeArray Elements = CTy->getElements();
916 for (const auto *Element : Elements) {
919 if (auto *SP = dyn_cast<DISubprogram>(Element))
920 getOrCreateSubprogramDIE(SP);
921 else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
922 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
923 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
924 addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
925 } else if (DDTy->isStaticMember()) {
926 getOrCreateStaticMemberDIE(DDTy);
928 constructMemberDIE(Buffer, DDTy);
930 } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
931 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
932 StringRef PropertyName = Property->getName();
933 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
934 if (Property->getType())
935 addType(ElemDie, Property->getType());
936 addSourceLine(ElemDie, Property);
937 StringRef GetterName = Property->getGetterName();
938 if (!GetterName.empty())
939 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
940 StringRef SetterName = Property->getSetterName();
941 if (!SetterName.empty())
942 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
943 if (unsigned PropertyAttributes = Property->getAttributes())
944 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
949 if (CTy->isAppleBlockExtension())
950 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
952 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
953 // inside C++ composite types to point to the base class with the vtable.
954 if (auto *ContainingType =
955 dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
956 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
957 *getOrCreateTypeDIE(ContainingType));
959 if (CTy->isObjcClassComplete())
960 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
962 // Add template parameters to a class, structure or union types.
963 // FIXME: The support isn't in the metadata for this yet.
964 if (Tag == dwarf::DW_TAG_class_type ||
965 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
966 addTemplateParams(Buffer, CTy->getTemplateParams());
974 // Add name if not anonymous or intermediate type.
976 addString(Buffer, dwarf::DW_AT_name, Name);
978 if (Tag == dwarf::DW_TAG_enumeration_type ||
979 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
980 Tag == dwarf::DW_TAG_union_type) {
981 // Add size if non-zero (derived types might be zero-sized.)
982 // TODO: Do we care about size for enum forward declarations?
984 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
985 else if (!CTy->isForwardDecl())
986 // Add zero size if it is not a forward declaration.
987 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
989 // If we're a forward decl, say so.
990 if (CTy->isForwardDecl())
991 addFlag(Buffer, dwarf::DW_AT_declaration);
993 // Add source line info if available.
994 if (!CTy->isForwardDecl())
995 addSourceLine(Buffer, CTy);
997 // No harm in adding the runtime language to the declaration.
998 unsigned RLang = CTy->getRuntimeLang();
1000 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1005 void DwarfUnit::constructTemplateTypeParameterDIE(
1006 DIE &Buffer, const DITemplateTypeParameter *TP) {
1008 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1009 // Add the type if it exists, it could be void and therefore no type.
1011 addType(ParamDIE, resolve(TP->getType()));
1012 if (!TP->getName().empty())
1013 addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1016 void DwarfUnit::constructTemplateValueParameterDIE(
1017 DIE &Buffer, const DITemplateValueParameter *VP) {
1018 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1020 // Add the type if there is one, template template and template parameter
1021 // packs will not have a type.
1022 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1023 addType(ParamDIE, resolve(VP->getType()));
1024 if (!VP->getName().empty())
1025 addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1026 if (Metadata *Val = VP->getValue()) {
1027 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1028 addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1029 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1030 // For declaration non-type template parameters (such as global values and
1032 DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1033 addOpAddress(*Loc, Asm->getSymbol(GV));
1034 // Emit DW_OP_stack_value to use the address as the immediate value of the
1035 // parameter, rather than a pointer to it.
1036 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1037 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1038 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1039 assert(isa<MDString>(Val));
1040 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1041 cast<MDString>(Val)->getString());
1042 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1043 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1048 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1049 // Construct the context before querying for the existence of the DIE in case
1050 // such construction creates the DIE.
1051 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1053 if (DIE *NDie = getDIE(NS))
1055 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1057 StringRef Name = NS->getName();
1059 addString(NDie, dwarf::DW_AT_name, NS->getName());
1061 Name = "(anonymous namespace)";
1062 DD->addAccelNamespace(Name, NDie);
1063 addGlobalName(Name, NDie, NS->getScope());
1064 addSourceLine(NDie, NS);
1068 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1069 // Construct the context before querying for the existence of the DIE in case
1070 // such construction creates the DIE (as is the case for member function
1073 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1075 if (DIE *SPDie = getDIE(SP))
1078 if (auto *SPDecl = SP->getDeclaration()) {
1080 // Add subprogram definitions to the CU die directly.
1081 ContextDIE = &getUnitDie();
1082 // Build the decl now to ensure it precedes the definition.
1083 getOrCreateSubprogramDIE(SPDecl);
1087 // DW_TAG_inlined_subroutine may refer to this DIE.
1088 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1090 // Stop here and fill this in later, depending on whether or not this
1091 // subprogram turns out to have inlined instances or not.
1092 if (SP->isDefinition())
1095 applySubprogramAttributes(SP, SPDie);
1099 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1101 DIE *DeclDie = nullptr;
1102 StringRef DeclLinkageName;
1103 if (auto *SPDecl = SP->getDeclaration()) {
1104 DeclDie = getDIE(SPDecl);
1105 assert(DeclDie && "This DIE should've already been constructed when the "
1106 "definition DIE was created in "
1107 "getOrCreateSubprogramDIE");
1108 DeclLinkageName = SPDecl->getLinkageName();
1111 // Add function template parameters.
1112 addTemplateParams(SPDie, SP->getTemplateParams());
1114 // Add the linkage name if we have one and it isn't in the Decl.
1115 StringRef LinkageName = SP->getLinkageName();
1116 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1117 LinkageName == DeclLinkageName) &&
1118 "decl has a linkage name and it is different");
1119 if (DeclLinkageName.empty())
1120 addLinkageName(SPDie, LinkageName);
1125 // Refer to the function declaration where all the other attributes will be
1127 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1131 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1134 if (applySubprogramDefinitionAttributes(SP, SPDie))
1137 // Constructors and operators for anonymous aggregates do not have names.
1138 if (!SP->getName().empty())
1139 addString(SPDie, dwarf::DW_AT_name, SP->getName());
1141 // Skip the rest of the attributes under -gmlt to save space.
1145 addSourceLine(SPDie, SP);
1147 // Add the prototype if we have a prototype and we have a C like
1149 uint16_t Language = getLanguage();
1150 if (SP->isPrototyped() &&
1151 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1152 Language == dwarf::DW_LANG_ObjC))
1153 addFlag(SPDie, dwarf::DW_AT_prototyped);
1155 const DISubroutineType *SPTy = SP->getType();
1156 assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1157 "the type of a subprogram should be a subroutine");
1159 auto Args = SPTy->getTypeArray();
1160 // Add a return type. If this is a type like a C/C++ void type we don't add a
1163 if (auto Ty = resolve(Args[0]))
1166 unsigned VK = SP->getVirtuality();
1168 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1169 DIELoc *Block = getDIELoc();
1170 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1171 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1172 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1173 ContainingTypeMap.insert(
1174 std::make_pair(&SPDie, resolve(SP->getContainingType())));
1177 if (!SP->isDefinition()) {
1178 addFlag(SPDie, dwarf::DW_AT_declaration);
1180 // Add arguments. Do not add arguments for subprogram definition. They will
1181 // be handled while processing variables.
1182 constructSubprogramArguments(SPDie, Args);
1185 if (SP->isArtificial())
1186 addFlag(SPDie, dwarf::DW_AT_artificial);
1188 if (!SP->isLocalToUnit())
1189 addFlag(SPDie, dwarf::DW_AT_external);
1191 if (SP->isOptimized())
1192 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1194 if (unsigned isa = Asm->getISAEncoding())
1195 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1197 if (SP->isLValueReference())
1198 addFlag(SPDie, dwarf::DW_AT_reference);
1200 if (SP->isRValueReference())
1201 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1203 if (SP->isProtected())
1204 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1205 dwarf::DW_ACCESS_protected);
1206 else if (SP->isPrivate())
1207 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1208 dwarf::DW_ACCESS_private);
1209 else if (SP->isPublic())
1210 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1211 dwarf::DW_ACCESS_public);
1213 if (SP->isExplicit())
1214 addFlag(SPDie, dwarf::DW_AT_explicit);
1217 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1219 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1220 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1222 // The LowerBound value defines the lower bounds which is typically zero for
1223 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1224 // Count == -1 then the array is unbounded and we do not emit
1225 // DW_AT_lower_bound and DW_AT_count attributes.
1226 int64_t LowerBound = SR->getLowerBound();
1227 int64_t DefaultLowerBound = getDefaultLowerBound();
1228 int64_t Count = SR->getCount();
1230 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1231 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1234 // FIXME: An unbounded array should reference the expression that defines
1236 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1239 DIE *DwarfUnit::getIndexTyDie() {
1242 // Construct an integer type to use for indexes.
1243 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1244 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1245 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1246 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1247 dwarf::DW_ATE_unsigned);
1251 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1252 if (CTy->isVector())
1253 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1255 // Emit the element type.
1256 addType(Buffer, resolve(CTy->getBaseType()));
1258 // Get an anonymous type for index type.
1259 // FIXME: This type should be passed down from the front end
1260 // as different languages may have different sizes for indexes.
1261 DIE *IdxTy = getIndexTyDie();
1263 // Add subranges to array type.
1264 DINodeArray Elements = CTy->getElements();
1265 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1266 // FIXME: Should this really be such a loose cast?
1267 if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1268 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1269 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1273 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1274 DINodeArray Elements = CTy->getElements();
1276 // Add enumerators to enumeration type.
1277 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1278 auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1280 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1281 StringRef Name = Enum->getName();
1282 addString(Enumerator, dwarf::DW_AT_name, Name);
1283 int64_t Value = Enum->getValue();
1284 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1288 const DIType *DTy = resolve(CTy->getBaseType());
1290 addType(Buffer, DTy);
1291 addFlag(Buffer, dwarf::DW_AT_enum_class);
1295 void DwarfUnit::constructContainingTypeDIEs() {
1296 for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1298 DIE &SPDie = *CI->first;
1299 const DINode *D = CI->second;
1302 DIE *NDie = getDIE(D);
1305 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1309 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1310 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1311 StringRef Name = DT->getName();
1313 addString(MemberDie, dwarf::DW_AT_name, Name);
1315 addType(MemberDie, resolve(DT->getBaseType()));
1317 addSourceLine(MemberDie, DT);
1319 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1321 // For C++, virtual base classes are not at fixed offset. Use following
1322 // expression to extract appropriate offset from vtable.
1323 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1325 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1326 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1327 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1328 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1329 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1330 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1331 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1332 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1334 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1336 uint64_t Size = DT->getSizeInBits();
1337 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1338 uint64_t OffsetInBytes;
1340 if (FieldSize && Size != FieldSize) {
1341 // Handle bitfield, assume bytes are 8 bits.
1342 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1343 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1345 uint64_t Offset = DT->getOffsetInBits();
1346 uint64_t AlignMask = ~(DT->getAlignInBits() - 1);
1347 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1348 uint64_t FieldOffset = (HiMark - FieldSize);
1349 Offset -= FieldOffset;
1351 // Maybe we need to work from the other end.
1352 if (Asm->getDataLayout().isLittleEndian())
1353 Offset = FieldSize - (Offset + Size);
1354 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1356 // Here DW_AT_data_member_location points to the anonymous
1357 // field that includes this bit field.
1358 OffsetInBytes = FieldOffset >> 3;
1360 // This is not a bitfield.
1361 OffsetInBytes = DT->getOffsetInBits() >> 3;
1363 if (DD->getDwarfVersion() <= 2) {
1364 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1365 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1366 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1367 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1369 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1373 if (DT->isProtected())
1374 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1375 dwarf::DW_ACCESS_protected);
1376 else if (DT->isPrivate())
1377 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1378 dwarf::DW_ACCESS_private);
1379 // Otherwise C++ member and base classes are considered public.
1380 else if (DT->isPublic())
1381 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1382 dwarf::DW_ACCESS_public);
1383 if (DT->isVirtual())
1384 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1385 dwarf::DW_VIRTUALITY_virtual);
1387 // Objective-C properties.
1388 if (DINode *PNode = DT->getObjCProperty())
1389 if (DIE *PDie = getDIE(PNode))
1390 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1393 if (DT->isArtificial())
1394 addFlag(MemberDie, dwarf::DW_AT_artificial);
1397 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1401 // Construct the context before querying for the existence of the DIE in case
1402 // such construction creates the DIE.
1403 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1404 assert(dwarf::isType(ContextDIE->getTag()) &&
1405 "Static member should belong to a type.");
1407 if (DIE *StaticMemberDIE = getDIE(DT))
1408 return StaticMemberDIE;
1410 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1412 const DIType *Ty = resolve(DT->getBaseType());
1414 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1415 addType(StaticMemberDIE, Ty);
1416 addSourceLine(StaticMemberDIE, DT);
1417 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1418 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1420 // FIXME: We could omit private if the parent is a class_type, and
1421 // public if the parent is something else.
1422 if (DT->isProtected())
1423 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1424 dwarf::DW_ACCESS_protected);
1425 else if (DT->isPrivate())
1426 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1427 dwarf::DW_ACCESS_private);
1428 else if (DT->isPublic())
1429 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1430 dwarf::DW_ACCESS_public);
1432 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1433 addConstantValue(StaticMemberDIE, CI, Ty);
1434 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1435 addConstantFPValue(StaticMemberDIE, CFP);
1437 return &StaticMemberDIE;
1440 void DwarfUnit::emitHeader(bool UseOffsets) {
1441 // Emit size of content not including length itself
1442 Asm->OutStreamer->AddComment("Length of Unit");
1443 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1445 Asm->OutStreamer->AddComment("DWARF version number");
1446 Asm->EmitInt16(DD->getDwarfVersion());
1447 Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1449 // We share one abbreviations table across all units so it's always at the
1450 // start of the section. Use a relocatable offset where needed to ensure
1451 // linking doesn't invalidate that offset.
1452 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1454 Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1458 Asm->OutStreamer->AddComment("Address Size (in bytes)");
1459 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1462 void DwarfUnit::initSection(MCSection *Section) {
1463 assert(!this->Section);
1464 this->Section = Section;
1467 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1468 DwarfUnit::emitHeader(UseOffsets);
1469 Asm->OutStreamer->AddComment("Type Signature");
1470 Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1471 Asm->OutStreamer->AddComment("Type DIE Offset");
1472 // In a skeleton type unit there is no type DIE so emit a zero offset.
1473 Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1474 sizeof(Ty->getOffset()));
1477 bool DwarfTypeUnit::isDwoUnit() const {
1478 // Since there are no skeleton type units, all type units are dwo type units
1479 // when split DWARF is being used.
1480 return DD->useSplitDwarf();