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/IR/Constants.h"
21 #include "llvm/IR/DIBuilder.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Mangler.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetSubtargetInfo.h"
39 #define DEBUG_TYPE "dwarfdebug"
42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
43 cl::desc("Generate DWARF4 type units."),
46 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
47 DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
49 void DIEDwarfExpression::EmitSigned(int Value) {
50 DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
52 void DIEDwarfExpression::EmitUnsigned(unsigned Value) {
53 DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
55 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
56 return MachineReg == getTRI()->getFrameRegister(*AP.MF);
60 /// Unit - Unit constructor.
61 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
62 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
63 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
64 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
65 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
66 UnitTag == dwarf::DW_TAG_type_unit);
67 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
70 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
71 DwarfDebug *DW, DwarfFile *DWU,
72 MCDwarfDwoLineTable *SplitLineTable)
73 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
74 CU(CU), SplitLineTable(SplitLineTable) {
76 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
79 /// ~Unit - Destructor for compile unit.
80 DwarfUnit::~DwarfUnit() {
81 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
82 DIEBlocks[j]->~DIEBlock();
83 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
84 DIELocs[j]->~DIELoc();
87 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
88 /// information entry.
89 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
90 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
94 /// getDefaultLowerBound - Return the default lower bound for an array. If the
95 /// DWARF version doesn't handle the language, return -1.
96 int64_t DwarfUnit::getDefaultLowerBound() const {
97 switch (getLanguage()) {
101 case dwarf::DW_LANG_C89:
102 case dwarf::DW_LANG_C99:
103 case dwarf::DW_LANG_C:
104 case dwarf::DW_LANG_C_plus_plus:
105 case dwarf::DW_LANG_ObjC:
106 case dwarf::DW_LANG_ObjC_plus_plus:
109 case dwarf::DW_LANG_Fortran77:
110 case dwarf::DW_LANG_Fortran90:
111 case dwarf::DW_LANG_Fortran95:
114 // The languages below have valid values only if the DWARF version >= 4.
115 case dwarf::DW_LANG_Java:
116 case dwarf::DW_LANG_Python:
117 case dwarf::DW_LANG_UPC:
118 case dwarf::DW_LANG_D:
119 if (dwarf::DWARF_VERSION >= 4)
123 case dwarf::DW_LANG_Ada83:
124 case dwarf::DW_LANG_Ada95:
125 case dwarf::DW_LANG_Cobol74:
126 case dwarf::DW_LANG_Cobol85:
127 case dwarf::DW_LANG_Modula2:
128 case dwarf::DW_LANG_Pascal83:
129 case dwarf::DW_LANG_PLI:
130 if (dwarf::DWARF_VERSION >= 4)
138 /// Check whether the DIE for this MDNode can be shared across CUs.
139 static bool isShareableAcrossCUs(DIDescriptor D) {
140 // When the MDNode can be part of the type system, the DIE can be shared
142 // Combining type units and cross-CU DIE sharing is lower value (since
143 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
144 // level already) but may be implementable for some value in projects
145 // building multiple independent libraries with LTO and then linking those
147 return (D.isType() ||
148 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
149 !GenerateDwarfTypeUnits;
152 /// getDIE - Returns the debug information entry map slot for the
153 /// specified debug variable. We delegate the request to DwarfDebug
154 /// when the DIE for this MDNode can be shared across CUs. The mappings
155 /// will be kept in DwarfDebug for shareable DIEs.
156 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
157 if (isShareableAcrossCUs(D))
158 return DU->getDIE(D);
159 return MDNodeToDieMap.lookup(D);
162 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
163 /// when the DIE for this MDNode can be shared across CUs. The mappings
164 /// will be kept in DwarfDebug for shareable DIEs.
165 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
166 if (isShareableAcrossCUs(Desc)) {
167 DU->insertDIE(Desc, D);
170 MDNodeToDieMap.insert(std::make_pair(Desc, D));
173 /// addFlag - Add a flag that is true.
174 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
175 if (DD->getDwarfVersion() >= 4)
176 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
178 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
181 /// addUInt - Add an unsigned integer attribute data and value.
183 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
184 Optional<dwarf::Form> Form, uint64_t Integer) {
186 Form = DIEInteger::BestForm(false, Integer);
187 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
189 Die.addValue(Attribute, *Form, Value);
192 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
193 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
196 /// addSInt - Add an signed integer attribute data and value.
198 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
199 Optional<dwarf::Form> Form, int64_t Integer) {
201 Form = DIEInteger::BestForm(true, Integer);
202 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
203 Die.addValue(Attribute, *Form, Value);
206 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
208 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
211 /// addString - Add a string attribute data and value. We always emit a
212 /// reference to the string pool instead of immediate strings so that DIEs have
213 /// more predictable sizes. In the case of split dwarf we emit an index
214 /// into another table which gets us the static offset into the string
216 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
219 return addLocalString(Die, Attribute, String);
221 addIndexedString(Die, Attribute, String);
224 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
226 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
227 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
228 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
229 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
232 /// addLocalString - Add a string attribute data and value. This is guaranteed
233 /// to be in the local string pool instead of indirected.
234 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
236 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
238 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
239 Value = new (DIEValueAllocator) DIELabel(Symb);
241 Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
242 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
243 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
246 /// addLabel - Add a Dwarf label attribute data and value.
248 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
249 const MCSymbol *Label) {
250 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
251 Die.addValue(Attribute, Form, Value);
254 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
255 addLabel(Die, (dwarf::Attribute)0, Form, Label);
258 /// addSectionOffset - Add an offset into a section attribute data and value.
260 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
262 if (DD->getDwarfVersion() >= 4)
263 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
265 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
268 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
269 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
270 : getCU().getOrCreateSourceID(FileName, DirName);
273 /// addOpAddress - Add a dwarf op address data and value using the
274 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
276 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
277 if (!DD->useSplitDwarf()) {
278 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
279 addLabel(Die, dwarf::DW_FORM_udata, Sym);
281 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
282 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
283 DD->getAddressPool().getIndex(Sym));
287 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
288 const MCSymbol *Hi, const MCSymbol *Lo) {
289 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
290 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
293 /// addDIEEntry - Add a DIE attribute data and value.
295 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
296 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
299 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
300 // Flag the type unit reference as a declaration so that if it contains
301 // members (implicit special members, static data member definitions, member
302 // declarations for definitions in this CU, etc) consumers don't get confused
303 // and think this is a full definition.
304 addFlag(Die, dwarf::DW_AT_declaration);
306 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
307 new (DIEValueAllocator) DIETypeSignature(Type));
310 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
312 const DIE *DieCU = Die.getUnitOrNull();
313 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
315 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
316 DieCU = &getUnitDie();
318 EntryCU = &getUnitDie();
319 Die.addValue(Attribute,
320 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
324 /// Create a DIE with the given Tag, add the DIE to its parent, and
325 /// call insertDIE if MD is not null.
326 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
327 assert(Tag != dwarf::DW_TAG_auto_variable &&
328 Tag != dwarf::DW_TAG_arg_variable);
329 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
330 DIE &Die = *Parent.getChildren().back();
336 /// addBlock - Add block data.
338 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
339 Loc->ComputeSize(Asm);
340 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
341 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
344 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
346 Block->ComputeSize(Asm);
347 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
348 Die.addValue(Attribute, Block->BestForm(), Block);
351 /// addSourceLine - Add location information to specified debug information
353 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
354 StringRef Directory) {
358 unsigned FileID = getOrCreateSourceID(File, Directory);
359 assert(FileID && "Invalid file id");
360 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
361 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
364 /// addSourceLine - Add location information to specified debug information
366 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
367 assert(V.isVariable());
369 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
370 V.getContext().getDirectory());
373 /// addSourceLine - Add location information to specified debug information
375 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
376 assert(G.isGlobalVariable());
378 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
381 /// addSourceLine - Add location information to specified debug information
383 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
384 assert(SP.isSubprogram());
386 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
389 /// addSourceLine - Add location information to specified debug information
391 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
394 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
397 /// addSourceLine - Add location information to specified debug information
399 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
400 assert(Ty.isObjCProperty());
402 DIFile File = Ty.getFile();
403 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
404 File.getDirectory());
407 /// addSourceLine - Add location information to specified debug information
409 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
412 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
415 /// addRegisterOp - Add register operand.
416 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
417 unsigned SizeInBits, unsigned OffsetInBits) {
418 DIEDwarfExpression Expr(*Asm, *this, TheDie);
419 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
423 /// addRegisterOffset - Add register offset.
424 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
426 DIEDwarfExpression Expr(*Asm, *this, TheDie);
427 return Expr.AddMachineRegIndirect(Reg, Offset);
430 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
431 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
432 gives the variable VarName either the struct, or a pointer to the struct, as
433 its type. This is necessary for various behind-the-scenes things the
434 compiler needs to do with by-reference variables in Blocks.
436 However, as far as the original *programmer* is concerned, the variable
437 should still have type 'SomeType', as originally declared.
439 The function getBlockByrefType dives into the __Block_byref_x_VarName
440 struct to find the original type of the variable, which is then assigned to
441 the variable's Debug Information Entry as its real type. So far, so good.
442 However now the debugger will expect the variable VarName to have the type
443 SomeType. So we need the location attribute for the variable to be an
444 expression that explains to the debugger how to navigate through the
445 pointers and struct to find the actual variable of type SomeType.
447 The following function does just that. We start by getting
448 the "normal" location for the variable. This will be the location
449 of either the struct __Block_byref_x_VarName or the pointer to the
450 struct __Block_byref_x_VarName.
452 The struct will look something like:
454 struct __Block_byref_x_VarName {
456 struct __Block_byref_x_VarName *forwarding;
457 ... <various other fields>
459 ... <maybe more fields>
462 If we are given the struct directly (as our starting point) we
463 need to tell the debugger to:
465 1). Add the offset of the forwarding field.
467 2). Follow that pointer to get the real __Block_byref_x_VarName
468 struct to use (the real one may have been copied onto the heap).
470 3). Add the offset for the field VarName, to find the actual variable.
472 If we started with a pointer to the struct, then we need to
473 dereference that pointer first, before the other steps.
474 Translating this into DWARF ops, we will need to append the following
475 to the current location description for the variable:
477 DW_OP_deref -- optional, if we start with a pointer
478 DW_OP_plus_uconst <forward_fld_offset>
480 DW_OP_plus_uconst <varName_fld_offset>
482 That is what this function does. */
484 /// addBlockByrefAddress - Start with the address based on the location
485 /// provided, and generate the DWARF information necessary to find the
486 /// actual Block variable (navigating the Block struct) based on the
487 /// starting location. Add the DWARF information to the die. For
488 /// more information, read large comment just above here.
490 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
491 dwarf::Attribute Attribute,
492 const MachineLocation &Location) {
493 DIType Ty = DV.getType();
495 uint16_t Tag = Ty.getTag();
496 bool isPointer = false;
498 StringRef varName = DV.getName();
500 if (Tag == dwarf::DW_TAG_pointer_type) {
501 DIDerivedType DTy(Ty);
502 TmpTy = resolve(DTy.getTypeDerivedFrom());
506 DICompositeType blockStruct(TmpTy);
508 // Find the __forwarding field and the variable field in the __Block_byref
510 DIArray Fields = blockStruct.getElements();
511 DIDerivedType varField;
512 DIDerivedType forwardingField;
514 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
515 DIDerivedType DT(Fields.getElement(i));
516 StringRef fieldName = DT.getName();
517 if (fieldName == "__forwarding")
518 forwardingField = DT;
519 else if (fieldName == varName)
523 // Get the offsets for the forwarding field and the variable field.
524 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
525 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
527 // Decode the original location, and use that as the start of the byref
528 // variable's location.
529 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
532 if (Location.isReg())
533 validReg = addRegisterOpPiece(*Loc, Location.getReg());
535 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
540 // If we started with a pointer to the __Block_byref... struct, then
541 // the first thing we need to do is dereference the pointer (DW_OP_deref).
543 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
545 // Next add the offset for the '__forwarding' field:
546 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
547 // adding the offset if it's 0.
548 if (forwardingFieldOffset > 0) {
549 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
550 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
553 // Now dereference the __forwarding field to get to the real __Block_byref
554 // struct: DW_OP_deref.
555 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
557 // Now that we've got the real __Block_byref... struct, add the offset
558 // for the variable's field to get to the location of the actual variable:
559 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
560 if (varFieldOffset > 0) {
561 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
562 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
565 // Now attach the location information to the DIE.
566 addBlock(Die, Attribute, Loc);
569 /// Return true if type encoding is unsigned.
570 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
571 DIDerivedType DTy(Ty);
572 if (DTy.isDerivedType()) {
573 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
574 // Encode pointer constants as unsigned bytes. This is used at least for
575 // null pointer constant emission.
576 // (Pieces of) aggregate types that get hacked apart by SROA may also be
577 // represented by a constant. Encode them as unsigned bytes.
578 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
579 // here, but accept them for now due to a bug in SROA producing bogus
581 if (T == dwarf::DW_TAG_array_type ||
582 T == dwarf::DW_TAG_class_type ||
583 T == dwarf::DW_TAG_pointer_type ||
584 T == dwarf::DW_TAG_ptr_to_member_type ||
585 T == dwarf::DW_TAG_reference_type ||
586 T == dwarf::DW_TAG_rvalue_reference_type ||
587 T == dwarf::DW_TAG_structure_type ||
588 T == dwarf::DW_TAG_union_type)
590 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
591 T == dwarf::DW_TAG_volatile_type ||
592 T == dwarf::DW_TAG_restrict_type ||
593 T == dwarf::DW_TAG_enumeration_type);
594 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
595 return isUnsignedDIType(DD, DD->resolve(Deriv));
596 // FIXME: Enums without a fixed underlying type have unknown signedness
597 // here, leading to incorrectly emitted constants.
598 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
603 assert(BTy.isBasicType());
604 unsigned Encoding = BTy.getEncoding();
605 assert((Encoding == dwarf::DW_ATE_unsigned ||
606 Encoding == dwarf::DW_ATE_unsigned_char ||
607 Encoding == dwarf::DW_ATE_signed ||
608 Encoding == dwarf::DW_ATE_signed_char ||
609 Encoding == dwarf::DW_ATE_float ||
610 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
611 (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
612 Ty.getName() == "decltype(nullptr)")) &&
613 "Unsupported encoding");
614 return (Encoding == dwarf::DW_ATE_unsigned ||
615 Encoding == dwarf::DW_ATE_unsigned_char ||
616 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
617 Ty.getTag() == dwarf::DW_TAG_unspecified_type);
620 /// If this type is derived from a base type then return base type size.
621 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
622 unsigned Tag = Ty.getTag();
624 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
625 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
626 Tag != dwarf::DW_TAG_restrict_type)
627 return Ty.getSizeInBits();
629 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
631 assert(BaseType.isValid() && "Unexpected invalid base type");
633 // If this is a derived type, go ahead and get the base type, unless it's a
634 // reference then it's just the size of the field. Pointer types have no need
635 // of this since they're a different type of qualification on the type.
636 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
637 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
638 return Ty.getSizeInBits();
640 if (BaseType.isDerivedType())
641 return getBaseTypeSize(DD, DIDerivedType(BaseType));
643 return BaseType.getSizeInBits();
646 /// addConstantFPValue - Add constant value entry in variable DIE.
647 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
648 assert(MO.isFPImm() && "Invalid machine operand!");
649 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
650 APFloat FPImm = MO.getFPImm()->getValueAPF();
652 // Get the raw data form of the floating point.
653 const APInt FltVal = FPImm.bitcastToAPInt();
654 const char *FltPtr = (const char *)FltVal.getRawData();
656 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
657 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
658 int Incr = (LittleEndian ? 1 : -1);
659 int Start = (LittleEndian ? 0 : NumBytes - 1);
660 int Stop = (LittleEndian ? NumBytes : -1);
662 // Output the constant to DWARF one byte at a time.
663 for (; Start != Stop; Start += Incr)
664 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
666 addBlock(Die, dwarf::DW_AT_const_value, Block);
669 /// addConstantFPValue - Add constant value entry in variable DIE.
670 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
671 // Pass this down to addConstantValue as an unsigned bag of bits.
672 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
675 /// addConstantValue - Add constant value entry in variable DIE.
676 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
677 addConstantValue(Die, CI->getValue(), Ty);
680 /// addConstantValue - Add constant value entry in variable DIE.
681 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
683 assert(MO.isImm() && "Invalid machine operand!");
685 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
688 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
689 // FIXME: This is a bit conservative/simple - it emits negative values always
690 // sign extended to 64 bits rather than minimizing the number of bytes.
691 addUInt(Die, dwarf::DW_AT_const_value,
692 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
695 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
696 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
699 // addConstantValue - Add constant value entry in variable DIE.
700 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
701 unsigned CIBitWidth = Val.getBitWidth();
702 if (CIBitWidth <= 64) {
703 addConstantValue(Die, Unsigned,
704 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
708 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
710 // Get the raw data form of the large APInt.
711 const uint64_t *Ptr64 = Val.getRawData();
713 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
714 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
716 // Output the constant to DWARF one byte at a time.
717 for (int i = 0; i < NumBytes; i++) {
720 c = Ptr64[i / 8] >> (8 * (i & 7));
722 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
723 addUInt(*Block, dwarf::DW_FORM_data1, c);
726 addBlock(Die, dwarf::DW_AT_const_value, Block);
729 /// addTemplateParams - Add template parameters into buffer.
730 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
731 // Add template parameters.
732 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
733 DIDescriptor Element = TParams.getElement(i);
734 if (Element.isTemplateTypeParameter())
735 constructTemplateTypeParameterDIE(Buffer,
736 DITemplateTypeParameter(Element));
737 else if (Element.isTemplateValueParameter())
738 constructTemplateValueParameterDIE(Buffer,
739 DITemplateValueParameter(Element));
743 /// getOrCreateContextDIE - Get context owner's DIE.
744 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
745 if (!Context || Context.isFile())
746 return &getUnitDie();
747 if (Context.isType())
748 return getOrCreateTypeDIE(DIType(Context));
749 if (Context.isNameSpace())
750 return getOrCreateNameSpace(DINameSpace(Context));
751 if (Context.isSubprogram())
752 return getOrCreateSubprogramDIE(DISubprogram(Context));
753 return getDIE(Context);
756 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
757 DIScope Context = resolve(Ty.getContext());
758 DIE *ContextDIE = getOrCreateContextDIE(Context);
760 if (DIE *TyDIE = getDIE(Ty))
764 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
766 constructTypeDIE(TyDIE, Ty);
768 updateAcceleratorTables(Context, Ty, TyDIE);
772 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
774 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
780 assert(Ty == resolve(Ty.getRef()) &&
781 "type was not uniqued, possible ODR violation.");
783 // DW_TAG_restrict_type is not supported in DWARF2
784 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
785 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
787 // Construct the context before querying for the existence of the DIE in case
788 // such construction creates the DIE.
789 DIScope Context = resolve(Ty.getContext());
790 DIE *ContextDIE = getOrCreateContextDIE(Context);
793 if (DIE *TyDIE = getDIE(Ty))
797 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
799 updateAcceleratorTables(Context, Ty, TyDIE);
801 if (Ty.isBasicType())
802 constructTypeDIE(TyDIE, DIBasicType(Ty));
803 else if (Ty.isCompositeType()) {
804 DICompositeType CTy(Ty);
805 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
806 if (MDString *TypeId = CTy.getIdentifier()) {
807 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
808 // Skip updating the accelerator tables since this is not the full type.
811 constructTypeDIE(TyDIE, CTy);
813 assert(Ty.isDerivedType() && "Unknown kind of DIType");
814 constructTypeDIE(TyDIE, DIDerivedType(Ty));
820 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
822 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
823 bool IsImplementation = 0;
824 if (Ty.isCompositeType()) {
825 DICompositeType CT(Ty);
826 // A runtime language of 0 actually means C/C++ and that any
827 // non-negative value is some version of Objective-C/C++.
828 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
830 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
831 DD->addAccelType(Ty.getName(), TyDIE, Flags);
833 if (!Context || Context.isCompileUnit() || Context.isFile() ||
834 Context.isNameSpace())
835 addGlobalType(Ty, TyDIE, Context);
839 /// addType - Add a new type attribute to the specified entity.
840 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
841 assert(Ty && "Trying to add a type that doesn't exist?");
843 // Check for pre-existence.
844 DIEEntry *Entry = getDIEEntry(Ty);
845 // If it exists then use the existing value.
847 addDIEEntry(Entity, Attribute, Entry);
852 DIE *Buffer = getOrCreateTypeDIE(Ty);
855 Entry = createDIEEntry(*Buffer);
856 insertDIEEntry(Ty, Entry);
857 addDIEEntry(Entity, Attribute, Entry);
860 /// getParentContextString - Walks the metadata parent chain in a language
861 /// specific manner (using the compile unit language) and returns
862 /// it as a string. This is done at the metadata level because DIEs may
863 /// not currently have been added to the parent context and walking the
864 /// DIEs looking for names is more expensive than walking the metadata.
865 std::string DwarfUnit::getParentContextString(DIScope Context) const {
869 // FIXME: Decide whether to implement this for non-C++ languages.
870 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
874 SmallVector<DIScope, 1> Parents;
875 while (!Context.isCompileUnit()) {
876 Parents.push_back(Context);
877 if (Context.getContext())
878 Context = resolve(Context.getContext());
880 // Structure, etc types will have a NULL context if they're at the top
885 // Reverse iterate over our list to go from the outermost construct to the
887 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
891 StringRef Name = Ctx.getName();
892 if (Name.empty() && Ctx.isNameSpace())
893 Name = "(anonymous namespace)";
902 /// constructTypeDIE - Construct basic type die from DIBasicType.
903 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
904 // Get core information.
905 StringRef Name = BTy.getName();
906 // Add name if not anonymous or intermediate type.
908 addString(Buffer, dwarf::DW_AT_name, Name);
910 // An unspecified type only has a name attribute.
911 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
914 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
917 uint64_t Size = BTy.getSizeInBits() >> 3;
918 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
921 /// constructTypeDIE - Construct derived type die from DIDerivedType.
922 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
923 // Get core information.
924 StringRef Name = DTy.getName();
925 uint64_t Size = DTy.getSizeInBits() >> 3;
926 uint16_t Tag = Buffer.getTag();
928 // Map to main type, void will not have a type.
929 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
931 addType(Buffer, FromTy);
933 // Add name if not anonymous or intermediate type.
935 addString(Buffer, dwarf::DW_AT_name, Name);
937 // Add size if non-zero (derived types might be zero-sized.)
938 if (Size && Tag != dwarf::DW_TAG_pointer_type
939 && Tag != dwarf::DW_TAG_ptr_to_member_type)
940 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
942 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
943 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
944 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
945 // Add source line info if available and TyDesc is not a forward declaration.
946 if (!DTy.isForwardDecl())
947 addSourceLine(Buffer, DTy);
950 /// constructSubprogramArguments - Construct function argument DIEs.
951 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
952 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
953 DIType Ty = resolve(Args.getElement(i));
955 assert(i == N-1 && "Unspecified parameter must be the last argument");
956 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
958 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
960 if (Ty.isArtificial())
961 addFlag(Arg, dwarf::DW_AT_artificial);
966 /// constructTypeDIE - Construct type DIE from DICompositeType.
967 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
968 // Add name if not anonymous or intermediate type.
969 StringRef Name = CTy.getName();
971 uint64_t Size = CTy.getSizeInBits() >> 3;
972 uint16_t Tag = Buffer.getTag();
975 case dwarf::DW_TAG_array_type:
976 constructArrayTypeDIE(Buffer, CTy);
978 case dwarf::DW_TAG_enumeration_type:
979 constructEnumTypeDIE(Buffer, CTy);
981 case dwarf::DW_TAG_subroutine_type: {
982 // Add return type. A void return won't have a type.
983 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
984 DIType RTy(resolve(Elements.getElement(0)));
986 addType(Buffer, RTy);
988 bool isPrototyped = true;
989 if (Elements.getNumElements() == 2 &&
990 !Elements.getElement(1))
991 isPrototyped = false;
993 constructSubprogramArguments(Buffer, Elements);
995 // Add prototype flag if we're dealing with a C language and the
996 // function has been prototyped.
997 uint16_t Language = getLanguage();
999 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1000 Language == dwarf::DW_LANG_ObjC))
1001 addFlag(Buffer, dwarf::DW_AT_prototyped);
1003 if (CTy.isLValueReference())
1004 addFlag(Buffer, dwarf::DW_AT_reference);
1006 if (CTy.isRValueReference())
1007 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1009 case dwarf::DW_TAG_structure_type:
1010 case dwarf::DW_TAG_union_type:
1011 case dwarf::DW_TAG_class_type: {
1012 // Add elements to structure type.
1013 DIArray Elements = CTy.getElements();
1014 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1015 DIDescriptor Element = Elements.getElement(i);
1016 if (Element.isSubprogram())
1017 getOrCreateSubprogramDIE(DISubprogram(Element));
1018 else if (Element.isDerivedType()) {
1019 DIDerivedType DDTy(Element);
1020 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1021 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1022 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1023 dwarf::DW_AT_friend);
1024 } else if (DDTy.isStaticMember()) {
1025 getOrCreateStaticMemberDIE(DDTy);
1027 constructMemberDIE(Buffer, DDTy);
1029 } else if (Element.isObjCProperty()) {
1030 DIObjCProperty Property(Element);
1031 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1032 StringRef PropertyName = Property.getObjCPropertyName();
1033 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1034 if (Property.getType())
1035 addType(ElemDie, Property.getType());
1036 addSourceLine(ElemDie, Property);
1037 StringRef GetterName = Property.getObjCPropertyGetterName();
1038 if (!GetterName.empty())
1039 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1040 StringRef SetterName = Property.getObjCPropertySetterName();
1041 if (!SetterName.empty())
1042 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1043 unsigned PropertyAttributes = 0;
1044 if (Property.isReadOnlyObjCProperty())
1045 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1046 if (Property.isReadWriteObjCProperty())
1047 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1048 if (Property.isAssignObjCProperty())
1049 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1050 if (Property.isRetainObjCProperty())
1051 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1052 if (Property.isCopyObjCProperty())
1053 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1054 if (Property.isNonAtomicObjCProperty())
1055 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1056 if (PropertyAttributes)
1057 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1058 PropertyAttributes);
1060 DIEEntry *Entry = getDIEEntry(Element);
1062 Entry = createDIEEntry(ElemDie);
1063 insertDIEEntry(Element, Entry);
1069 if (CTy.isAppleBlockExtension())
1070 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1072 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1073 // inside C++ composite types to point to the base class with the vtable.
1074 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1076 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1077 *getOrCreateTypeDIE(ContainingType));
1079 if (CTy.isObjcClassComplete())
1080 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1082 // Add template parameters to a class, structure or union types.
1083 // FIXME: The support isn't in the metadata for this yet.
1084 if (Tag == dwarf::DW_TAG_class_type ||
1085 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1086 addTemplateParams(Buffer, CTy.getTemplateParams());
1094 // Add name if not anonymous or intermediate type.
1096 addString(Buffer, dwarf::DW_AT_name, Name);
1098 if (Tag == dwarf::DW_TAG_enumeration_type ||
1099 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1100 Tag == dwarf::DW_TAG_union_type) {
1101 // Add size if non-zero (derived types might be zero-sized.)
1102 // TODO: Do we care about size for enum forward declarations?
1104 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1105 else if (!CTy.isForwardDecl())
1106 // Add zero size if it is not a forward declaration.
1107 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1109 // If we're a forward decl, say so.
1110 if (CTy.isForwardDecl())
1111 addFlag(Buffer, dwarf::DW_AT_declaration);
1113 // Add source line info if available.
1114 if (!CTy.isForwardDecl())
1115 addSourceLine(Buffer, CTy);
1117 // No harm in adding the runtime language to the declaration.
1118 unsigned RLang = CTy.getRunTimeLang();
1120 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1125 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1126 /// DITemplateTypeParameter.
1127 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1128 DITemplateTypeParameter TP) {
1130 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1131 // Add the type if it exists, it could be void and therefore no type.
1133 addType(ParamDIE, resolve(TP.getType()));
1134 if (!TP.getName().empty())
1135 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1138 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1139 /// DITemplateValueParameter.
1141 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1142 DITemplateValueParameter VP) {
1143 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1145 // Add the type if there is one, template template and template parameter
1146 // packs will not have a type.
1147 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1148 addType(ParamDIE, resolve(VP.getType()));
1149 if (!VP.getName().empty())
1150 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1151 if (Metadata *Val = VP.getValue()) {
1152 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1153 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1154 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1155 // For declaration non-type template parameters (such as global values and
1157 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1158 addOpAddress(*Loc, Asm->getSymbol(GV));
1159 // Emit DW_OP_stack_value to use the address as the immediate value of the
1160 // parameter, rather than a pointer to it.
1161 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1162 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1163 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1164 assert(isa<MDString>(Val));
1165 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1166 cast<MDString>(Val)->getString());
1167 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1168 assert(isa<MDNode>(Val));
1169 DIArray A(cast<MDNode>(Val));
1170 addTemplateParams(ParamDIE, A);
1175 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1176 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1177 // Construct the context before querying for the existence of the DIE in case
1178 // such construction creates the DIE.
1179 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1181 if (DIE *NDie = getDIE(NS))
1183 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1185 StringRef Name = NS.getName();
1187 addString(NDie, dwarf::DW_AT_name, NS.getName());
1189 Name = "(anonymous namespace)";
1190 DD->addAccelNamespace(Name, NDie);
1191 addGlobalName(Name, NDie, NS.getContext());
1192 addSourceLine(NDie, NS);
1196 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1197 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1198 // Construct the context before querying for the existence of the DIE in case
1199 // such construction creates the DIE (as is the case for member function
1202 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1204 if (DIE *SPDie = getDIE(SP))
1207 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1209 // Add subprogram definitions to the CU die directly.
1210 ContextDIE = &getUnitDie();
1211 // Build the decl now to ensure it precedes the definition.
1212 getOrCreateSubprogramDIE(SPDecl);
1216 // DW_TAG_inlined_subroutine may refer to this DIE.
1217 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1219 // Stop here and fill this in later, depending on whether or not this
1220 // subprogram turns out to have inlined instances or not.
1221 if (SP.isDefinition())
1224 applySubprogramAttributes(SP, SPDie);
1228 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1230 DIE *DeclDie = nullptr;
1231 StringRef DeclLinkageName;
1232 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1233 DeclDie = getDIE(SPDecl);
1234 assert(DeclDie && "This DIE should've already been constructed when the "
1235 "definition DIE was created in "
1236 "getOrCreateSubprogramDIE");
1237 DeclLinkageName = SPDecl.getLinkageName();
1240 // Add function template parameters.
1241 addTemplateParams(SPDie, SP.getTemplateParams());
1243 // Add the linkage name if we have one and it isn't in the Decl.
1244 StringRef LinkageName = SP.getLinkageName();
1245 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1246 LinkageName == DeclLinkageName) &&
1247 "decl has a linkage name and it is different");
1248 if (!LinkageName.empty() && DeclLinkageName.empty())
1249 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1250 GlobalValue::getRealLinkageName(LinkageName));
1255 // Refer to the function declaration where all the other attributes will be
1257 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1261 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1264 if (applySubprogramDefinitionAttributes(SP, SPDie))
1267 // Constructors and operators for anonymous aggregates do not have names.
1268 if (!SP.getName().empty())
1269 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1271 // Skip the rest of the attributes under -gmlt to save space.
1275 addSourceLine(SPDie, SP);
1277 // Add the prototype if we have a prototype and we have a C like
1279 uint16_t Language = getLanguage();
1280 if (SP.isPrototyped() &&
1281 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1282 Language == dwarf::DW_LANG_ObjC))
1283 addFlag(SPDie, dwarf::DW_AT_prototyped);
1285 DISubroutineType SPTy = SP.getType();
1286 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1287 "the type of a subprogram should be a subroutine");
1289 DITypeArray Args = SPTy.getTypeArray();
1290 // Add a return type. If this is a type like a C/C++ void type we don't add a
1292 if (resolve(Args.getElement(0)))
1293 addType(SPDie, DIType(resolve(Args.getElement(0))));
1295 unsigned VK = SP.getVirtuality();
1297 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1298 DIELoc *Block = getDIELoc();
1299 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1300 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1301 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1302 ContainingTypeMap.insert(
1303 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1306 if (!SP.isDefinition()) {
1307 addFlag(SPDie, dwarf::DW_AT_declaration);
1309 // Add arguments. Do not add arguments for subprogram definition. They will
1310 // be handled while processing variables.
1311 constructSubprogramArguments(SPDie, Args);
1314 if (SP.isArtificial())
1315 addFlag(SPDie, dwarf::DW_AT_artificial);
1317 if (!SP.isLocalToUnit())
1318 addFlag(SPDie, dwarf::DW_AT_external);
1320 if (SP.isOptimized())
1321 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1323 if (unsigned isa = Asm->getISAEncoding()) {
1324 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1327 if (SP.isLValueReference())
1328 addFlag(SPDie, dwarf::DW_AT_reference);
1330 if (SP.isRValueReference())
1331 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1333 if (SP.isProtected())
1334 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1335 dwarf::DW_ACCESS_protected);
1336 else if (SP.isPrivate())
1337 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1338 dwarf::DW_ACCESS_private);
1339 else if (SP.isPublic())
1340 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1341 dwarf::DW_ACCESS_public);
1343 if (SP.isExplicit())
1344 addFlag(SPDie, dwarf::DW_AT_explicit);
1347 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1348 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1349 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1350 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1352 // The LowerBound value defines the lower bounds which is typically zero for
1353 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1354 // Count == -1 then the array is unbounded and we do not emit
1355 // DW_AT_lower_bound and DW_AT_count attributes.
1356 int64_t LowerBound = SR.getLo();
1357 int64_t DefaultLowerBound = getDefaultLowerBound();
1358 int64_t Count = SR.getCount();
1360 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1361 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1364 // FIXME: An unbounded array should reference the expression that defines
1366 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1369 DIE *DwarfUnit::getIndexTyDie() {
1372 // Construct an integer type to use for indexes.
1373 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1374 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1375 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1376 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1377 dwarf::DW_ATE_unsigned);
1381 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1382 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1384 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1386 // Emit the element type.
1387 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1389 // Get an anonymous type for index type.
1390 // FIXME: This type should be passed down from the front end
1391 // as different languages may have different sizes for indexes.
1392 DIE *IdxTy = getIndexTyDie();
1394 // Add subranges to array type.
1395 DIArray Elements = CTy.getElements();
1396 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1397 DIDescriptor Element = Elements.getElement(i);
1398 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1399 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1403 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1404 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1405 DIArray Elements = CTy.getElements();
1407 // Add enumerators to enumeration type.
1408 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1409 DIEnumerator Enum(Elements.getElement(i));
1410 if (Enum.isEnumerator()) {
1411 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1412 StringRef Name = Enum.getName();
1413 addString(Enumerator, dwarf::DW_AT_name, Name);
1414 int64_t Value = Enum.getEnumValue();
1415 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1419 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1421 addType(Buffer, DTy);
1422 addFlag(Buffer, dwarf::DW_AT_enum_class);
1426 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1428 void DwarfUnit::constructContainingTypeDIEs() {
1429 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1430 CE = ContainingTypeMap.end();
1432 DIE &SPDie = *CI->first;
1433 DIDescriptor D(CI->second);
1436 DIE *NDie = getDIE(D);
1439 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1443 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1444 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1445 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1446 StringRef Name = DT.getName();
1448 addString(MemberDie, dwarf::DW_AT_name, Name);
1450 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1452 addSourceLine(MemberDie, DT);
1454 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1456 // For C++, virtual base classes are not at fixed offset. Use following
1457 // expression to extract appropriate offset from vtable.
1458 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1460 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1461 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1462 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1463 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1464 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1465 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1466 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1467 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1469 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1471 uint64_t Size = DT.getSizeInBits();
1472 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1473 uint64_t OffsetInBytes;
1475 if (FieldSize && Size != FieldSize) {
1476 // Handle bitfield, assume bytes are 8 bits.
1477 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1478 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1480 uint64_t Offset = DT.getOffsetInBits();
1481 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1482 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1483 uint64_t FieldOffset = (HiMark - FieldSize);
1484 Offset -= FieldOffset;
1486 // Maybe we need to work from the other end.
1487 if (Asm->getDataLayout().isLittleEndian())
1488 Offset = FieldSize - (Offset + Size);
1489 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1491 // Here DW_AT_data_member_location points to the anonymous
1492 // field that includes this bit field.
1493 OffsetInBytes = FieldOffset >> 3;
1495 // This is not a bitfield.
1496 OffsetInBytes = DT.getOffsetInBits() >> 3;
1498 if (DD->getDwarfVersion() <= 2) {
1499 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1500 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1501 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1502 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1504 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1508 if (DT.isProtected())
1509 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1510 dwarf::DW_ACCESS_protected);
1511 else if (DT.isPrivate())
1512 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1513 dwarf::DW_ACCESS_private);
1514 // Otherwise C++ member and base classes are considered public.
1515 else if (DT.isPublic())
1516 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1517 dwarf::DW_ACCESS_public);
1519 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1520 dwarf::DW_VIRTUALITY_virtual);
1522 // Objective-C properties.
1523 if (MDNode *PNode = DT.getObjCProperty())
1524 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1525 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1528 if (DT.isArtificial())
1529 addFlag(MemberDie, dwarf::DW_AT_artificial);
1532 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1533 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1537 // Construct the context before querying for the existence of the DIE in case
1538 // such construction creates the DIE.
1539 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1540 assert(dwarf::isType(ContextDIE->getTag()) &&
1541 "Static member should belong to a type.");
1543 if (DIE *StaticMemberDIE = getDIE(DT))
1544 return StaticMemberDIE;
1546 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1548 DIType Ty = resolve(DT.getTypeDerivedFrom());
1550 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1551 addType(StaticMemberDIE, Ty);
1552 addSourceLine(StaticMemberDIE, DT);
1553 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1554 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1556 // FIXME: We could omit private if the parent is a class_type, and
1557 // public if the parent is something else.
1558 if (DT.isProtected())
1559 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1560 dwarf::DW_ACCESS_protected);
1561 else if (DT.isPrivate())
1562 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1563 dwarf::DW_ACCESS_private);
1564 else if (DT.isPublic())
1565 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1566 dwarf::DW_ACCESS_public);
1568 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1569 addConstantValue(StaticMemberDIE, CI, Ty);
1570 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1571 addConstantFPValue(StaticMemberDIE, CFP);
1573 return &StaticMemberDIE;
1576 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1577 // Emit size of content not including length itself
1578 Asm->OutStreamer.AddComment("Length of Unit");
1579 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1581 Asm->OutStreamer.AddComment("DWARF version number");
1582 Asm->EmitInt16(DD->getDwarfVersion());
1583 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1584 // We share one abbreviations table across all units so it's always at the
1585 // start of the section. Use a relocatable offset where needed to ensure
1586 // linking doesn't invalidate that offset.
1588 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1590 // Use a constant value when no symbol is provided.
1592 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1593 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1596 void DwarfUnit::initSection(const MCSection *Section) {
1597 assert(!this->Section);
1598 this->Section = Section;
1601 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1602 DwarfUnit::emitHeader(ASectionSym);
1603 Asm->OutStreamer.AddComment("Type Signature");
1604 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1605 Asm->OutStreamer.AddComment("Type DIE Offset");
1606 // In a skeleton type unit there is no type DIE so emit a zero offset.
1607 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1608 sizeof(Ty->getOffset()));
1611 bool DwarfTypeUnit::isDwoUnit() const {
1612 // Since there are no skeleton type units, all type units are dwo type units
1613 // when split DWARF is being used.
1614 return DD->useSplitDwarf();