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 /// addTemplateParams - Add template parameters into buffer.
763 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
764 // Add template parameters.
765 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
766 DIDescriptor Element = TParams.getElement(i);
767 if (Element.isTemplateTypeParameter())
768 constructTemplateTypeParameterDIE(Buffer,
769 DITemplateTypeParameter(Element));
770 else if (Element.isTemplateValueParameter())
771 constructTemplateValueParameterDIE(Buffer,
772 DITemplateValueParameter(Element));
776 /// getOrCreateContextDIE - Get context owner's DIE.
777 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
778 if (!Context || Context.isFile())
779 return &getUnitDie();
780 if (Context.isType())
781 return getOrCreateTypeDIE(DIType(Context));
782 if (Context.isNameSpace())
783 return getOrCreateNameSpace(DINameSpace(Context));
784 if (Context.isSubprogram())
785 return getOrCreateSubprogramDIE(DISubprogram(Context));
786 return getDIE(Context);
789 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
790 DIScope Context = resolve(Ty.getContext());
791 DIE *ContextDIE = getOrCreateContextDIE(Context);
793 if (DIE *TyDIE = getDIE(Ty))
797 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
799 constructTypeDIE(TyDIE, Ty);
801 updateAcceleratorTables(Context, Ty, TyDIE);
805 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
807 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
813 assert(Ty == resolve(Ty.getRef()) &&
814 "type was not uniqued, possible ODR violation.");
816 // DW_TAG_restrict_type is not supported in DWARF2
817 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
818 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
820 // Construct the context before querying for the existence of the DIE in case
821 // such construction creates the DIE.
822 DIScope Context = resolve(Ty.getContext());
823 DIE *ContextDIE = getOrCreateContextDIE(Context);
826 if (DIE *TyDIE = getDIE(Ty))
830 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
832 updateAcceleratorTables(Context, Ty, TyDIE);
834 if (Ty.isBasicType())
835 constructTypeDIE(TyDIE, DIBasicType(Ty));
836 else if (Ty.isCompositeType()) {
837 DICompositeType CTy(Ty);
838 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
839 if (MDString *TypeId = CTy.getIdentifier()) {
840 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
841 // Skip updating the accelerator tables since this is not the full type.
844 constructTypeDIE(TyDIE, CTy);
846 assert(Ty.isDerivedType() && "Unknown kind of DIType");
847 constructTypeDIE(TyDIE, DIDerivedType(Ty));
853 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
855 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
856 bool IsImplementation = 0;
857 if (Ty.isCompositeType()) {
858 DICompositeType CT(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 || Context.isCompileUnit() || Context.isFile() ||
867 Context.isNameSpace())
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 (!Context.isCompileUnit()) {
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() && Ctx.isNameSpace())
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.getNumElements(); i < N; ++i) {
986 DIType Ty = resolve(Args.getElement(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 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1017 DIType RTy(resolve(Elements.getElement(0)));
1019 addType(Buffer, RTy);
1021 bool isPrototyped = true;
1022 if (Elements.getNumElements() == 2 &&
1023 !Elements.getElement(1))
1024 isPrototyped = false;
1026 constructSubprogramArguments(Buffer, Elements);
1028 // Add prototype flag if we're dealing with a C language and the
1029 // function has been prototyped.
1030 uint16_t Language = getLanguage();
1032 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1033 Language == dwarf::DW_LANG_ObjC))
1034 addFlag(Buffer, dwarf::DW_AT_prototyped);
1036 if (CTy.isLValueReference())
1037 addFlag(Buffer, dwarf::DW_AT_reference);
1039 if (CTy.isRValueReference())
1040 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1042 case dwarf::DW_TAG_structure_type:
1043 case dwarf::DW_TAG_union_type:
1044 case dwarf::DW_TAG_class_type: {
1045 // Add elements to structure type.
1046 DIArray Elements = CTy.getElements();
1047 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1048 DIDescriptor Element = Elements.getElement(i);
1049 if (Element.isSubprogram())
1050 getOrCreateSubprogramDIE(DISubprogram(Element));
1051 else if (Element.isDerivedType()) {
1052 DIDerivedType DDTy(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 (Element.isObjCProperty()) {
1063 DIObjCProperty Property(Element);
1064 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1065 StringRef PropertyName = Property.getObjCPropertyName();
1066 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1067 if (Property.getType())
1068 addType(ElemDie, Property.getType());
1069 addSourceLine(ElemDie, Property);
1070 StringRef GetterName = Property.getObjCPropertyGetterName();
1071 if (!GetterName.empty())
1072 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1073 StringRef SetterName = Property.getObjCPropertySetterName();
1074 if (!SetterName.empty())
1075 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1076 unsigned PropertyAttributes = 0;
1077 if (Property.isReadOnlyObjCProperty())
1078 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1079 if (Property.isReadWriteObjCProperty())
1080 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1081 if (Property.isAssignObjCProperty())
1082 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1083 if (Property.isRetainObjCProperty())
1084 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1085 if (Property.isCopyObjCProperty())
1086 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1087 if (Property.isNonAtomicObjCProperty())
1088 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1089 if (PropertyAttributes)
1090 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1091 PropertyAttributes);
1093 DIEEntry *Entry = getDIEEntry(Element);
1095 Entry = createDIEEntry(ElemDie);
1096 insertDIEEntry(Element, Entry);
1102 if (CTy.isAppleBlockExtension())
1103 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1105 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1106 // inside C++ composite types to point to the base class with the vtable.
1107 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1109 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1110 *getOrCreateTypeDIE(ContainingType));
1112 if (CTy.isObjcClassComplete())
1113 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1115 // Add template parameters to a class, structure or union types.
1116 // FIXME: The support isn't in the metadata for this yet.
1117 if (Tag == dwarf::DW_TAG_class_type ||
1118 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1119 addTemplateParams(Buffer, CTy.getTemplateParams());
1127 // Add name if not anonymous or intermediate type.
1129 addString(Buffer, dwarf::DW_AT_name, Name);
1131 if (Tag == dwarf::DW_TAG_enumeration_type ||
1132 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1133 Tag == dwarf::DW_TAG_union_type) {
1134 // Add size if non-zero (derived types might be zero-sized.)
1135 // TODO: Do we care about size for enum forward declarations?
1137 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1138 else if (!CTy.isForwardDecl())
1139 // Add zero size if it is not a forward declaration.
1140 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1142 // If we're a forward decl, say so.
1143 if (CTy.isForwardDecl())
1144 addFlag(Buffer, dwarf::DW_AT_declaration);
1146 // Add source line info if available.
1147 if (!CTy.isForwardDecl())
1148 addSourceLine(Buffer, CTy);
1150 // No harm in adding the runtime language to the declaration.
1151 unsigned RLang = CTy.getRunTimeLang();
1153 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1158 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1159 /// DITemplateTypeParameter.
1160 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1161 DITemplateTypeParameter TP) {
1163 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1164 // Add the type if it exists, it could be void and therefore no type.
1166 addType(ParamDIE, resolve(TP.getType()));
1167 if (!TP.getName().empty())
1168 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1171 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1172 /// DITemplateValueParameter.
1174 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1175 DITemplateValueParameter VP) {
1176 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1178 // Add the type if there is one, template template and template parameter
1179 // packs will not have a type.
1180 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1181 addType(ParamDIE, resolve(VP.getType()));
1182 if (!VP.getName().empty())
1183 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1184 if (Metadata *Val = VP.getValue()) {
1185 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1186 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1187 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1188 // For declaration non-type template parameters (such as global values and
1190 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1191 addOpAddress(*Loc, Asm->getSymbol(GV));
1192 // Emit DW_OP_stack_value to use the address as the immediate value of the
1193 // parameter, rather than a pointer to it.
1194 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1195 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1196 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1197 assert(isa<MDString>(Val));
1198 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1199 cast<MDString>(Val)->getString());
1200 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1201 assert(isa<MDNode>(Val));
1202 DIArray A(cast<MDNode>(Val));
1203 addTemplateParams(ParamDIE, A);
1208 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1209 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1210 // Construct the context before querying for the existence of the DIE in case
1211 // such construction creates the DIE.
1212 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1214 if (DIE *NDie = getDIE(NS))
1216 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1218 StringRef Name = NS.getName();
1220 addString(NDie, dwarf::DW_AT_name, NS.getName());
1222 Name = "(anonymous namespace)";
1223 DD->addAccelNamespace(Name, NDie);
1224 addGlobalName(Name, NDie, NS.getContext());
1225 addSourceLine(NDie, NS);
1229 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1230 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1231 // Construct the context before querying for the existence of the DIE in case
1232 // such construction creates the DIE (as is the case for member function
1235 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1237 if (DIE *SPDie = getDIE(SP))
1240 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1242 // Add subprogram definitions to the CU die directly.
1243 ContextDIE = &getUnitDie();
1244 // Build the decl now to ensure it precedes the definition.
1245 getOrCreateSubprogramDIE(SPDecl);
1249 // DW_TAG_inlined_subroutine may refer to this DIE.
1250 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1252 // Stop here and fill this in later, depending on whether or not this
1253 // subprogram turns out to have inlined instances or not.
1254 if (SP.isDefinition())
1257 applySubprogramAttributes(SP, SPDie);
1261 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1263 DIE *DeclDie = nullptr;
1264 StringRef DeclLinkageName;
1265 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1266 DeclDie = getDIE(SPDecl);
1267 assert(DeclDie && "This DIE should've already been constructed when the "
1268 "definition DIE was created in "
1269 "getOrCreateSubprogramDIE");
1270 DeclLinkageName = SPDecl.getLinkageName();
1273 // Add function template parameters.
1274 addTemplateParams(SPDie, SP.getTemplateParams());
1276 // Add the linkage name if we have one and it isn't in the Decl.
1277 StringRef LinkageName = SP.getLinkageName();
1278 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1279 LinkageName == DeclLinkageName) &&
1280 "decl has a linkage name and it is different");
1281 if (!LinkageName.empty() && DeclLinkageName.empty())
1282 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1283 GlobalValue::getRealLinkageName(LinkageName));
1288 // Refer to the function declaration where all the other attributes will be
1290 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1294 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1297 if (applySubprogramDefinitionAttributes(SP, SPDie))
1300 // Constructors and operators for anonymous aggregates do not have names.
1301 if (!SP.getName().empty())
1302 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1304 // Skip the rest of the attributes under -gmlt to save space.
1308 addSourceLine(SPDie, SP);
1310 // Add the prototype if we have a prototype and we have a C like
1312 uint16_t Language = getLanguage();
1313 if (SP.isPrototyped() &&
1314 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1315 Language == dwarf::DW_LANG_ObjC))
1316 addFlag(SPDie, dwarf::DW_AT_prototyped);
1318 DISubroutineType SPTy = SP.getType();
1319 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1320 "the type of a subprogram should be a subroutine");
1322 DITypeArray Args = SPTy.getTypeArray();
1323 // Add a return type. If this is a type like a C/C++ void type we don't add a
1325 if (resolve(Args.getElement(0)))
1326 addType(SPDie, DIType(resolve(Args.getElement(0))));
1328 unsigned VK = SP.getVirtuality();
1330 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1331 DIELoc *Block = getDIELoc();
1332 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1333 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1334 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1335 ContainingTypeMap.insert(
1336 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1339 if (!SP.isDefinition()) {
1340 addFlag(SPDie, dwarf::DW_AT_declaration);
1342 // Add arguments. Do not add arguments for subprogram definition. They will
1343 // be handled while processing variables.
1344 constructSubprogramArguments(SPDie, Args);
1347 if (SP.isArtificial())
1348 addFlag(SPDie, dwarf::DW_AT_artificial);
1350 if (!SP.isLocalToUnit())
1351 addFlag(SPDie, dwarf::DW_AT_external);
1353 if (SP.isOptimized())
1354 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1356 if (unsigned isa = Asm->getISAEncoding(SP.getFunction())) {
1357 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1360 if (SP.isLValueReference())
1361 addFlag(SPDie, dwarf::DW_AT_reference);
1363 if (SP.isRValueReference())
1364 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1366 if (SP.isProtected())
1367 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1368 dwarf::DW_ACCESS_protected);
1369 else if (SP.isPrivate())
1370 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1371 dwarf::DW_ACCESS_private);
1372 else if (SP.isPublic())
1373 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1374 dwarf::DW_ACCESS_public);
1376 if (SP.isExplicit())
1377 addFlag(SPDie, dwarf::DW_AT_explicit);
1380 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1381 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1382 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1383 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1385 // The LowerBound value defines the lower bounds which is typically zero for
1386 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1387 // Count == -1 then the array is unbounded and we do not emit
1388 // DW_AT_lower_bound and DW_AT_count attributes.
1389 int64_t LowerBound = SR.getLo();
1390 int64_t DefaultLowerBound = getDefaultLowerBound();
1391 int64_t Count = SR.getCount();
1393 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1394 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1397 // FIXME: An unbounded array should reference the expression that defines
1399 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1402 DIE *DwarfUnit::getIndexTyDie() {
1405 // Construct an integer type to use for indexes.
1406 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1407 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1408 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1409 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1410 dwarf::DW_ATE_unsigned);
1414 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1415 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1417 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1419 // Emit the element type.
1420 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1422 // Get an anonymous type for index type.
1423 // FIXME: This type should be passed down from the front end
1424 // as different languages may have different sizes for indexes.
1425 DIE *IdxTy = getIndexTyDie();
1427 // Add subranges to array type.
1428 DIArray Elements = CTy.getElements();
1429 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1430 DIDescriptor Element = Elements.getElement(i);
1431 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1432 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1436 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1437 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1438 DIArray Elements = CTy.getElements();
1440 // Add enumerators to enumeration type.
1441 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1442 DIEnumerator Enum(Elements.getElement(i));
1443 if (Enum.isEnumerator()) {
1444 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1445 StringRef Name = Enum.getName();
1446 addString(Enumerator, dwarf::DW_AT_name, Name);
1447 int64_t Value = Enum.getEnumValue();
1448 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1452 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1454 addType(Buffer, DTy);
1455 addFlag(Buffer, dwarf::DW_AT_enum_class);
1459 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1461 void DwarfUnit::constructContainingTypeDIEs() {
1462 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1463 CE = ContainingTypeMap.end();
1465 DIE &SPDie = *CI->first;
1466 DIDescriptor D(CI->second);
1469 DIE *NDie = getDIE(D);
1472 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1476 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1477 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1478 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1479 StringRef Name = DT.getName();
1481 addString(MemberDie, dwarf::DW_AT_name, Name);
1483 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1485 addSourceLine(MemberDie, DT);
1487 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1489 // For C++, virtual base classes are not at fixed offset. Use following
1490 // expression to extract appropriate offset from vtable.
1491 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1493 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1494 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1495 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1496 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1497 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1498 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1499 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1500 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1502 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1504 uint64_t Size = DT.getSizeInBits();
1505 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1506 uint64_t OffsetInBytes;
1508 if (FieldSize && Size != FieldSize) {
1509 // Handle bitfield, assume bytes are 8 bits.
1510 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1511 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1513 uint64_t Offset = DT.getOffsetInBits();
1514 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1515 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1516 uint64_t FieldOffset = (HiMark - FieldSize);
1517 Offset -= FieldOffset;
1519 // Maybe we need to work from the other end.
1520 if (Asm->getDataLayout().isLittleEndian())
1521 Offset = FieldSize - (Offset + Size);
1522 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1524 // Here DW_AT_data_member_location points to the anonymous
1525 // field that includes this bit field.
1526 OffsetInBytes = FieldOffset >> 3;
1528 // This is not a bitfield.
1529 OffsetInBytes = DT.getOffsetInBits() >> 3;
1531 if (DD->getDwarfVersion() <= 2) {
1532 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1533 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1534 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1535 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1537 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1541 if (DT.isProtected())
1542 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1543 dwarf::DW_ACCESS_protected);
1544 else if (DT.isPrivate())
1545 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1546 dwarf::DW_ACCESS_private);
1547 // Otherwise C++ member and base classes are considered public.
1548 else if (DT.isPublic())
1549 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1550 dwarf::DW_ACCESS_public);
1552 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1553 dwarf::DW_VIRTUALITY_virtual);
1555 // Objective-C properties.
1556 if (MDNode *PNode = DT.getObjCProperty())
1557 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1558 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1561 if (DT.isArtificial())
1562 addFlag(MemberDie, dwarf::DW_AT_artificial);
1565 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1566 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1570 // Construct the context before querying for the existence of the DIE in case
1571 // such construction creates the DIE.
1572 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1573 assert(dwarf::isType(ContextDIE->getTag()) &&
1574 "Static member should belong to a type.");
1576 if (DIE *StaticMemberDIE = getDIE(DT))
1577 return StaticMemberDIE;
1579 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1581 DIType Ty = resolve(DT.getTypeDerivedFrom());
1583 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1584 addType(StaticMemberDIE, Ty);
1585 addSourceLine(StaticMemberDIE, DT);
1586 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1587 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1589 // FIXME: We could omit private if the parent is a class_type, and
1590 // public if the parent is something else.
1591 if (DT.isProtected())
1592 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1593 dwarf::DW_ACCESS_protected);
1594 else if (DT.isPrivate())
1595 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1596 dwarf::DW_ACCESS_private);
1597 else if (DT.isPublic())
1598 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1599 dwarf::DW_ACCESS_public);
1601 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1602 addConstantValue(StaticMemberDIE, CI, Ty);
1603 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1604 addConstantFPValue(StaticMemberDIE, CFP);
1606 return &StaticMemberDIE;
1609 void DwarfUnit::emitHeader(bool UseOffsets) {
1610 // Emit size of content not including length itself
1611 Asm->OutStreamer.AddComment("Length of Unit");
1612 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1614 Asm->OutStreamer.AddComment("DWARF version number");
1615 Asm->EmitInt16(DD->getDwarfVersion());
1616 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1618 // We share one abbreviations table across all units so it's always at the
1619 // start of the section. Use a relocatable offset where needed to ensure
1620 // linking doesn't invalidate that offset.
1621 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1623 Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1627 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1628 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1631 void DwarfUnit::initSection(const MCSection *Section) {
1632 assert(!this->Section);
1633 this->Section = Section;
1636 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1637 DwarfUnit::emitHeader(UseOffsets);
1638 Asm->OutStreamer.AddComment("Type Signature");
1639 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1640 Asm->OutStreamer.AddComment("Type DIE Offset");
1641 // In a skeleton type unit there is no type DIE so emit a zero offset.
1642 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1643 sizeof(Ty->getOffset()));
1646 bool DwarfTypeUnit::isDwoUnit() const {
1647 // Since there are no skeleton type units, all type units are dwo type units
1648 // when split DWARF is being used.
1649 return DD->useSplitDwarf();