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);
67 /// Unit - Unit constructor.
68 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
69 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
70 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
71 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
72 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
73 UnitTag == dwarf::DW_TAG_type_unit);
74 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
77 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
78 DwarfDebug *DW, DwarfFile *DWU,
79 MCDwarfDwoLineTable *SplitLineTable)
80 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
81 CU(CU), SplitLineTable(SplitLineTable) {
83 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
86 /// ~Unit - Destructor for compile unit.
87 DwarfUnit::~DwarfUnit() {
88 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
89 DIEBlocks[j]->~DIEBlock();
90 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
91 DIELocs[j]->~DIELoc();
94 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
95 /// information entry.
96 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
97 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
101 /// getDefaultLowerBound - Return the default lower bound for an array. If the
102 /// DWARF version doesn't handle the language, return -1.
103 int64_t DwarfUnit::getDefaultLowerBound() const {
104 switch (getLanguage()) {
108 case dwarf::DW_LANG_C89:
109 case dwarf::DW_LANG_C99:
110 case dwarf::DW_LANG_C:
111 case dwarf::DW_LANG_C_plus_plus:
112 case dwarf::DW_LANG_ObjC:
113 case dwarf::DW_LANG_ObjC_plus_plus:
116 case dwarf::DW_LANG_Fortran77:
117 case dwarf::DW_LANG_Fortran90:
118 case dwarf::DW_LANG_Fortran95:
121 // The languages below have valid values only if the DWARF version >= 4.
122 case dwarf::DW_LANG_Java:
123 case dwarf::DW_LANG_Python:
124 case dwarf::DW_LANG_UPC:
125 case dwarf::DW_LANG_D:
126 if (dwarf::DWARF_VERSION >= 4)
130 case dwarf::DW_LANG_Ada83:
131 case dwarf::DW_LANG_Ada95:
132 case dwarf::DW_LANG_Cobol74:
133 case dwarf::DW_LANG_Cobol85:
134 case dwarf::DW_LANG_Modula2:
135 case dwarf::DW_LANG_Pascal83:
136 case dwarf::DW_LANG_PLI:
137 if (dwarf::DWARF_VERSION >= 4)
141 // The languages below have valid values only if the DWARF version >= 5.
142 case dwarf::DW_LANG_OpenCL:
143 case dwarf::DW_LANG_Go:
144 case dwarf::DW_LANG_Haskell:
145 case dwarf::DW_LANG_C_plus_plus_03:
146 case dwarf::DW_LANG_C_plus_plus_11:
147 case dwarf::DW_LANG_OCaml:
148 case dwarf::DW_LANG_Rust:
149 case dwarf::DW_LANG_C11:
150 case dwarf::DW_LANG_Swift:
151 case dwarf::DW_LANG_Dylan:
152 case dwarf::DW_LANG_C_plus_plus_14:
153 if (dwarf::DWARF_VERSION >= 5)
157 case dwarf::DW_LANG_Modula3:
158 case dwarf::DW_LANG_Julia:
159 case dwarf::DW_LANG_Fortran03:
160 case dwarf::DW_LANG_Fortran08:
161 if (dwarf::DWARF_VERSION >= 5)
169 /// Check whether the DIE for this MDNode can be shared across CUs.
170 static bool isShareableAcrossCUs(DIDescriptor D) {
171 // When the MDNode can be part of the type system, the DIE can be shared
173 // Combining type units and cross-CU DIE sharing is lower value (since
174 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
175 // level already) but may be implementable for some value in projects
176 // building multiple independent libraries with LTO and then linking those
178 return (isa<MDType>(D) ||
179 (isa<MDSubprogram>(D) && !cast<MDSubprogram>(D)->isDefinition())) &&
180 !GenerateDwarfTypeUnits;
183 /// getDIE - Returns the debug information entry map slot for the
184 /// specified debug variable. We delegate the request to DwarfDebug
185 /// when the DIE for this MDNode can be shared across CUs. The mappings
186 /// will be kept in DwarfDebug for shareable DIEs.
187 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
188 if (isShareableAcrossCUs(D))
189 return DU->getDIE(D);
190 return MDNodeToDieMap.lookup(D);
193 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
194 /// when the DIE for this MDNode can be shared across CUs. The mappings
195 /// will be kept in DwarfDebug for shareable DIEs.
196 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
197 if (isShareableAcrossCUs(Desc)) {
198 DU->insertDIE(Desc, D);
201 MDNodeToDieMap.insert(std::make_pair(Desc, D));
204 /// addFlag - Add a flag that is true.
205 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
206 if (DD->getDwarfVersion() >= 4)
207 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
209 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
212 /// addUInt - Add an unsigned integer attribute data and value.
214 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
215 Optional<dwarf::Form> Form, uint64_t Integer) {
217 Form = DIEInteger::BestForm(false, Integer);
218 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
220 Die.addValue(Attribute, *Form, Value);
223 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
224 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
227 /// addSInt - Add an signed integer attribute data and value.
229 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
230 Optional<dwarf::Form> Form, int64_t Integer) {
232 Form = DIEInteger::BestForm(true, Integer);
233 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
234 Die.addValue(Attribute, *Form, Value);
237 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
239 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
242 /// addString - Add a string attribute data and value. We always emit a
243 /// reference to the string pool instead of immediate strings so that DIEs have
244 /// more predictable sizes. In the case of split dwarf we emit an index
245 /// into another table which gets us the static offset into the string
247 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
250 return addLocalString(Die, Attribute, String);
252 addIndexedString(Die, Attribute, String);
255 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
257 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
258 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
259 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
260 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
263 /// addLocalString - Add a string attribute data and value. This is guaranteed
264 /// to be in the local string pool instead of indirected.
265 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
267 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
268 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
270 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
271 Value = new (DIEValueAllocator) DIELabel(Symb);
273 Value = new (DIEValueAllocator)
274 DIEDelta(Symb, TLOF.getDwarfStrSection()->getBeginSymbol());
275 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
276 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
279 /// addLabel - Add a Dwarf label attribute data and value.
281 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
282 const MCSymbol *Label) {
283 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
284 Die.addValue(Attribute, Form, Value);
287 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
288 addLabel(Die, (dwarf::Attribute)0, Form, Label);
291 /// addSectionOffset - Add an offset into a section attribute data and value.
293 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
295 if (DD->getDwarfVersion() >= 4)
296 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
298 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
301 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
302 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
303 : getCU().getOrCreateSourceID(FileName, DirName);
306 /// addOpAddress - Add a dwarf op address data and value using the
307 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
309 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
310 if (!DD->useSplitDwarf()) {
311 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
312 addLabel(Die, dwarf::DW_FORM_udata, Sym);
314 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
315 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
316 DD->getAddressPool().getIndex(Sym));
320 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
321 const MCSymbol *Hi, const MCSymbol *Lo) {
322 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
323 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
326 /// addDIEEntry - Add a DIE attribute data and value.
328 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
329 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
332 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
333 // Flag the type unit reference as a declaration so that if it contains
334 // members (implicit special members, static data member definitions, member
335 // declarations for definitions in this CU, etc) consumers don't get confused
336 // and think this is a full definition.
337 addFlag(Die, dwarf::DW_AT_declaration);
339 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
340 new (DIEValueAllocator) DIETypeSignature(Type));
343 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
345 const DIE *DieCU = Die.getUnitOrNull();
346 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
348 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
349 DieCU = &getUnitDie();
351 EntryCU = &getUnitDie();
352 Die.addValue(Attribute,
353 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
357 /// Create a DIE with the given Tag, add the DIE to its parent, and
358 /// call insertDIE if MD is not null.
359 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
360 assert(Tag != dwarf::DW_TAG_auto_variable &&
361 Tag != dwarf::DW_TAG_arg_variable);
362 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
363 DIE &Die = *Parent.getChildren().back();
369 /// addBlock - Add block data.
371 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
372 Loc->ComputeSize(Asm);
373 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
374 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
377 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
379 Block->ComputeSize(Asm);
380 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
381 Die.addValue(Attribute, Block->BestForm(), Block);
384 /// addSourceLine - Add location information to specified debug information
386 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
387 StringRef Directory) {
391 unsigned FileID = getOrCreateSourceID(File, Directory);
392 assert(FileID && "Invalid file id");
393 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
394 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
397 /// addSourceLine - Add location information to specified debug information
399 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
402 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
403 V.getContext().getDirectory());
406 /// addSourceLine - Add location information to specified debug information
408 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
411 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
414 /// addSourceLine - Add location information to specified debug information
416 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
419 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
422 /// addSourceLine - Add location information to specified debug information
424 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
427 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
430 /// addSourceLine - Add location information to specified debug information
432 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
435 DIFile File = Ty.getFile();
436 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
437 File.getDirectory());
440 /// addSourceLine - Add location information to specified debug information
442 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
443 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
446 /// addRegisterOp - Add register operand.
447 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
448 unsigned SizeInBits, unsigned OffsetInBits) {
449 DIEDwarfExpression Expr(*Asm, *this, TheDie);
450 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
454 /// addRegisterOffset - Add register offset.
455 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
457 DIEDwarfExpression Expr(*Asm, *this, TheDie);
458 return Expr.AddMachineRegIndirect(Reg, Offset);
461 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
462 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
463 gives the variable VarName either the struct, or a pointer to the struct, as
464 its type. This is necessary for various behind-the-scenes things the
465 compiler needs to do with by-reference variables in Blocks.
467 However, as far as the original *programmer* is concerned, the variable
468 should still have type 'SomeType', as originally declared.
470 The function getBlockByrefType dives into the __Block_byref_x_VarName
471 struct to find the original type of the variable, which is then assigned to
472 the variable's Debug Information Entry as its real type. So far, so good.
473 However now the debugger will expect the variable VarName to have the type
474 SomeType. So we need the location attribute for the variable to be an
475 expression that explains to the debugger how to navigate through the
476 pointers and struct to find the actual variable of type SomeType.
478 The following function does just that. We start by getting
479 the "normal" location for the variable. This will be the location
480 of either the struct __Block_byref_x_VarName or the pointer to the
481 struct __Block_byref_x_VarName.
483 The struct will look something like:
485 struct __Block_byref_x_VarName {
487 struct __Block_byref_x_VarName *forwarding;
488 ... <various other fields>
490 ... <maybe more fields>
493 If we are given the struct directly (as our starting point) we
494 need to tell the debugger to:
496 1). Add the offset of the forwarding field.
498 2). Follow that pointer to get the real __Block_byref_x_VarName
499 struct to use (the real one may have been copied onto the heap).
501 3). Add the offset for the field VarName, to find the actual variable.
503 If we started with a pointer to the struct, then we need to
504 dereference that pointer first, before the other steps.
505 Translating this into DWARF ops, we will need to append the following
506 to the current location description for the variable:
508 DW_OP_deref -- optional, if we start with a pointer
509 DW_OP_plus_uconst <forward_fld_offset>
511 DW_OP_plus_uconst <varName_fld_offset>
513 That is what this function does. */
515 /// addBlockByrefAddress - Start with the address based on the location
516 /// provided, and generate the DWARF information necessary to find the
517 /// actual Block variable (navigating the Block struct) based on the
518 /// starting location. Add the DWARF information to the die. For
519 /// more information, read large comment just above here.
521 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
522 dwarf::Attribute Attribute,
523 const MachineLocation &Location) {
524 DIType Ty = DV.getType();
526 uint16_t Tag = Ty.getTag();
527 bool isPointer = false;
529 StringRef varName = DV.getName();
531 if (Tag == dwarf::DW_TAG_pointer_type) {
532 DIDerivedType DTy = cast<MDDerivedType>(Ty);
533 TmpTy = resolve(DTy.getTypeDerivedFrom());
537 DICompositeType blockStruct = cast<MDCompositeTypeBase>(TmpTy);
539 // Find the __forwarding field and the variable field in the __Block_byref
541 DIArray Fields = blockStruct.getElements();
542 DIDerivedType varField;
543 DIDerivedType forwardingField;
545 for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
546 DIDerivedType DT = cast<MDDerivedTypeBase>(Fields[i]);
547 StringRef fieldName = DT.getName();
548 if (fieldName == "__forwarding")
549 forwardingField = DT;
550 else if (fieldName == varName)
554 // Get the offsets for the forwarding field and the variable field.
555 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
556 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
558 // Decode the original location, and use that as the start of the byref
559 // variable's location.
560 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
563 if (Location.isReg())
564 validReg = addRegisterOpPiece(*Loc, Location.getReg());
566 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
571 // If we started with a pointer to the __Block_byref... struct, then
572 // the first thing we need to do is dereference the pointer (DW_OP_deref).
574 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
576 // Next add the offset for the '__forwarding' field:
577 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
578 // adding the offset if it's 0.
579 if (forwardingFieldOffset > 0) {
580 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
581 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
584 // Now dereference the __forwarding field to get to the real __Block_byref
585 // struct: DW_OP_deref.
586 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
588 // Now that we've got the real __Block_byref... struct, add the offset
589 // for the variable's field to get to the location of the actual variable:
590 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
591 if (varFieldOffset > 0) {
592 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
593 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
596 // Now attach the location information to the DIE.
597 addBlock(Die, Attribute, Loc);
600 /// Return true if type encoding is unsigned.
601 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
602 if (DIDerivedType DTy = dyn_cast<MDDerivedTypeBase>(Ty)) {
603 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
604 // Encode pointer constants as unsigned bytes. This is used at least for
605 // null pointer constant emission.
606 // (Pieces of) aggregate types that get hacked apart by SROA may also be
607 // represented by a constant. Encode them as unsigned bytes.
608 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
609 // here, but accept them for now due to a bug in SROA producing bogus
611 if (T == dwarf::DW_TAG_array_type ||
612 T == dwarf::DW_TAG_class_type ||
613 T == dwarf::DW_TAG_pointer_type ||
614 T == dwarf::DW_TAG_ptr_to_member_type ||
615 T == dwarf::DW_TAG_reference_type ||
616 T == dwarf::DW_TAG_rvalue_reference_type ||
617 T == dwarf::DW_TAG_structure_type ||
618 T == dwarf::DW_TAG_union_type)
620 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
621 T == dwarf::DW_TAG_volatile_type ||
622 T == dwarf::DW_TAG_restrict_type ||
623 T == dwarf::DW_TAG_enumeration_type);
624 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
625 return isUnsignedDIType(DD, DD->resolve(Deriv));
626 // FIXME: Enums without a fixed underlying type have unknown signedness
627 // here, leading to incorrectly emitted constants.
628 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
632 DIBasicType BTy = cast<MDBasicType>(Ty);
633 unsigned Encoding = BTy.getEncoding();
634 assert((Encoding == dwarf::DW_ATE_unsigned ||
635 Encoding == dwarf::DW_ATE_unsigned_char ||
636 Encoding == dwarf::DW_ATE_signed ||
637 Encoding == dwarf::DW_ATE_signed_char ||
638 Encoding == dwarf::DW_ATE_float ||
639 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
640 (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
641 Ty.getName() == "decltype(nullptr)")) &&
642 "Unsupported encoding");
643 return (Encoding == dwarf::DW_ATE_unsigned ||
644 Encoding == dwarf::DW_ATE_unsigned_char ||
645 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
646 Ty.getTag() == dwarf::DW_TAG_unspecified_type);
649 /// If this type is derived from a base type then return base type size.
650 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
651 unsigned Tag = Ty.getTag();
653 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
654 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
655 Tag != dwarf::DW_TAG_restrict_type)
656 return Ty.getSizeInBits();
658 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
660 assert(BaseType.isValid() && "Unexpected invalid base type");
662 // If this is a derived type, go ahead and get the base type, unless it's a
663 // reference then it's just the size of the field. Pointer types have no need
664 // of this since they're a different type of qualification on the type.
665 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
666 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
667 return Ty.getSizeInBits();
669 if (auto *DT = dyn_cast<MDDerivedTypeBase>(BaseType))
670 return getBaseTypeSize(DD, DT);
672 return BaseType.getSizeInBits();
675 /// addConstantFPValue - Add constant value entry in variable DIE.
676 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
677 assert(MO.isFPImm() && "Invalid machine operand!");
678 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
679 APFloat FPImm = MO.getFPImm()->getValueAPF();
681 // Get the raw data form of the floating point.
682 const APInt FltVal = FPImm.bitcastToAPInt();
683 const char *FltPtr = (const char *)FltVal.getRawData();
685 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
686 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
687 int Incr = (LittleEndian ? 1 : -1);
688 int Start = (LittleEndian ? 0 : NumBytes - 1);
689 int Stop = (LittleEndian ? NumBytes : -1);
691 // Output the constant to DWARF one byte at a time.
692 for (; Start != Stop; Start += Incr)
693 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
695 addBlock(Die, dwarf::DW_AT_const_value, Block);
698 /// addConstantFPValue - Add constant value entry in variable DIE.
699 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
700 // Pass this down to addConstantValue as an unsigned bag of bits.
701 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
704 /// addConstantValue - Add constant value entry in variable DIE.
705 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
706 addConstantValue(Die, CI->getValue(), Ty);
709 /// addConstantValue - Add constant value entry in variable DIE.
710 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
712 assert(MO.isImm() && "Invalid machine operand!");
714 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
717 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
718 // FIXME: This is a bit conservative/simple - it emits negative values always
719 // sign extended to 64 bits rather than minimizing the number of bytes.
720 addUInt(Die, dwarf::DW_AT_const_value,
721 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
724 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
725 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
728 // addConstantValue - Add constant value entry in variable DIE.
729 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
730 unsigned CIBitWidth = Val.getBitWidth();
731 if (CIBitWidth <= 64) {
732 addConstantValue(Die, Unsigned,
733 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
737 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
739 // Get the raw data form of the large APInt.
740 const uint64_t *Ptr64 = Val.getRawData();
742 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
743 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
745 // Output the constant to DWARF one byte at a time.
746 for (int i = 0; i < NumBytes; i++) {
749 c = Ptr64[i / 8] >> (8 * (i & 7));
751 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
752 addUInt(*Block, dwarf::DW_FORM_data1, c);
755 addBlock(Die, dwarf::DW_AT_const_value, Block);
758 // Add a linkage name to the DIE.
759 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
760 if (!LinkageName.empty())
762 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
763 : dwarf::DW_AT_MIPS_linkage_name,
764 GlobalValue::getRealLinkageName(LinkageName));
767 /// addTemplateParams - Add template parameters into buffer.
768 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
769 // Add template parameters.
770 for (unsigned i = 0, e = TParams.size(); i != e; ++i) {
771 DIDescriptor Element = TParams[i];
772 if (auto *TTP = dyn_cast<MDTemplateTypeParameter>(Element))
773 constructTemplateTypeParameterDIE(Buffer, TTP);
774 else if (auto *TVP = dyn_cast<MDTemplateValueParameter>(Element))
775 constructTemplateValueParameterDIE(Buffer, TVP);
779 /// getOrCreateContextDIE - Get context owner's DIE.
780 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
781 if (!Context || isa<MDFile>(Context))
782 return &getUnitDie();
783 if (auto *T = dyn_cast<MDType>(Context))
784 return getOrCreateTypeDIE(T);
785 if (auto *NS = dyn_cast<MDNamespace>(Context))
786 return getOrCreateNameSpace(NS);
787 if (auto *SP = dyn_cast<MDSubprogram>(Context))
788 return getOrCreateSubprogramDIE(SP);
789 return getDIE(Context);
792 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
793 DIScope Context = resolve(Ty.getContext());
794 DIE *ContextDIE = getOrCreateContextDIE(Context);
796 if (DIE *TyDIE = getDIE(Ty))
800 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
802 constructTypeDIE(TyDIE, Ty);
804 updateAcceleratorTables(Context, Ty, TyDIE);
808 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
810 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
814 DIType Ty = cast<MDType>(TyNode);
815 assert(Ty == resolve(Ty.getRef()) &&
816 "type was not uniqued, possible ODR violation.");
818 // DW_TAG_restrict_type is not supported in DWARF2
819 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
820 return getOrCreateTypeDIE(
821 resolve(DITypeRef(cast<MDDerivedType>(Ty)->getBaseType())));
823 // Construct the context before querying for the existence of the DIE in case
824 // such construction creates the DIE.
825 DIScope Context = resolve(Ty.getContext());
826 DIE *ContextDIE = getOrCreateContextDIE(Context);
829 if (DIE *TyDIE = getDIE(Ty))
833 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
835 updateAcceleratorTables(Context, Ty, TyDIE);
837 if (auto *BT = dyn_cast<MDBasicType>(Ty))
838 constructTypeDIE(TyDIE, BT);
839 else if (DICompositeType CTy = dyn_cast<MDCompositeTypeBase>(Ty)) {
840 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
841 if (MDString *TypeId = CTy.getIdentifier()) {
842 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
843 // Skip updating the accelerator tables since this is not the full type.
846 constructTypeDIE(TyDIE, CTy);
848 constructTypeDIE(TyDIE, cast<MDDerivedType>(Ty));
854 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
856 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
857 bool IsImplementation = 0;
858 if (DICompositeType CT = dyn_cast<MDCompositeTypeBase>(Ty)) {
859 // A runtime language of 0 actually means C/C++ and that any
860 // non-negative value is some version of Objective-C/C++.
861 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
863 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
864 DD->addAccelType(Ty.getName(), TyDIE, Flags);
866 if (!Context || isa<MDCompileUnit>(Context) || isa<MDFile>(Context) ||
867 isa<MDNamespace>(Context))
868 addGlobalType(Ty, TyDIE, Context);
872 /// addType - Add a new type attribute to the specified entity.
873 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
874 assert(Ty && "Trying to add a type that doesn't exist?");
876 // Check for pre-existence.
877 DIEEntry *Entry = getDIEEntry(Ty);
878 // If it exists then use the existing value.
880 addDIEEntry(Entity, Attribute, Entry);
885 DIE *Buffer = getOrCreateTypeDIE(Ty);
888 Entry = createDIEEntry(*Buffer);
889 insertDIEEntry(Ty, Entry);
890 addDIEEntry(Entity, Attribute, Entry);
893 /// getParentContextString - Walks the metadata parent chain in a language
894 /// specific manner (using the compile unit language) and returns
895 /// it as a string. This is done at the metadata level because DIEs may
896 /// not currently have been added to the parent context and walking the
897 /// DIEs looking for names is more expensive than walking the metadata.
898 std::string DwarfUnit::getParentContextString(DIScope Context) const {
902 // FIXME: Decide whether to implement this for non-C++ languages.
903 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
907 SmallVector<DIScope, 1> Parents;
908 while (!isa<MDCompileUnit>(Context)) {
909 Parents.push_back(Context);
910 if (Context.getContext())
911 Context = resolve(Context.getContext());
913 // Structure, etc types will have a NULL context if they're at the top
918 // Reverse iterate over our list to go from the outermost construct to the
920 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
924 StringRef Name = Ctx.getName();
925 if (Name.empty() && isa<MDNamespace>(Ctx))
926 Name = "(anonymous namespace)";
935 /// constructTypeDIE - Construct basic type die from DIBasicType.
936 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
937 // Get core information.
938 StringRef Name = BTy.getName();
939 // Add name if not anonymous or intermediate type.
941 addString(Buffer, dwarf::DW_AT_name, Name);
943 // An unspecified type only has a name attribute.
944 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
947 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
950 uint64_t Size = BTy.getSizeInBits() >> 3;
951 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
954 /// constructTypeDIE - Construct derived type die from DIDerivedType.
955 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
956 // Get core information.
957 StringRef Name = DTy.getName();
958 uint64_t Size = DTy.getSizeInBits() >> 3;
959 uint16_t Tag = Buffer.getTag();
961 // Map to main type, void will not have a type.
962 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
964 addType(Buffer, FromTy);
966 // Add name if not anonymous or intermediate type.
968 addString(Buffer, dwarf::DW_AT_name, Name);
970 // Add size if non-zero (derived types might be zero-sized.)
971 if (Size && Tag != dwarf::DW_TAG_pointer_type
972 && Tag != dwarf::DW_TAG_ptr_to_member_type)
973 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
975 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
976 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
977 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
978 // Add source line info if available and TyDesc is not a forward declaration.
979 if (!DTy.isForwardDecl())
980 addSourceLine(Buffer, DTy);
983 /// constructSubprogramArguments - Construct function argument DIEs.
984 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
985 for (unsigned i = 1, N = Args.size(); i < N; ++i) {
986 DIType Ty = resolve(Args[i]);
988 assert(i == N-1 && "Unspecified parameter must be the last argument");
989 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
991 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
993 if (Ty.isArtificial())
994 addFlag(Arg, dwarf::DW_AT_artificial);
999 /// constructTypeDIE - Construct type DIE from DICompositeType.
1000 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1001 // Add name if not anonymous or intermediate type.
1002 StringRef Name = CTy.getName();
1004 uint64_t Size = CTy.getSizeInBits() >> 3;
1005 uint16_t Tag = Buffer.getTag();
1008 case dwarf::DW_TAG_array_type:
1009 constructArrayTypeDIE(Buffer, CTy);
1011 case dwarf::DW_TAG_enumeration_type:
1012 constructEnumTypeDIE(Buffer, CTy);
1014 case dwarf::DW_TAG_subroutine_type: {
1015 // Add return type. A void return won't have a type.
1016 auto Elements = cast<MDSubroutineType>(CTy)->getTypeArray();
1017 if (Elements.size())
1018 if (MDType *RTy = resolve(DITypeRef(Elements[0u])))
1019 addType(Buffer, RTy);
1021 bool isPrototyped = true;
1022 if (Elements.size() == 2 && !DITypeRef(Elements[1u]))
1023 isPrototyped = false;
1025 constructSubprogramArguments(Buffer, Elements);
1027 // Add prototype flag if we're dealing with a C language and the
1028 // function has been prototyped.
1029 uint16_t Language = getLanguage();
1031 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1032 Language == dwarf::DW_LANG_ObjC))
1033 addFlag(Buffer, dwarf::DW_AT_prototyped);
1035 if (CTy.isLValueReference())
1036 addFlag(Buffer, dwarf::DW_AT_reference);
1038 if (CTy.isRValueReference())
1039 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1041 case dwarf::DW_TAG_structure_type:
1042 case dwarf::DW_TAG_union_type:
1043 case dwarf::DW_TAG_class_type: {
1044 // Add elements to structure type.
1045 DIArray Elements = CTy.getElements();
1046 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1047 DIDescriptor Element = Elements[i];
1050 if (auto *SP = dyn_cast<MDSubprogram>(Element))
1051 getOrCreateSubprogramDIE(SP);
1052 else if (DIDerivedType DDTy = dyn_cast<MDDerivedTypeBase>(Element)) {
1053 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1054 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1055 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1056 dwarf::DW_AT_friend);
1057 } else if (DDTy.isStaticMember()) {
1058 getOrCreateStaticMemberDIE(DDTy);
1060 constructMemberDIE(Buffer, DDTy);
1062 } else if (DIObjCProperty Property = dyn_cast<MDObjCProperty>(Element)) {
1063 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1064 StringRef PropertyName = Property.getObjCPropertyName();
1065 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1066 if (Property.getType())
1067 addType(ElemDie, Property.getType());
1068 addSourceLine(ElemDie, Property);
1069 StringRef GetterName = Property.getObjCPropertyGetterName();
1070 if (!GetterName.empty())
1071 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1072 StringRef SetterName = Property.getObjCPropertySetterName();
1073 if (!SetterName.empty())
1074 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1075 unsigned PropertyAttributes = 0;
1076 if (Property.isReadOnlyObjCProperty())
1077 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1078 if (Property.isReadWriteObjCProperty())
1079 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1080 if (Property.isAssignObjCProperty())
1081 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1082 if (Property.isRetainObjCProperty())
1083 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1084 if (Property.isCopyObjCProperty())
1085 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1086 if (Property.isNonAtomicObjCProperty())
1087 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1088 if (PropertyAttributes)
1089 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1090 PropertyAttributes);
1092 DIEEntry *Entry = getDIEEntry(Element);
1094 Entry = createDIEEntry(ElemDie);
1095 insertDIEEntry(Element, Entry);
1100 if (CTy.isAppleBlockExtension())
1101 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1103 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1104 // inside C++ composite types to point to the base class with the vtable.
1105 if (DICompositeType ContainingType =
1106 dyn_cast_or_null<MDCompositeType>(resolve(CTy.getContainingType())))
1107 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1108 *getOrCreateTypeDIE(ContainingType));
1110 if (CTy.isObjcClassComplete())
1111 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1113 // Add template parameters to a class, structure or union types.
1114 // FIXME: The support isn't in the metadata for this yet.
1115 if (Tag == dwarf::DW_TAG_class_type ||
1116 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1117 addTemplateParams(Buffer, CTy.getTemplateParams());
1125 // Add name if not anonymous or intermediate type.
1127 addString(Buffer, dwarf::DW_AT_name, Name);
1129 if (Tag == dwarf::DW_TAG_enumeration_type ||
1130 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1131 Tag == dwarf::DW_TAG_union_type) {
1132 // Add size if non-zero (derived types might be zero-sized.)
1133 // TODO: Do we care about size for enum forward declarations?
1135 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1136 else if (!CTy.isForwardDecl())
1137 // Add zero size if it is not a forward declaration.
1138 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1140 // If we're a forward decl, say so.
1141 if (CTy.isForwardDecl())
1142 addFlag(Buffer, dwarf::DW_AT_declaration);
1144 // Add source line info if available.
1145 if (!CTy.isForwardDecl())
1146 addSourceLine(Buffer, CTy);
1148 // No harm in adding the runtime language to the declaration.
1149 unsigned RLang = CTy.getRunTimeLang();
1151 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1156 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1157 /// DITemplateTypeParameter.
1158 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1159 DITemplateTypeParameter TP) {
1161 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1162 // Add the type if it exists, it could be void and therefore no type.
1164 addType(ParamDIE, resolve(TP.getType()));
1165 if (!TP.getName().empty())
1166 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1169 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1170 /// DITemplateValueParameter.
1172 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1173 DITemplateValueParameter VP) {
1174 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1176 // Add the type if there is one, template template and template parameter
1177 // packs will not have a type.
1178 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1179 addType(ParamDIE, resolve(VP.getType()));
1180 if (!VP.getName().empty())
1181 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1182 if (Metadata *Val = VP.getValue()) {
1183 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1184 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1185 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1186 // For declaration non-type template parameters (such as global values and
1188 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1189 addOpAddress(*Loc, Asm->getSymbol(GV));
1190 // Emit DW_OP_stack_value to use the address as the immediate value of the
1191 // parameter, rather than a pointer to it.
1192 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1193 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1194 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1195 assert(isa<MDString>(Val));
1196 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1197 cast<MDString>(Val)->getString());
1198 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1199 addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1204 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1205 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1206 // Construct the context before querying for the existence of the DIE in case
1207 // such construction creates the DIE.
1208 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1210 if (DIE *NDie = getDIE(NS))
1212 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1214 StringRef Name = NS.getName();
1216 addString(NDie, dwarf::DW_AT_name, NS.getName());
1218 Name = "(anonymous namespace)";
1219 DD->addAccelNamespace(Name, NDie);
1220 addGlobalName(Name, NDie, NS.getContext());
1221 addSourceLine(NDie, NS);
1225 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1226 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1227 // Construct the context before querying for the existence of the DIE in case
1228 // such construction creates the DIE (as is the case for member function
1231 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1233 if (DIE *SPDie = getDIE(SP))
1236 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1238 // Add subprogram definitions to the CU die directly.
1239 ContextDIE = &getUnitDie();
1240 // Build the decl now to ensure it precedes the definition.
1241 getOrCreateSubprogramDIE(SPDecl);
1245 // DW_TAG_inlined_subroutine may refer to this DIE.
1246 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1248 // Stop here and fill this in later, depending on whether or not this
1249 // subprogram turns out to have inlined instances or not.
1250 if (SP.isDefinition())
1253 applySubprogramAttributes(SP, SPDie);
1257 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1259 DIE *DeclDie = nullptr;
1260 StringRef DeclLinkageName;
1261 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1262 DeclDie = getDIE(SPDecl);
1263 assert(DeclDie && "This DIE should've already been constructed when the "
1264 "definition DIE was created in "
1265 "getOrCreateSubprogramDIE");
1266 DeclLinkageName = SPDecl.getLinkageName();
1269 // Add function template parameters.
1270 addTemplateParams(SPDie, SP.getTemplateParams());
1272 // Add the linkage name if we have one and it isn't in the Decl.
1273 StringRef LinkageName = SP.getLinkageName();
1274 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1275 LinkageName == DeclLinkageName) &&
1276 "decl has a linkage name and it is different");
1277 if (DeclLinkageName.empty())
1278 addLinkageName(SPDie, LinkageName);
1283 // Refer to the function declaration where all the other attributes will be
1285 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1289 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1292 if (applySubprogramDefinitionAttributes(SP, SPDie))
1295 // Constructors and operators for anonymous aggregates do not have names.
1296 if (!SP.getName().empty())
1297 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1299 // Skip the rest of the attributes under -gmlt to save space.
1303 addSourceLine(SPDie, SP);
1305 // Add the prototype if we have a prototype and we have a C like
1307 uint16_t Language = getLanguage();
1308 if (SP.isPrototyped() &&
1309 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1310 Language == dwarf::DW_LANG_ObjC))
1311 addFlag(SPDie, dwarf::DW_AT_prototyped);
1313 DISubroutineType SPTy = SP.getType();
1314 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1315 "the type of a subprogram should be a subroutine");
1317 auto Args = SPTy.getTypeArray();
1318 // Add a return type. If this is a type like a C/C++ void type we don't add a
1321 if (MDType *Ty = resolve(DITypeRef(Args[0u])))
1324 unsigned VK = SP.getVirtuality();
1326 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1327 DIELoc *Block = getDIELoc();
1328 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1329 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1330 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1331 ContainingTypeMap.insert(
1332 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1335 if (!SP.isDefinition()) {
1336 addFlag(SPDie, dwarf::DW_AT_declaration);
1338 // Add arguments. Do not add arguments for subprogram definition. They will
1339 // be handled while processing variables.
1340 constructSubprogramArguments(SPDie, Args);
1343 if (SP.isArtificial())
1344 addFlag(SPDie, dwarf::DW_AT_artificial);
1346 if (!SP.isLocalToUnit())
1347 addFlag(SPDie, dwarf::DW_AT_external);
1349 if (SP.isOptimized())
1350 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1352 if (unsigned isa = Asm->getISAEncoding())
1353 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1355 if (SP.isLValueReference())
1356 addFlag(SPDie, dwarf::DW_AT_reference);
1358 if (SP.isRValueReference())
1359 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1361 if (SP.isProtected())
1362 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1363 dwarf::DW_ACCESS_protected);
1364 else if (SP.isPrivate())
1365 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1366 dwarf::DW_ACCESS_private);
1367 else if (SP.isPublic())
1368 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1369 dwarf::DW_ACCESS_public);
1371 if (SP.isExplicit())
1372 addFlag(SPDie, dwarf::DW_AT_explicit);
1375 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1376 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1377 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1378 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1380 // The LowerBound value defines the lower bounds which is typically zero for
1381 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1382 // Count == -1 then the array is unbounded and we do not emit
1383 // DW_AT_lower_bound and DW_AT_count attributes.
1384 int64_t LowerBound = SR.getLo();
1385 int64_t DefaultLowerBound = getDefaultLowerBound();
1386 int64_t Count = SR.getCount();
1388 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1389 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1392 // FIXME: An unbounded array should reference the expression that defines
1394 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1397 DIE *DwarfUnit::getIndexTyDie() {
1400 // Construct an integer type to use for indexes.
1401 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1402 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1403 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1404 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1405 dwarf::DW_ATE_unsigned);
1409 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1410 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1412 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1414 // Emit the element type.
1415 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1417 // Get an anonymous type for index type.
1418 // FIXME: This type should be passed down from the front end
1419 // as different languages may have different sizes for indexes.
1420 DIE *IdxTy = getIndexTyDie();
1422 // Add subranges to array type.
1423 DIArray Elements = CTy.getElements();
1424 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1425 DIDescriptor Element = Elements[i];
1426 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1427 constructSubrangeDIE(Buffer, cast<MDSubrange>(Element), IdxTy);
1431 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1432 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1433 DIArray Elements = CTy.getElements();
1435 // Add enumerators to enumeration type.
1436 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1437 DIEnumerator Enum = dyn_cast_or_null<MDEnumerator>(Elements[i]);
1439 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1440 StringRef Name = Enum.getName();
1441 addString(Enumerator, dwarf::DW_AT_name, Name);
1442 int64_t Value = Enum.getEnumValue();
1443 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1447 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1449 addType(Buffer, DTy);
1450 addFlag(Buffer, dwarf::DW_AT_enum_class);
1454 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1456 void DwarfUnit::constructContainingTypeDIEs() {
1457 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1458 CE = ContainingTypeMap.end();
1460 DIE &SPDie = *CI->first;
1461 DIDescriptor D(CI->second);
1464 DIE *NDie = getDIE(D);
1467 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1471 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1472 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1473 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1474 StringRef Name = DT.getName();
1476 addString(MemberDie, dwarf::DW_AT_name, Name);
1478 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1480 addSourceLine(MemberDie, DT);
1482 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1484 // For C++, virtual base classes are not at fixed offset. Use following
1485 // expression to extract appropriate offset from vtable.
1486 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1488 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1489 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1490 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1491 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1492 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1493 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1494 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1495 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1497 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1499 uint64_t Size = DT.getSizeInBits();
1500 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1501 uint64_t OffsetInBytes;
1503 if (FieldSize && Size != FieldSize) {
1504 // Handle bitfield, assume bytes are 8 bits.
1505 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1506 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1508 uint64_t Offset = DT.getOffsetInBits();
1509 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1510 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1511 uint64_t FieldOffset = (HiMark - FieldSize);
1512 Offset -= FieldOffset;
1514 // Maybe we need to work from the other end.
1515 if (Asm->getDataLayout().isLittleEndian())
1516 Offset = FieldSize - (Offset + Size);
1517 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1519 // Here DW_AT_data_member_location points to the anonymous
1520 // field that includes this bit field.
1521 OffsetInBytes = FieldOffset >> 3;
1523 // This is not a bitfield.
1524 OffsetInBytes = DT.getOffsetInBits() >> 3;
1526 if (DD->getDwarfVersion() <= 2) {
1527 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1528 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1529 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1530 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1532 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1536 if (DT.isProtected())
1537 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1538 dwarf::DW_ACCESS_protected);
1539 else if (DT.isPrivate())
1540 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1541 dwarf::DW_ACCESS_private);
1542 // Otherwise C++ member and base classes are considered public.
1543 else if (DT.isPublic())
1544 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1545 dwarf::DW_ACCESS_public);
1547 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1548 dwarf::DW_VIRTUALITY_virtual);
1550 // Objective-C properties.
1551 if (MDNode *PNode = DT.getObjCProperty())
1552 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1553 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1556 if (DT.isArtificial())
1557 addFlag(MemberDie, dwarf::DW_AT_artificial);
1560 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1561 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1565 // Construct the context before querying for the existence of the DIE in case
1566 // such construction creates the DIE.
1567 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1568 assert(dwarf::isType(ContextDIE->getTag()) &&
1569 "Static member should belong to a type.");
1571 if (DIE *StaticMemberDIE = getDIE(DT))
1572 return StaticMemberDIE;
1574 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1576 DIType Ty = resolve(DT.getTypeDerivedFrom());
1578 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1579 addType(StaticMemberDIE, Ty);
1580 addSourceLine(StaticMemberDIE, DT);
1581 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1582 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1584 // FIXME: We could omit private if the parent is a class_type, and
1585 // public if the parent is something else.
1586 if (DT.isProtected())
1587 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1588 dwarf::DW_ACCESS_protected);
1589 else if (DT.isPrivate())
1590 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1591 dwarf::DW_ACCESS_private);
1592 else if (DT.isPublic())
1593 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1594 dwarf::DW_ACCESS_public);
1596 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1597 addConstantValue(StaticMemberDIE, CI, Ty);
1598 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1599 addConstantFPValue(StaticMemberDIE, CFP);
1601 return &StaticMemberDIE;
1604 void DwarfUnit::emitHeader(bool UseOffsets) {
1605 // Emit size of content not including length itself
1606 Asm->OutStreamer.AddComment("Length of Unit");
1607 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1609 Asm->OutStreamer.AddComment("DWARF version number");
1610 Asm->EmitInt16(DD->getDwarfVersion());
1611 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1613 // We share one abbreviations table across all units so it's always at the
1614 // start of the section. Use a relocatable offset where needed to ensure
1615 // linking doesn't invalidate that offset.
1616 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1618 Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1622 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1623 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1626 void DwarfUnit::initSection(const MCSection *Section) {
1627 assert(!this->Section);
1628 this->Section = Section;
1631 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1632 DwarfUnit::emitHeader(UseOffsets);
1633 Asm->OutStreamer.AddComment("Type Signature");
1634 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1635 Asm->OutStreamer.AddComment("Type DIE Offset");
1636 // In a skeleton type unit there is no type DIE so emit a zero offset.
1637 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1638 sizeof(Ty->getOffset()));
1641 bool DwarfTypeUnit::isDwoUnit() const {
1642 // Since there are no skeleton type units, all type units are dwo type units
1643 // when split DWARF is being used.
1644 return DD->useSplitDwarf();