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 (D.isType() ||
179 (D.isSubprogram() && !DISubprogram(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) {
400 assert(V.isVariable());
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) {
409 assert(G.isGlobalVariable());
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) {
417 assert(SP.isSubprogram());
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) {
433 assert(Ty.isObjCProperty());
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) {
445 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
448 /// addRegisterOp - Add register operand.
449 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
450 unsigned SizeInBits, unsigned OffsetInBits) {
451 DIEDwarfExpression Expr(*Asm, *this, TheDie);
452 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
456 /// addRegisterOffset - Add register offset.
457 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
459 DIEDwarfExpression Expr(*Asm, *this, TheDie);
460 return Expr.AddMachineRegIndirect(Reg, Offset);
463 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
464 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
465 gives the variable VarName either the struct, or a pointer to the struct, as
466 its type. This is necessary for various behind-the-scenes things the
467 compiler needs to do with by-reference variables in Blocks.
469 However, as far as the original *programmer* is concerned, the variable
470 should still have type 'SomeType', as originally declared.
472 The function getBlockByrefType dives into the __Block_byref_x_VarName
473 struct to find the original type of the variable, which is then assigned to
474 the variable's Debug Information Entry as its real type. So far, so good.
475 However now the debugger will expect the variable VarName to have the type
476 SomeType. So we need the location attribute for the variable to be an
477 expression that explains to the debugger how to navigate through the
478 pointers and struct to find the actual variable of type SomeType.
480 The following function does just that. We start by getting
481 the "normal" location for the variable. This will be the location
482 of either the struct __Block_byref_x_VarName or the pointer to the
483 struct __Block_byref_x_VarName.
485 The struct will look something like:
487 struct __Block_byref_x_VarName {
489 struct __Block_byref_x_VarName *forwarding;
490 ... <various other fields>
492 ... <maybe more fields>
495 If we are given the struct directly (as our starting point) we
496 need to tell the debugger to:
498 1). Add the offset of the forwarding field.
500 2). Follow that pointer to get the real __Block_byref_x_VarName
501 struct to use (the real one may have been copied onto the heap).
503 3). Add the offset for the field VarName, to find the actual variable.
505 If we started with a pointer to the struct, then we need to
506 dereference that pointer first, before the other steps.
507 Translating this into DWARF ops, we will need to append the following
508 to the current location description for the variable:
510 DW_OP_deref -- optional, if we start with a pointer
511 DW_OP_plus_uconst <forward_fld_offset>
513 DW_OP_plus_uconst <varName_fld_offset>
515 That is what this function does. */
517 /// addBlockByrefAddress - Start with the address based on the location
518 /// provided, and generate the DWARF information necessary to find the
519 /// actual Block variable (navigating the Block struct) based on the
520 /// starting location. Add the DWARF information to the die. For
521 /// more information, read large comment just above here.
523 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
524 dwarf::Attribute Attribute,
525 const MachineLocation &Location) {
526 DIType Ty = DV.getType();
528 uint16_t Tag = Ty.getTag();
529 bool isPointer = false;
531 StringRef varName = DV.getName();
533 if (Tag == dwarf::DW_TAG_pointer_type) {
534 DIDerivedType DTy(Ty);
535 TmpTy = resolve(DTy.getTypeDerivedFrom());
539 DICompositeType blockStruct(TmpTy);
541 // Find the __forwarding field and the variable field in the __Block_byref
543 DIArray Fields = blockStruct.getElements();
544 DIDerivedType varField;
545 DIDerivedType forwardingField;
547 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
548 DIDerivedType DT(Fields.getElement(i));
549 StringRef fieldName = DT.getName();
550 if (fieldName == "__forwarding")
551 forwardingField = DT;
552 else if (fieldName == varName)
556 // Get the offsets for the forwarding field and the variable field.
557 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
558 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
560 // Decode the original location, and use that as the start of the byref
561 // variable's location.
562 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
565 if (Location.isReg())
566 validReg = addRegisterOpPiece(*Loc, Location.getReg());
568 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
573 // If we started with a pointer to the __Block_byref... struct, then
574 // the first thing we need to do is dereference the pointer (DW_OP_deref).
576 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
578 // Next add the offset for the '__forwarding' field:
579 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
580 // adding the offset if it's 0.
581 if (forwardingFieldOffset > 0) {
582 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
583 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
586 // Now dereference the __forwarding field to get to the real __Block_byref
587 // struct: DW_OP_deref.
588 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
590 // Now that we've got the real __Block_byref... struct, add the offset
591 // for the variable's field to get to the location of the actual variable:
592 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
593 if (varFieldOffset > 0) {
594 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
595 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
598 // Now attach the location information to the DIE.
599 addBlock(Die, Attribute, Loc);
602 /// Return true if type encoding is unsigned.
603 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
604 DIDerivedType DTy(Ty);
605 if (DTy.isDerivedType()) {
606 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
607 // Encode pointer constants as unsigned bytes. This is used at least for
608 // null pointer constant emission.
609 // (Pieces of) aggregate types that get hacked apart by SROA may also be
610 // represented by a constant. Encode them as unsigned bytes.
611 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
612 // here, but accept them for now due to a bug in SROA producing bogus
614 if (T == dwarf::DW_TAG_array_type ||
615 T == dwarf::DW_TAG_class_type ||
616 T == dwarf::DW_TAG_pointer_type ||
617 T == dwarf::DW_TAG_ptr_to_member_type ||
618 T == dwarf::DW_TAG_reference_type ||
619 T == dwarf::DW_TAG_rvalue_reference_type ||
620 T == dwarf::DW_TAG_structure_type ||
621 T == dwarf::DW_TAG_union_type)
623 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
624 T == dwarf::DW_TAG_volatile_type ||
625 T == dwarf::DW_TAG_restrict_type ||
626 T == dwarf::DW_TAG_enumeration_type);
627 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
628 return isUnsignedDIType(DD, DD->resolve(Deriv));
629 // FIXME: Enums without a fixed underlying type have unknown signedness
630 // here, leading to incorrectly emitted constants.
631 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
636 assert(BTy.isBasicType());
637 unsigned Encoding = BTy.getEncoding();
638 assert((Encoding == dwarf::DW_ATE_unsigned ||
639 Encoding == dwarf::DW_ATE_unsigned_char ||
640 Encoding == dwarf::DW_ATE_signed ||
641 Encoding == dwarf::DW_ATE_signed_char ||
642 Encoding == dwarf::DW_ATE_float ||
643 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
644 (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
645 Ty.getName() == "decltype(nullptr)")) &&
646 "Unsupported encoding");
647 return (Encoding == dwarf::DW_ATE_unsigned ||
648 Encoding == dwarf::DW_ATE_unsigned_char ||
649 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
650 Ty.getTag() == dwarf::DW_TAG_unspecified_type);
653 /// If this type is derived from a base type then return base type size.
654 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
655 unsigned Tag = Ty.getTag();
657 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
658 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
659 Tag != dwarf::DW_TAG_restrict_type)
660 return Ty.getSizeInBits();
662 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
664 assert(BaseType.isValid() && "Unexpected invalid base type");
666 // If this is a derived type, go ahead and get the base type, unless it's a
667 // reference then it's just the size of the field. Pointer types have no need
668 // of this since they're a different type of qualification on the type.
669 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
670 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
671 return Ty.getSizeInBits();
673 if (BaseType.isDerivedType())
674 return getBaseTypeSize(DD, DIDerivedType(BaseType));
676 return BaseType.getSizeInBits();
679 /// addConstantFPValue - Add constant value entry in variable DIE.
680 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
681 assert(MO.isFPImm() && "Invalid machine operand!");
682 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
683 APFloat FPImm = MO.getFPImm()->getValueAPF();
685 // Get the raw data form of the floating point.
686 const APInt FltVal = FPImm.bitcastToAPInt();
687 const char *FltPtr = (const char *)FltVal.getRawData();
689 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
690 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
691 int Incr = (LittleEndian ? 1 : -1);
692 int Start = (LittleEndian ? 0 : NumBytes - 1);
693 int Stop = (LittleEndian ? NumBytes : -1);
695 // Output the constant to DWARF one byte at a time.
696 for (; Start != Stop; Start += Incr)
697 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
699 addBlock(Die, dwarf::DW_AT_const_value, Block);
702 /// addConstantFPValue - Add constant value entry in variable DIE.
703 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
704 // Pass this down to addConstantValue as an unsigned bag of bits.
705 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
708 /// addConstantValue - Add constant value entry in variable DIE.
709 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
710 addConstantValue(Die, CI->getValue(), Ty);
713 /// addConstantValue - Add constant value entry in variable DIE.
714 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
716 assert(MO.isImm() && "Invalid machine operand!");
718 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
721 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
722 // FIXME: This is a bit conservative/simple - it emits negative values always
723 // sign extended to 64 bits rather than minimizing the number of bytes.
724 addUInt(Die, dwarf::DW_AT_const_value,
725 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
728 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
729 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
732 // addConstantValue - Add constant value entry in variable DIE.
733 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
734 unsigned CIBitWidth = Val.getBitWidth();
735 if (CIBitWidth <= 64) {
736 addConstantValue(Die, Unsigned,
737 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
741 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
743 // Get the raw data form of the large APInt.
744 const uint64_t *Ptr64 = Val.getRawData();
746 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
747 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
749 // Output the constant to DWARF one byte at a time.
750 for (int i = 0; i < NumBytes; i++) {
753 c = Ptr64[i / 8] >> (8 * (i & 7));
755 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
756 addUInt(*Block, dwarf::DW_FORM_data1, c);
759 addBlock(Die, dwarf::DW_AT_const_value, Block);
762 // Add a linkage name to the DIE.
763 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
764 if (!LinkageName.empty())
766 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
767 : dwarf::DW_AT_MIPS_linkage_name,
768 GlobalValue::getRealLinkageName(LinkageName));
771 /// addTemplateParams - Add template parameters into buffer.
772 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
773 // Add template parameters.
774 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
775 DIDescriptor Element = TParams.getElement(i);
776 if (Element.isTemplateTypeParameter())
777 constructTemplateTypeParameterDIE(Buffer,
778 DITemplateTypeParameter(Element));
779 else if (Element.isTemplateValueParameter())
780 constructTemplateValueParameterDIE(Buffer,
781 DITemplateValueParameter(Element));
785 /// getOrCreateContextDIE - Get context owner's DIE.
786 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
787 if (!Context || Context.isFile())
788 return &getUnitDie();
789 if (Context.isType())
790 return getOrCreateTypeDIE(DIType(Context));
791 if (Context.isNameSpace())
792 return getOrCreateNameSpace(DINameSpace(Context));
793 if (Context.isSubprogram())
794 return getOrCreateSubprogramDIE(DISubprogram(Context));
795 return getDIE(Context);
798 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
799 DIScope Context = resolve(Ty.getContext());
800 DIE *ContextDIE = getOrCreateContextDIE(Context);
802 if (DIE *TyDIE = getDIE(Ty))
806 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
808 constructTypeDIE(TyDIE, Ty);
810 updateAcceleratorTables(Context, Ty, TyDIE);
814 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
816 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
822 assert(Ty == resolve(Ty.getRef()) &&
823 "type was not uniqued, possible ODR violation.");
825 // DW_TAG_restrict_type is not supported in DWARF2
826 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
827 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
829 // Construct the context before querying for the existence of the DIE in case
830 // such construction creates the DIE.
831 DIScope Context = resolve(Ty.getContext());
832 DIE *ContextDIE = getOrCreateContextDIE(Context);
835 if (DIE *TyDIE = getDIE(Ty))
839 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
841 updateAcceleratorTables(Context, Ty, TyDIE);
843 if (Ty.isBasicType())
844 constructTypeDIE(TyDIE, DIBasicType(Ty));
845 else if (Ty.isCompositeType()) {
846 DICompositeType CTy(Ty);
847 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
848 if (MDString *TypeId = CTy.getIdentifier()) {
849 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
850 // Skip updating the accelerator tables since this is not the full type.
853 constructTypeDIE(TyDIE, CTy);
855 assert(Ty.isDerivedType() && "Unknown kind of DIType");
856 constructTypeDIE(TyDIE, DIDerivedType(Ty));
862 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
864 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
865 bool IsImplementation = 0;
866 if (Ty.isCompositeType()) {
867 DICompositeType CT(Ty);
868 // A runtime language of 0 actually means C/C++ and that any
869 // non-negative value is some version of Objective-C/C++.
870 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
872 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
873 DD->addAccelType(Ty.getName(), TyDIE, Flags);
875 if (!Context || Context.isCompileUnit() || Context.isFile() ||
876 Context.isNameSpace())
877 addGlobalType(Ty, TyDIE, Context);
881 /// addType - Add a new type attribute to the specified entity.
882 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
883 assert(Ty && "Trying to add a type that doesn't exist?");
885 // Check for pre-existence.
886 DIEEntry *Entry = getDIEEntry(Ty);
887 // If it exists then use the existing value.
889 addDIEEntry(Entity, Attribute, Entry);
894 DIE *Buffer = getOrCreateTypeDIE(Ty);
897 Entry = createDIEEntry(*Buffer);
898 insertDIEEntry(Ty, Entry);
899 addDIEEntry(Entity, Attribute, Entry);
902 /// getParentContextString - Walks the metadata parent chain in a language
903 /// specific manner (using the compile unit language) and returns
904 /// it as a string. This is done at the metadata level because DIEs may
905 /// not currently have been added to the parent context and walking the
906 /// DIEs looking for names is more expensive than walking the metadata.
907 std::string DwarfUnit::getParentContextString(DIScope Context) const {
911 // FIXME: Decide whether to implement this for non-C++ languages.
912 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
916 SmallVector<DIScope, 1> Parents;
917 while (!Context.isCompileUnit()) {
918 Parents.push_back(Context);
919 if (Context.getContext())
920 Context = resolve(Context.getContext());
922 // Structure, etc types will have a NULL context if they're at the top
927 // Reverse iterate over our list to go from the outermost construct to the
929 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
933 StringRef Name = Ctx.getName();
934 if (Name.empty() && Ctx.isNameSpace())
935 Name = "(anonymous namespace)";
944 /// constructTypeDIE - Construct basic type die from DIBasicType.
945 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
946 // Get core information.
947 StringRef Name = BTy.getName();
948 // Add name if not anonymous or intermediate type.
950 addString(Buffer, dwarf::DW_AT_name, Name);
952 // An unspecified type only has a name attribute.
953 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
956 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
959 uint64_t Size = BTy.getSizeInBits() >> 3;
960 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
963 /// constructTypeDIE - Construct derived type die from DIDerivedType.
964 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
965 // Get core information.
966 StringRef Name = DTy.getName();
967 uint64_t Size = DTy.getSizeInBits() >> 3;
968 uint16_t Tag = Buffer.getTag();
970 // Map to main type, void will not have a type.
971 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
973 addType(Buffer, FromTy);
975 // Add name if not anonymous or intermediate type.
977 addString(Buffer, dwarf::DW_AT_name, Name);
979 // Add size if non-zero (derived types might be zero-sized.)
980 if (Size && Tag != dwarf::DW_TAG_pointer_type
981 && Tag != dwarf::DW_TAG_ptr_to_member_type)
982 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
984 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
985 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
986 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
987 // Add source line info if available and TyDesc is not a forward declaration.
988 if (!DTy.isForwardDecl())
989 addSourceLine(Buffer, DTy);
992 /// constructSubprogramArguments - Construct function argument DIEs.
993 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
994 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
995 DIType Ty = resolve(Args.getElement(i));
997 assert(i == N-1 && "Unspecified parameter must be the last argument");
998 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1000 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1002 if (Ty.isArtificial())
1003 addFlag(Arg, dwarf::DW_AT_artificial);
1008 /// constructTypeDIE - Construct type DIE from DICompositeType.
1009 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1010 // Add name if not anonymous or intermediate type.
1011 StringRef Name = CTy.getName();
1013 uint64_t Size = CTy.getSizeInBits() >> 3;
1014 uint16_t Tag = Buffer.getTag();
1017 case dwarf::DW_TAG_array_type:
1018 constructArrayTypeDIE(Buffer, CTy);
1020 case dwarf::DW_TAG_enumeration_type:
1021 constructEnumTypeDIE(Buffer, CTy);
1023 case dwarf::DW_TAG_subroutine_type: {
1024 // Add return type. A void return won't have a type.
1025 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1026 DIType RTy(resolve(Elements.getElement(0)));
1028 addType(Buffer, RTy);
1030 bool isPrototyped = true;
1031 if (Elements.getNumElements() == 2 &&
1032 !Elements.getElement(1))
1033 isPrototyped = false;
1035 constructSubprogramArguments(Buffer, Elements);
1037 // Add prototype flag if we're dealing with a C language and the
1038 // function has been prototyped.
1039 uint16_t Language = getLanguage();
1041 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1042 Language == dwarf::DW_LANG_ObjC))
1043 addFlag(Buffer, dwarf::DW_AT_prototyped);
1045 if (CTy.isLValueReference())
1046 addFlag(Buffer, dwarf::DW_AT_reference);
1048 if (CTy.isRValueReference())
1049 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1051 case dwarf::DW_TAG_structure_type:
1052 case dwarf::DW_TAG_union_type:
1053 case dwarf::DW_TAG_class_type: {
1054 // Add elements to structure type.
1055 DIArray Elements = CTy.getElements();
1056 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1057 DIDescriptor Element = Elements.getElement(i);
1058 if (Element.isSubprogram())
1059 getOrCreateSubprogramDIE(DISubprogram(Element));
1060 else if (Element.isDerivedType()) {
1061 DIDerivedType DDTy(Element);
1062 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1063 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1064 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1065 dwarf::DW_AT_friend);
1066 } else if (DDTy.isStaticMember()) {
1067 getOrCreateStaticMemberDIE(DDTy);
1069 constructMemberDIE(Buffer, DDTy);
1071 } else if (Element.isObjCProperty()) {
1072 DIObjCProperty Property(Element);
1073 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1074 StringRef PropertyName = Property.getObjCPropertyName();
1075 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1076 if (Property.getType())
1077 addType(ElemDie, Property.getType());
1078 addSourceLine(ElemDie, Property);
1079 StringRef GetterName = Property.getObjCPropertyGetterName();
1080 if (!GetterName.empty())
1081 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1082 StringRef SetterName = Property.getObjCPropertySetterName();
1083 if (!SetterName.empty())
1084 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1085 unsigned PropertyAttributes = 0;
1086 if (Property.isReadOnlyObjCProperty())
1087 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1088 if (Property.isReadWriteObjCProperty())
1089 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1090 if (Property.isAssignObjCProperty())
1091 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1092 if (Property.isRetainObjCProperty())
1093 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1094 if (Property.isCopyObjCProperty())
1095 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1096 if (Property.isNonAtomicObjCProperty())
1097 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1098 if (PropertyAttributes)
1099 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1100 PropertyAttributes);
1102 DIEEntry *Entry = getDIEEntry(Element);
1104 Entry = createDIEEntry(ElemDie);
1105 insertDIEEntry(Element, Entry);
1111 if (CTy.isAppleBlockExtension())
1112 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1114 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1115 // inside C++ composite types to point to the base class with the vtable.
1116 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1118 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1119 *getOrCreateTypeDIE(ContainingType));
1121 if (CTy.isObjcClassComplete())
1122 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1124 // Add template parameters to a class, structure or union types.
1125 // FIXME: The support isn't in the metadata for this yet.
1126 if (Tag == dwarf::DW_TAG_class_type ||
1127 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1128 addTemplateParams(Buffer, CTy.getTemplateParams());
1136 // Add name if not anonymous or intermediate type.
1138 addString(Buffer, dwarf::DW_AT_name, Name);
1140 if (Tag == dwarf::DW_TAG_enumeration_type ||
1141 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1142 Tag == dwarf::DW_TAG_union_type) {
1143 // Add size if non-zero (derived types might be zero-sized.)
1144 // TODO: Do we care about size for enum forward declarations?
1146 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1147 else if (!CTy.isForwardDecl())
1148 // Add zero size if it is not a forward declaration.
1149 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1151 // If we're a forward decl, say so.
1152 if (CTy.isForwardDecl())
1153 addFlag(Buffer, dwarf::DW_AT_declaration);
1155 // Add source line info if available.
1156 if (!CTy.isForwardDecl())
1157 addSourceLine(Buffer, CTy);
1159 // No harm in adding the runtime language to the declaration.
1160 unsigned RLang = CTy.getRunTimeLang();
1162 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1167 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1168 /// DITemplateTypeParameter.
1169 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1170 DITemplateTypeParameter TP) {
1172 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1173 // Add the type if it exists, it could be void and therefore no type.
1175 addType(ParamDIE, resolve(TP.getType()));
1176 if (!TP.getName().empty())
1177 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1180 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1181 /// DITemplateValueParameter.
1183 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1184 DITemplateValueParameter VP) {
1185 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1187 // Add the type if there is one, template template and template parameter
1188 // packs will not have a type.
1189 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1190 addType(ParamDIE, resolve(VP.getType()));
1191 if (!VP.getName().empty())
1192 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1193 if (Metadata *Val = VP.getValue()) {
1194 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1195 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1196 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1197 // For declaration non-type template parameters (such as global values and
1199 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1200 addOpAddress(*Loc, Asm->getSymbol(GV));
1201 // Emit DW_OP_stack_value to use the address as the immediate value of the
1202 // parameter, rather than a pointer to it.
1203 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1204 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1205 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1206 assert(isa<MDString>(Val));
1207 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1208 cast<MDString>(Val)->getString());
1209 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1210 assert(isa<MDNode>(Val));
1211 DIArray A(cast<MDNode>(Val));
1212 addTemplateParams(ParamDIE, A);
1217 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1218 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1219 // Construct the context before querying for the existence of the DIE in case
1220 // such construction creates the DIE.
1221 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1223 if (DIE *NDie = getDIE(NS))
1225 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1227 StringRef Name = NS.getName();
1229 addString(NDie, dwarf::DW_AT_name, NS.getName());
1231 Name = "(anonymous namespace)";
1232 DD->addAccelNamespace(Name, NDie);
1233 addGlobalName(Name, NDie, NS.getContext());
1234 addSourceLine(NDie, NS);
1238 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1239 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1240 // Construct the context before querying for the existence of the DIE in case
1241 // such construction creates the DIE (as is the case for member function
1244 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1246 if (DIE *SPDie = getDIE(SP))
1249 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1251 // Add subprogram definitions to the CU die directly.
1252 ContextDIE = &getUnitDie();
1253 // Build the decl now to ensure it precedes the definition.
1254 getOrCreateSubprogramDIE(SPDecl);
1258 // DW_TAG_inlined_subroutine may refer to this DIE.
1259 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1261 // Stop here and fill this in later, depending on whether or not this
1262 // subprogram turns out to have inlined instances or not.
1263 if (SP.isDefinition())
1266 applySubprogramAttributes(SP, SPDie);
1270 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1272 DIE *DeclDie = nullptr;
1273 StringRef DeclLinkageName;
1274 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1275 DeclDie = getDIE(SPDecl);
1276 assert(DeclDie && "This DIE should've already been constructed when the "
1277 "definition DIE was created in "
1278 "getOrCreateSubprogramDIE");
1279 DeclLinkageName = SPDecl.getLinkageName();
1282 // Add function template parameters.
1283 addTemplateParams(SPDie, SP.getTemplateParams());
1285 // Add the linkage name if we have one and it isn't in the Decl.
1286 StringRef LinkageName = SP.getLinkageName();
1287 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1288 LinkageName == DeclLinkageName) &&
1289 "decl has a linkage name and it is different");
1290 if (DeclLinkageName.empty())
1291 addLinkageName(SPDie, LinkageName);
1296 // Refer to the function declaration where all the other attributes will be
1298 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1302 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1305 if (applySubprogramDefinitionAttributes(SP, SPDie))
1308 // Constructors and operators for anonymous aggregates do not have names.
1309 if (!SP.getName().empty())
1310 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1312 // Skip the rest of the attributes under -gmlt to save space.
1316 addSourceLine(SPDie, SP);
1318 // Add the prototype if we have a prototype and we have a C like
1320 uint16_t Language = getLanguage();
1321 if (SP.isPrototyped() &&
1322 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1323 Language == dwarf::DW_LANG_ObjC))
1324 addFlag(SPDie, dwarf::DW_AT_prototyped);
1326 DISubroutineType SPTy = SP.getType();
1327 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1328 "the type of a subprogram should be a subroutine");
1330 DITypeArray Args = SPTy.getTypeArray();
1331 // Add a return type. If this is a type like a C/C++ void type we don't add a
1333 if (resolve(Args.getElement(0)))
1334 addType(SPDie, DIType(resolve(Args.getElement(0))));
1336 unsigned VK = SP.getVirtuality();
1338 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1339 DIELoc *Block = getDIELoc();
1340 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1341 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1342 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1343 ContainingTypeMap.insert(
1344 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1347 if (!SP.isDefinition()) {
1348 addFlag(SPDie, dwarf::DW_AT_declaration);
1350 // Add arguments. Do not add arguments for subprogram definition. They will
1351 // be handled while processing variables.
1352 constructSubprogramArguments(SPDie, Args);
1355 if (SP.isArtificial())
1356 addFlag(SPDie, dwarf::DW_AT_artificial);
1358 if (!SP.isLocalToUnit())
1359 addFlag(SPDie, dwarf::DW_AT_external);
1361 if (SP.isOptimized())
1362 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1364 if (unsigned isa = Asm->getISAEncoding())
1365 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1367 if (SP.isLValueReference())
1368 addFlag(SPDie, dwarf::DW_AT_reference);
1370 if (SP.isRValueReference())
1371 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1373 if (SP.isProtected())
1374 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1375 dwarf::DW_ACCESS_protected);
1376 else if (SP.isPrivate())
1377 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1378 dwarf::DW_ACCESS_private);
1379 else if (SP.isPublic())
1380 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1381 dwarf::DW_ACCESS_public);
1383 if (SP.isExplicit())
1384 addFlag(SPDie, dwarf::DW_AT_explicit);
1387 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1388 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1389 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1390 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1392 // The LowerBound value defines the lower bounds which is typically zero for
1393 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1394 // Count == -1 then the array is unbounded and we do not emit
1395 // DW_AT_lower_bound and DW_AT_count attributes.
1396 int64_t LowerBound = SR.getLo();
1397 int64_t DefaultLowerBound = getDefaultLowerBound();
1398 int64_t Count = SR.getCount();
1400 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1401 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1404 // FIXME: An unbounded array should reference the expression that defines
1406 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1409 DIE *DwarfUnit::getIndexTyDie() {
1412 // Construct an integer type to use for indexes.
1413 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1414 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1415 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1416 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1417 dwarf::DW_ATE_unsigned);
1421 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1422 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1424 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1426 // Emit the element type.
1427 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1429 // Get an anonymous type for index type.
1430 // FIXME: This type should be passed down from the front end
1431 // as different languages may have different sizes for indexes.
1432 DIE *IdxTy = getIndexTyDie();
1434 // Add subranges to array type.
1435 DIArray Elements = CTy.getElements();
1436 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1437 DIDescriptor Element = Elements.getElement(i);
1438 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1439 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1443 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1444 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1445 DIArray Elements = CTy.getElements();
1447 // Add enumerators to enumeration type.
1448 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1449 DIEnumerator Enum(Elements.getElement(i));
1450 if (Enum.isEnumerator()) {
1451 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1452 StringRef Name = Enum.getName();
1453 addString(Enumerator, dwarf::DW_AT_name, Name);
1454 int64_t Value = Enum.getEnumValue();
1455 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1459 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1461 addType(Buffer, DTy);
1462 addFlag(Buffer, dwarf::DW_AT_enum_class);
1466 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1468 void DwarfUnit::constructContainingTypeDIEs() {
1469 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1470 CE = ContainingTypeMap.end();
1472 DIE &SPDie = *CI->first;
1473 DIDescriptor D(CI->second);
1476 DIE *NDie = getDIE(D);
1479 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1483 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1484 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1485 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1486 StringRef Name = DT.getName();
1488 addString(MemberDie, dwarf::DW_AT_name, Name);
1490 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1492 addSourceLine(MemberDie, DT);
1494 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1496 // For C++, virtual base classes are not at fixed offset. Use following
1497 // expression to extract appropriate offset from vtable.
1498 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1500 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1501 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1502 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1503 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1504 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1505 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1506 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1507 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1509 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1511 uint64_t Size = DT.getSizeInBits();
1512 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1513 uint64_t OffsetInBytes;
1515 if (FieldSize && Size != FieldSize) {
1516 // Handle bitfield, assume bytes are 8 bits.
1517 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1518 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1520 uint64_t Offset = DT.getOffsetInBits();
1521 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1522 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1523 uint64_t FieldOffset = (HiMark - FieldSize);
1524 Offset -= FieldOffset;
1526 // Maybe we need to work from the other end.
1527 if (Asm->getDataLayout().isLittleEndian())
1528 Offset = FieldSize - (Offset + Size);
1529 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1531 // Here DW_AT_data_member_location points to the anonymous
1532 // field that includes this bit field.
1533 OffsetInBytes = FieldOffset >> 3;
1535 // This is not a bitfield.
1536 OffsetInBytes = DT.getOffsetInBits() >> 3;
1538 if (DD->getDwarfVersion() <= 2) {
1539 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1540 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1541 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1542 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1544 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1548 if (DT.isProtected())
1549 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1550 dwarf::DW_ACCESS_protected);
1551 else if (DT.isPrivate())
1552 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1553 dwarf::DW_ACCESS_private);
1554 // Otherwise C++ member and base classes are considered public.
1555 else if (DT.isPublic())
1556 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1557 dwarf::DW_ACCESS_public);
1559 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1560 dwarf::DW_VIRTUALITY_virtual);
1562 // Objective-C properties.
1563 if (MDNode *PNode = DT.getObjCProperty())
1564 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1565 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1568 if (DT.isArtificial())
1569 addFlag(MemberDie, dwarf::DW_AT_artificial);
1572 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1573 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1577 // Construct the context before querying for the existence of the DIE in case
1578 // such construction creates the DIE.
1579 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1580 assert(dwarf::isType(ContextDIE->getTag()) &&
1581 "Static member should belong to a type.");
1583 if (DIE *StaticMemberDIE = getDIE(DT))
1584 return StaticMemberDIE;
1586 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1588 DIType Ty = resolve(DT.getTypeDerivedFrom());
1590 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1591 addType(StaticMemberDIE, Ty);
1592 addSourceLine(StaticMemberDIE, DT);
1593 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1594 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1596 // FIXME: We could omit private if the parent is a class_type, and
1597 // public if the parent is something else.
1598 if (DT.isProtected())
1599 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1600 dwarf::DW_ACCESS_protected);
1601 else if (DT.isPrivate())
1602 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1603 dwarf::DW_ACCESS_private);
1604 else if (DT.isPublic())
1605 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1606 dwarf::DW_ACCESS_public);
1608 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1609 addConstantValue(StaticMemberDIE, CI, Ty);
1610 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1611 addConstantFPValue(StaticMemberDIE, CFP);
1613 return &StaticMemberDIE;
1616 void DwarfUnit::emitHeader(bool UseOffsets) {
1617 // Emit size of content not including length itself
1618 Asm->OutStreamer.AddComment("Length of Unit");
1619 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1621 Asm->OutStreamer.AddComment("DWARF version number");
1622 Asm->EmitInt16(DD->getDwarfVersion());
1623 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1625 // We share one abbreviations table across all units so it's always at the
1626 // start of the section. Use a relocatable offset where needed to ensure
1627 // linking doesn't invalidate that offset.
1628 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1630 Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1634 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1635 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1638 void DwarfUnit::initSection(const MCSection *Section) {
1639 assert(!this->Section);
1640 this->Section = Section;
1643 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1644 DwarfUnit::emitHeader(UseOffsets);
1645 Asm->OutStreamer.AddComment("Type Signature");
1646 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1647 Asm->OutStreamer.AddComment("Type DIE Offset");
1648 // In a skeleton type unit there is no type DIE so emit a zero offset.
1649 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1650 sizeof(Ty->getOffset()));
1653 bool DwarfTypeUnit::isDwoUnit() const {
1654 // Since there are no skeleton type units, all type units are dwo type units
1655 // when split DWARF is being used.
1656 return DD->useSplitDwarf();