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"
16 #include "DwarfAccelTable.h"
17 #include "DwarfCompileUnit.h"
18 #include "DwarfDebug.h"
19 #include "DwarfExpression.h"
20 #include "llvm/ADT/APFloat.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 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
48 DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
50 void DIEDwarfExpression::EmitSigned(int Value) {
51 DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
53 void DIEDwarfExpression::EmitUnsigned(unsigned Value) {
54 DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
56 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
57 return MachineReg == getTRI()->getFrameRegister(*AP.MF);
61 /// Unit - Unit constructor.
62 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
63 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
64 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
65 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
66 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
67 UnitTag == dwarf::DW_TAG_type_unit);
68 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
71 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
72 DwarfDebug *DW, DwarfFile *DWU,
73 MCDwarfDwoLineTable *SplitLineTable)
74 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
75 CU(CU), SplitLineTable(SplitLineTable) {
77 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
80 /// ~Unit - Destructor for compile unit.
81 DwarfUnit::~DwarfUnit() {
82 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
83 DIEBlocks[j]->~DIEBlock();
84 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
85 DIELocs[j]->~DIELoc();
88 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
89 /// information entry.
90 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
91 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
95 /// getDefaultLowerBound - Return the default lower bound for an array. If the
96 /// DWARF version doesn't handle the language, return -1.
97 int64_t DwarfUnit::getDefaultLowerBound() const {
98 switch (getLanguage()) {
102 case dwarf::DW_LANG_C89:
103 case dwarf::DW_LANG_C99:
104 case dwarf::DW_LANG_C:
105 case dwarf::DW_LANG_C_plus_plus:
106 case dwarf::DW_LANG_ObjC:
107 case dwarf::DW_LANG_ObjC_plus_plus:
110 case dwarf::DW_LANG_Fortran77:
111 case dwarf::DW_LANG_Fortran90:
112 case dwarf::DW_LANG_Fortran95:
115 // The languages below have valid values only if the DWARF version >= 4.
116 case dwarf::DW_LANG_Java:
117 case dwarf::DW_LANG_Python:
118 case dwarf::DW_LANG_UPC:
119 case dwarf::DW_LANG_D:
120 if (dwarf::DWARF_VERSION >= 4)
124 case dwarf::DW_LANG_Ada83:
125 case dwarf::DW_LANG_Ada95:
126 case dwarf::DW_LANG_Cobol74:
127 case dwarf::DW_LANG_Cobol85:
128 case dwarf::DW_LANG_Modula2:
129 case dwarf::DW_LANG_Pascal83:
130 case dwarf::DW_LANG_PLI:
131 if (dwarf::DWARF_VERSION >= 4)
139 /// Check whether the DIE for this MDNode can be shared across CUs.
140 static bool isShareableAcrossCUs(DIDescriptor D) {
141 // When the MDNode can be part of the type system, the DIE can be shared
143 // Combining type units and cross-CU DIE sharing is lower value (since
144 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
145 // level already) but may be implementable for some value in projects
146 // building multiple independent libraries with LTO and then linking those
148 return (D.isType() ||
149 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
150 !GenerateDwarfTypeUnits;
153 /// getDIE - Returns the debug information entry map slot for the
154 /// specified debug variable. We delegate the request to DwarfDebug
155 /// when the DIE for this MDNode can be shared across CUs. The mappings
156 /// will be kept in DwarfDebug for shareable DIEs.
157 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
158 if (isShareableAcrossCUs(D))
159 return DU->getDIE(D);
160 return MDNodeToDieMap.lookup(D);
163 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
164 /// when the DIE for this MDNode can be shared across CUs. The mappings
165 /// will be kept in DwarfDebug for shareable DIEs.
166 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
167 if (isShareableAcrossCUs(Desc)) {
168 DU->insertDIE(Desc, D);
171 MDNodeToDieMap.insert(std::make_pair(Desc, D));
174 /// addFlag - Add a flag that is true.
175 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
176 if (DD->getDwarfVersion() >= 4)
177 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
179 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
182 /// addUInt - Add an unsigned integer attribute data and value.
184 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
185 Optional<dwarf::Form> Form, uint64_t Integer) {
187 Form = DIEInteger::BestForm(false, Integer);
188 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
190 Die.addValue(Attribute, *Form, Value);
193 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
194 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
197 /// addSInt - Add an signed integer attribute data and value.
199 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
200 Optional<dwarf::Form> Form, int64_t Integer) {
202 Form = DIEInteger::BestForm(true, Integer);
203 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
204 Die.addValue(Attribute, *Form, Value);
207 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
209 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
212 /// addString - Add a string attribute data and value. We always emit a
213 /// reference to the string pool instead of immediate strings so that DIEs have
214 /// more predictable sizes. In the case of split dwarf we emit an index
215 /// into another table which gets us the static offset into the string
217 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
220 return addLocalString(Die, Attribute, String);
222 addIndexedString(Die, Attribute, String);
225 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
227 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
228 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
229 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
230 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
233 /// addLocalString - Add a string attribute data and value. This is guaranteed
234 /// to be in the local string pool instead of indirected.
235 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
237 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
239 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
240 Value = new (DIEValueAllocator) DIELabel(Symb);
242 Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
243 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
244 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
247 /// addLabel - Add a Dwarf label attribute data and value.
249 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
250 const MCSymbol *Label) {
251 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
252 Die.addValue(Attribute, Form, Value);
255 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
256 addLabel(Die, (dwarf::Attribute)0, Form, Label);
259 /// addSectionOffset - Add an offset into a section attribute data and value.
261 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
263 if (DD->getDwarfVersion() >= 4)
264 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
266 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
269 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
270 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
271 : getCU().getOrCreateSourceID(FileName, DirName);
274 /// addOpAddress - Add a dwarf op address data and value using the
275 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
277 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
278 if (!DD->useSplitDwarf()) {
279 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
280 addLabel(Die, dwarf::DW_FORM_udata, Sym);
282 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
283 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
284 DD->getAddressPool().getIndex(Sym));
288 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
289 const MCSymbol *Hi, const MCSymbol *Lo) {
290 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
291 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
294 /// addDIEEntry - Add a DIE attribute data and value.
296 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
297 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
300 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
301 // Flag the type unit reference as a declaration so that if it contains
302 // members (implicit special members, static data member definitions, member
303 // declarations for definitions in this CU, etc) consumers don't get confused
304 // and think this is a full definition.
305 addFlag(Die, dwarf::DW_AT_declaration);
307 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
308 new (DIEValueAllocator) DIETypeSignature(Type));
311 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
313 const DIE *DieCU = Die.getUnitOrNull();
314 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
316 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
317 DieCU = &getUnitDie();
319 EntryCU = &getUnitDie();
320 Die.addValue(Attribute,
321 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
325 /// Create a DIE with the given Tag, add the DIE to its parent, and
326 /// call insertDIE if MD is not null.
327 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
328 assert(Tag != dwarf::DW_TAG_auto_variable &&
329 Tag != dwarf::DW_TAG_arg_variable);
330 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
331 DIE &Die = *Parent.getChildren().back();
337 /// addBlock - Add block data.
339 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
340 Loc->ComputeSize(Asm);
341 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
342 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
345 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
347 Block->ComputeSize(Asm);
348 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
349 Die.addValue(Attribute, Block->BestForm(), Block);
352 /// addSourceLine - Add location information to specified debug information
354 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
355 StringRef Directory) {
359 unsigned FileID = getOrCreateSourceID(File, Directory);
360 assert(FileID && "Invalid file id");
361 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
362 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
365 /// addSourceLine - Add location information to specified debug information
367 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
368 assert(V.isVariable());
370 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
371 V.getContext().getDirectory());
374 /// addSourceLine - Add location information to specified debug information
376 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
377 assert(G.isGlobalVariable());
379 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
382 /// addSourceLine - Add location information to specified debug information
384 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
385 assert(SP.isSubprogram());
387 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
390 /// addSourceLine - Add location information to specified debug information
392 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
395 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
398 /// addSourceLine - Add location information to specified debug information
400 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
401 assert(Ty.isObjCProperty());
403 DIFile File = Ty.getFile();
404 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
405 File.getDirectory());
408 /// addSourceLine - Add location information to specified debug information
410 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
413 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
416 /// addRegisterOp - Add register operand.
417 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
418 unsigned SizeInBits, unsigned OffsetInBits) {
419 DIEDwarfExpression Expr(*Asm, *this, TheDie);
420 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
424 /// addRegisterOffset - Add register offset.
425 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
427 DIEDwarfExpression Expr(*Asm, *this, TheDie);
428 return Expr.AddMachineRegIndirect(Reg, Offset);
431 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
432 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
433 gives the variable VarName either the struct, or a pointer to the struct, as
434 its type. This is necessary for various behind-the-scenes things the
435 compiler needs to do with by-reference variables in Blocks.
437 However, as far as the original *programmer* is concerned, the variable
438 should still have type 'SomeType', as originally declared.
440 The function getBlockByrefType dives into the __Block_byref_x_VarName
441 struct to find the original type of the variable, which is then assigned to
442 the variable's Debug Information Entry as its real type. So far, so good.
443 However now the debugger will expect the variable VarName to have the type
444 SomeType. So we need the location attribute for the variable to be an
445 expression that explains to the debugger how to navigate through the
446 pointers and struct to find the actual variable of type SomeType.
448 The following function does just that. We start by getting
449 the "normal" location for the variable. This will be the location
450 of either the struct __Block_byref_x_VarName or the pointer to the
451 struct __Block_byref_x_VarName.
453 The struct will look something like:
455 struct __Block_byref_x_VarName {
457 struct __Block_byref_x_VarName *forwarding;
458 ... <various other fields>
460 ... <maybe more fields>
463 If we are given the struct directly (as our starting point) we
464 need to tell the debugger to:
466 1). Add the offset of the forwarding field.
468 2). Follow that pointer to get the real __Block_byref_x_VarName
469 struct to use (the real one may have been copied onto the heap).
471 3). Add the offset for the field VarName, to find the actual variable.
473 If we started with a pointer to the struct, then we need to
474 dereference that pointer first, before the other steps.
475 Translating this into DWARF ops, we will need to append the following
476 to the current location description for the variable:
478 DW_OP_deref -- optional, if we start with a pointer
479 DW_OP_plus_uconst <forward_fld_offset>
481 DW_OP_plus_uconst <varName_fld_offset>
483 That is what this function does. */
485 /// addBlockByrefAddress - Start with the address based on the location
486 /// provided, and generate the DWARF information necessary to find the
487 /// actual Block variable (navigating the Block struct) based on the
488 /// starting location. Add the DWARF information to the die. For
489 /// more information, read large comment just above here.
491 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
492 dwarf::Attribute Attribute,
493 const MachineLocation &Location) {
494 DIType Ty = DV.getType();
496 uint16_t Tag = Ty.getTag();
497 bool isPointer = false;
499 StringRef varName = DV.getName();
501 if (Tag == dwarf::DW_TAG_pointer_type) {
502 DIDerivedType DTy(Ty);
503 TmpTy = resolve(DTy.getTypeDerivedFrom());
507 DICompositeType blockStruct(TmpTy);
509 // Find the __forwarding field and the variable field in the __Block_byref
511 DIArray Fields = blockStruct.getElements();
512 DIDerivedType varField;
513 DIDerivedType forwardingField;
515 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
516 DIDerivedType DT(Fields.getElement(i));
517 StringRef fieldName = DT.getName();
518 if (fieldName == "__forwarding")
519 forwardingField = DT;
520 else if (fieldName == varName)
524 // Get the offsets for the forwarding field and the variable field.
525 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
526 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
528 // Decode the original location, and use that as the start of the byref
529 // variable's location.
530 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
533 if (Location.isReg())
534 validReg = addRegisterOpPiece(*Loc, Location.getReg());
536 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
541 // If we started with a pointer to the __Block_byref... struct, then
542 // the first thing we need to do is dereference the pointer (DW_OP_deref).
544 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
546 // Next add the offset for the '__forwarding' field:
547 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
548 // adding the offset if it's 0.
549 if (forwardingFieldOffset > 0) {
550 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
551 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
554 // Now dereference the __forwarding field to get to the real __Block_byref
555 // struct: DW_OP_deref.
556 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
558 // Now that we've got the real __Block_byref... struct, add the offset
559 // for the variable's field to get to the location of the actual variable:
560 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
561 if (varFieldOffset > 0) {
562 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
563 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
566 // Now attach the location information to the DIE.
567 addBlock(Die, Attribute, Loc);
570 /// Return true if type encoding is unsigned.
571 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
572 DIDerivedType DTy(Ty);
573 if (DTy.isDerivedType()) {
574 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
575 // Encode pointer constants as unsigned bytes. This is used at least for
576 // null pointer constant emission.
577 // (Pieces of) aggregate types that get hacked apart by SROA may also be
578 // represented by a constant. Encode them as unsigned bytes.
579 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
580 // here, but accept them for now due to a bug in SROA producing bogus
582 if (T == dwarf::DW_TAG_array_type ||
583 T == dwarf::DW_TAG_class_type ||
584 T == dwarf::DW_TAG_pointer_type ||
585 T == dwarf::DW_TAG_ptr_to_member_type ||
586 T == dwarf::DW_TAG_reference_type ||
587 T == dwarf::DW_TAG_rvalue_reference_type ||
588 T == dwarf::DW_TAG_structure_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_UTF || Encoding == dwarf::DW_ATE_boolean ||
610 (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
611 Ty.getName() == "decltype(nullptr)")) &&
612 "Unsupported encoding");
613 return (Encoding == dwarf::DW_ATE_unsigned ||
614 Encoding == dwarf::DW_ATE_unsigned_char ||
615 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
616 Ty.getTag() == dwarf::DW_TAG_unspecified_type);
619 /// If this type is derived from a base type then return base type size.
620 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
621 unsigned Tag = Ty.getTag();
623 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
624 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
625 Tag != dwarf::DW_TAG_restrict_type)
626 return Ty.getSizeInBits();
628 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
630 // If this type is not derived from any type or the type is a declaration then
631 // take conservative approach.
632 if (!BaseType.isValid() || BaseType.isForwardDecl())
633 return Ty.getSizeInBits();
635 // If this is a derived type, go ahead and get the base type, unless it's a
636 // reference then it's just the size of the field. Pointer types have no need
637 // of this since they're a different type of qualification on the type.
638 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
639 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
640 return Ty.getSizeInBits();
642 if (BaseType.isDerivedType())
643 return getBaseTypeSize(DD, DIDerivedType(BaseType));
645 return BaseType.getSizeInBits();
648 /// addConstantFPValue - Add constant value entry in variable DIE.
649 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
650 assert(MO.isFPImm() && "Invalid machine operand!");
651 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
652 APFloat FPImm = MO.getFPImm()->getValueAPF();
654 // Get the raw data form of the floating point.
655 const APInt FltVal = FPImm.bitcastToAPInt();
656 const char *FltPtr = (const char *)FltVal.getRawData();
658 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
659 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
660 int Incr = (LittleEndian ? 1 : -1);
661 int Start = (LittleEndian ? 0 : NumBytes - 1);
662 int Stop = (LittleEndian ? NumBytes : -1);
664 // Output the constant to DWARF one byte at a time.
665 for (; Start != Stop; Start += Incr)
666 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
668 addBlock(Die, dwarf::DW_AT_const_value, Block);
671 /// addConstantFPValue - Add constant value entry in variable DIE.
672 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
673 // Pass this down to addConstantValue as an unsigned bag of bits.
674 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
677 /// addConstantValue - Add constant value entry in variable DIE.
678 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
679 addConstantValue(Die, CI->getValue(), Ty);
682 /// addConstantValue - Add constant value entry in variable DIE.
683 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
685 assert(MO.isImm() && "Invalid machine operand!");
687 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
690 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
691 // FIXME: This is a bit conservative/simple - it emits negative values always
692 // sign extended to 64 bits rather than minimizing the number of bytes.
693 addUInt(Die, dwarf::DW_AT_const_value,
694 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
697 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
698 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
701 // addConstantValue - Add constant value entry in variable DIE.
702 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
703 unsigned CIBitWidth = Val.getBitWidth();
704 if (CIBitWidth <= 64) {
705 addConstantValue(Die, Unsigned,
706 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
710 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
712 // Get the raw data form of the large APInt.
713 const uint64_t *Ptr64 = Val.getRawData();
715 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
716 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
718 // Output the constant to DWARF one byte at a time.
719 for (int i = 0; i < NumBytes; i++) {
722 c = Ptr64[i / 8] >> (8 * (i & 7));
724 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
725 addUInt(*Block, dwarf::DW_FORM_data1, c);
728 addBlock(Die, dwarf::DW_AT_const_value, Block);
731 /// addTemplateParams - Add template parameters into buffer.
732 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
733 // Add template parameters.
734 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
735 DIDescriptor Element = TParams.getElement(i);
736 if (Element.isTemplateTypeParameter())
737 constructTemplateTypeParameterDIE(Buffer,
738 DITemplateTypeParameter(Element));
739 else if (Element.isTemplateValueParameter())
740 constructTemplateValueParameterDIE(Buffer,
741 DITemplateValueParameter(Element));
745 /// getOrCreateContextDIE - Get context owner's DIE.
746 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
747 if (!Context || Context.isFile())
748 return &getUnitDie();
749 if (Context.isType())
750 return getOrCreateTypeDIE(DIType(Context));
751 if (Context.isNameSpace())
752 return getOrCreateNameSpace(DINameSpace(Context));
753 if (Context.isSubprogram())
754 return getOrCreateSubprogramDIE(DISubprogram(Context));
755 return getDIE(Context);
758 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
759 DIScope Context = resolve(Ty.getContext());
760 DIE *ContextDIE = getOrCreateContextDIE(Context);
762 if (DIE *TyDIE = getDIE(Ty))
766 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
768 constructTypeDIE(TyDIE, Ty);
770 updateAcceleratorTables(Context, Ty, TyDIE);
774 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
776 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
782 assert(Ty == resolve(Ty.getRef()) &&
783 "type was not uniqued, possible ODR violation.");
785 // DW_TAG_restrict_type is not supported in DWARF2
786 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
787 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
789 // Construct the context before querying for the existence of the DIE in case
790 // such construction creates the DIE.
791 DIScope Context = resolve(Ty.getContext());
792 DIE *ContextDIE = getOrCreateContextDIE(Context);
795 if (DIE *TyDIE = getDIE(Ty))
799 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
801 updateAcceleratorTables(Context, Ty, TyDIE);
803 if (Ty.isBasicType())
804 constructTypeDIE(TyDIE, DIBasicType(Ty));
805 else if (Ty.isCompositeType()) {
806 DICompositeType CTy(Ty);
807 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
808 if (MDString *TypeId = CTy.getIdentifier()) {
809 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
810 // Skip updating the accelerator tables since this is not the full type.
813 constructTypeDIE(TyDIE, CTy);
815 assert(Ty.isDerivedType() && "Unknown kind of DIType");
816 constructTypeDIE(TyDIE, DIDerivedType(Ty));
822 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
824 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
825 bool IsImplementation = 0;
826 if (Ty.isCompositeType()) {
827 DICompositeType CT(Ty);
828 // A runtime language of 0 actually means C/C++ and that any
829 // non-negative value is some version of Objective-C/C++.
830 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
832 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
833 DD->addAccelType(Ty.getName(), TyDIE, Flags);
835 if (!Context || Context.isCompileUnit() || Context.isFile() ||
836 Context.isNameSpace())
837 addGlobalType(Ty, TyDIE, Context);
841 /// addType - Add a new type attribute to the specified entity.
842 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
843 assert(Ty && "Trying to add a type that doesn't exist?");
845 // Check for pre-existence.
846 DIEEntry *Entry = getDIEEntry(Ty);
847 // If it exists then use the existing value.
849 addDIEEntry(Entity, Attribute, Entry);
854 DIE *Buffer = getOrCreateTypeDIE(Ty);
857 Entry = createDIEEntry(*Buffer);
858 insertDIEEntry(Ty, Entry);
859 addDIEEntry(Entity, Attribute, Entry);
862 /// getParentContextString - Walks the metadata parent chain in a language
863 /// specific manner (using the compile unit language) and returns
864 /// it as a string. This is done at the metadata level because DIEs may
865 /// not currently have been added to the parent context and walking the
866 /// DIEs looking for names is more expensive than walking the metadata.
867 std::string DwarfUnit::getParentContextString(DIScope Context) const {
871 // FIXME: Decide whether to implement this for non-C++ languages.
872 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
876 SmallVector<DIScope, 1> Parents;
877 while (!Context.isCompileUnit()) {
878 Parents.push_back(Context);
879 if (Context.getContext())
880 Context = resolve(Context.getContext());
882 // Structure, etc types will have a NULL context if they're at the top
887 // Reverse iterate over our list to go from the outermost construct to the
889 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
893 StringRef Name = Ctx.getName();
894 if (Name.empty() && Ctx.isNameSpace())
895 Name = "(anonymous namespace)";
904 /// constructTypeDIE - Construct basic type die from DIBasicType.
905 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
906 // Get core information.
907 StringRef Name = BTy.getName();
908 // Add name if not anonymous or intermediate type.
910 addString(Buffer, dwarf::DW_AT_name, Name);
912 // An unspecified type only has a name attribute.
913 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
916 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
919 uint64_t Size = BTy.getSizeInBits() >> 3;
920 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
923 /// constructTypeDIE - Construct derived type die from DIDerivedType.
924 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
925 // Get core information.
926 StringRef Name = DTy.getName();
927 uint64_t Size = DTy.getSizeInBits() >> 3;
928 uint16_t Tag = Buffer.getTag();
930 // Map to main type, void will not have a type.
931 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
933 addType(Buffer, FromTy);
935 // Add name if not anonymous or intermediate type.
937 addString(Buffer, dwarf::DW_AT_name, Name);
939 // Add size if non-zero (derived types might be zero-sized.)
940 if (Size && Tag != dwarf::DW_TAG_pointer_type
941 && Tag != dwarf::DW_TAG_ptr_to_member_type)
942 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
944 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
945 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
946 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
947 // Add source line info if available and TyDesc is not a forward declaration.
948 if (!DTy.isForwardDecl())
949 addSourceLine(Buffer, DTy);
952 /// constructSubprogramArguments - Construct function argument DIEs.
953 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
954 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
955 DIType Ty = resolve(Args.getElement(i));
957 assert(i == N-1 && "Unspecified parameter must be the last argument");
958 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
960 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
962 if (Ty.isArtificial())
963 addFlag(Arg, dwarf::DW_AT_artificial);
968 /// constructTypeDIE - Construct type DIE from DICompositeType.
969 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
970 // Add name if not anonymous or intermediate type.
971 StringRef Name = CTy.getName();
973 uint64_t Size = CTy.getSizeInBits() >> 3;
974 uint16_t Tag = Buffer.getTag();
977 case dwarf::DW_TAG_array_type:
978 constructArrayTypeDIE(Buffer, CTy);
980 case dwarf::DW_TAG_enumeration_type:
981 constructEnumTypeDIE(Buffer, CTy);
983 case dwarf::DW_TAG_subroutine_type: {
984 // Add return type. A void return won't have a type.
985 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
986 DIType RTy(resolve(Elements.getElement(0)));
988 addType(Buffer, RTy);
990 bool isPrototyped = true;
991 if (Elements.getNumElements() == 2 &&
992 !Elements.getElement(1))
993 isPrototyped = false;
995 constructSubprogramArguments(Buffer, Elements);
997 // Add prototype flag if we're dealing with a C language and the
998 // function has been prototyped.
999 uint16_t Language = getLanguage();
1001 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1002 Language == dwarf::DW_LANG_ObjC))
1003 addFlag(Buffer, dwarf::DW_AT_prototyped);
1005 if (CTy.isLValueReference())
1006 addFlag(Buffer, dwarf::DW_AT_reference);
1008 if (CTy.isRValueReference())
1009 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1011 case dwarf::DW_TAG_structure_type:
1012 case dwarf::DW_TAG_union_type:
1013 case dwarf::DW_TAG_class_type: {
1014 // Add elements to structure type.
1015 DIArray Elements = CTy.getElements();
1016 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1017 DIDescriptor Element = Elements.getElement(i);
1018 if (Element.isSubprogram())
1019 getOrCreateSubprogramDIE(DISubprogram(Element));
1020 else if (Element.isDerivedType()) {
1021 DIDerivedType DDTy(Element);
1022 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1023 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1024 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1025 dwarf::DW_AT_friend);
1026 } else if (DDTy.isStaticMember()) {
1027 getOrCreateStaticMemberDIE(DDTy);
1029 constructMemberDIE(Buffer, DDTy);
1031 } else if (Element.isObjCProperty()) {
1032 DIObjCProperty Property(Element);
1033 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1034 StringRef PropertyName = Property.getObjCPropertyName();
1035 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1036 if (Property.getType())
1037 addType(ElemDie, Property.getType());
1038 addSourceLine(ElemDie, Property);
1039 StringRef GetterName = Property.getObjCPropertyGetterName();
1040 if (!GetterName.empty())
1041 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1042 StringRef SetterName = Property.getObjCPropertySetterName();
1043 if (!SetterName.empty())
1044 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1045 unsigned PropertyAttributes = 0;
1046 if (Property.isReadOnlyObjCProperty())
1047 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1048 if (Property.isReadWriteObjCProperty())
1049 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1050 if (Property.isAssignObjCProperty())
1051 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1052 if (Property.isRetainObjCProperty())
1053 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1054 if (Property.isCopyObjCProperty())
1055 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1056 if (Property.isNonAtomicObjCProperty())
1057 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1058 if (PropertyAttributes)
1059 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1060 PropertyAttributes);
1062 DIEEntry *Entry = getDIEEntry(Element);
1064 Entry = createDIEEntry(ElemDie);
1065 insertDIEEntry(Element, Entry);
1071 if (CTy.isAppleBlockExtension())
1072 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1074 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1075 // inside C++ composite types to point to the base class with the vtable.
1076 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1078 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1079 *getOrCreateTypeDIE(ContainingType));
1081 if (CTy.isObjcClassComplete())
1082 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1084 // Add template parameters to a class, structure or union types.
1085 // FIXME: The support isn't in the metadata for this yet.
1086 if (Tag == dwarf::DW_TAG_class_type ||
1087 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1088 addTemplateParams(Buffer, CTy.getTemplateParams());
1096 // Add name if not anonymous or intermediate type.
1098 addString(Buffer, dwarf::DW_AT_name, Name);
1100 if (Tag == dwarf::DW_TAG_enumeration_type ||
1101 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1102 Tag == dwarf::DW_TAG_union_type) {
1103 // Add size if non-zero (derived types might be zero-sized.)
1104 // TODO: Do we care about size for enum forward declarations?
1106 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1107 else if (!CTy.isForwardDecl())
1108 // Add zero size if it is not a forward declaration.
1109 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1111 // If we're a forward decl, say so.
1112 if (CTy.isForwardDecl())
1113 addFlag(Buffer, dwarf::DW_AT_declaration);
1115 // Add source line info if available.
1116 if (!CTy.isForwardDecl())
1117 addSourceLine(Buffer, CTy);
1119 // No harm in adding the runtime language to the declaration.
1120 unsigned RLang = CTy.getRunTimeLang();
1122 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1127 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1128 /// DITemplateTypeParameter.
1129 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1130 DITemplateTypeParameter TP) {
1132 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1133 // Add the type if it exists, it could be void and therefore no type.
1135 addType(ParamDIE, resolve(TP.getType()));
1136 if (!TP.getName().empty())
1137 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1140 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1141 /// DITemplateValueParameter.
1143 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1144 DITemplateValueParameter VP) {
1145 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1147 // Add the type if there is one, template template and template parameter
1148 // packs will not have a type.
1149 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1150 addType(ParamDIE, resolve(VP.getType()));
1151 if (!VP.getName().empty())
1152 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1153 if (Metadata *Val = VP.getValue()) {
1154 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1155 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1156 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1157 // For declaration non-type template parameters (such as global values and
1159 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1160 addOpAddress(*Loc, Asm->getSymbol(GV));
1161 // Emit DW_OP_stack_value to use the address as the immediate value of the
1162 // parameter, rather than a pointer to it.
1163 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1164 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1165 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1166 assert(isa<MDString>(Val));
1167 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1168 cast<MDString>(Val)->getString());
1169 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1170 assert(isa<MDNode>(Val));
1171 DIArray A(cast<MDNode>(Val));
1172 addTemplateParams(ParamDIE, A);
1177 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1178 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1179 // Construct the context before querying for the existence of the DIE in case
1180 // such construction creates the DIE.
1181 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1183 if (DIE *NDie = getDIE(NS))
1185 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1187 StringRef Name = NS.getName();
1189 addString(NDie, dwarf::DW_AT_name, NS.getName());
1191 Name = "(anonymous namespace)";
1192 DD->addAccelNamespace(Name, NDie);
1193 addGlobalName(Name, NDie, NS.getContext());
1194 addSourceLine(NDie, NS);
1198 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1199 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1200 // Construct the context before querying for the existence of the DIE in case
1201 // such construction creates the DIE (as is the case for member function
1204 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1206 if (DIE *SPDie = getDIE(SP))
1209 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1211 // Add subprogram definitions to the CU die directly.
1212 ContextDIE = &getUnitDie();
1213 // Build the decl now to ensure it precedes the definition.
1214 getOrCreateSubprogramDIE(SPDecl);
1218 // DW_TAG_inlined_subroutine may refer to this DIE.
1219 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1221 // Stop here and fill this in later, depending on whether or not this
1222 // subprogram turns out to have inlined instances or not.
1223 if (SP.isDefinition())
1226 applySubprogramAttributes(SP, SPDie);
1230 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1232 DIE *DeclDie = nullptr;
1233 StringRef DeclLinkageName;
1234 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1235 DeclDie = getDIE(SPDecl);
1236 assert(DeclDie && "This DIE should've already been constructed when the "
1237 "definition DIE was created in "
1238 "getOrCreateSubprogramDIE");
1239 DeclLinkageName = SPDecl.getLinkageName();
1242 // Add function template parameters.
1243 addTemplateParams(SPDie, SP.getTemplateParams());
1245 // Add the linkage name if we have one and it isn't in the Decl.
1246 StringRef LinkageName = SP.getLinkageName();
1247 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1248 LinkageName == DeclLinkageName) &&
1249 "decl has a linkage name and it is different");
1250 if (!LinkageName.empty() && DeclLinkageName.empty())
1251 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1252 GlobalValue::getRealLinkageName(LinkageName));
1257 // Refer to the function declaration where all the other attributes will be
1259 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1263 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1266 if (applySubprogramDefinitionAttributes(SP, SPDie))
1269 // Constructors and operators for anonymous aggregates do not have names.
1270 if (!SP.getName().empty())
1271 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1273 // Skip the rest of the attributes under -gmlt to save space.
1277 addSourceLine(SPDie, SP);
1279 // Add the prototype if we have a prototype and we have a C like
1281 uint16_t Language = getLanguage();
1282 if (SP.isPrototyped() &&
1283 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1284 Language == dwarf::DW_LANG_ObjC))
1285 addFlag(SPDie, dwarf::DW_AT_prototyped);
1287 DISubroutineType SPTy = SP.getType();
1288 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1289 "the type of a subprogram should be a subroutine");
1291 DITypeArray Args = SPTy.getTypeArray();
1292 // Add a return type. If this is a type like a C/C++ void type we don't add a
1294 if (resolve(Args.getElement(0)))
1295 addType(SPDie, DIType(resolve(Args.getElement(0))));
1297 unsigned VK = SP.getVirtuality();
1299 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1300 DIELoc *Block = getDIELoc();
1301 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1302 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1303 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1304 ContainingTypeMap.insert(
1305 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1308 if (!SP.isDefinition()) {
1309 addFlag(SPDie, dwarf::DW_AT_declaration);
1311 // Add arguments. Do not add arguments for subprogram definition. They will
1312 // be handled while processing variables.
1313 constructSubprogramArguments(SPDie, Args);
1316 if (SP.isArtificial())
1317 addFlag(SPDie, dwarf::DW_AT_artificial);
1319 if (!SP.isLocalToUnit())
1320 addFlag(SPDie, dwarf::DW_AT_external);
1322 if (SP.isOptimized())
1323 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1325 if (unsigned isa = Asm->getISAEncoding()) {
1326 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1329 if (SP.isLValueReference())
1330 addFlag(SPDie, dwarf::DW_AT_reference);
1332 if (SP.isRValueReference())
1333 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1335 if (SP.isProtected())
1336 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1337 dwarf::DW_ACCESS_protected);
1338 else if (SP.isPrivate())
1339 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1340 dwarf::DW_ACCESS_private);
1341 else if (SP.isPublic())
1342 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1343 dwarf::DW_ACCESS_public);
1345 if (SP.isExplicit())
1346 addFlag(SPDie, dwarf::DW_AT_explicit);
1349 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1350 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1351 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1352 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1354 // The LowerBound value defines the lower bounds which is typically zero for
1355 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1356 // Count == -1 then the array is unbounded and we do not emit
1357 // DW_AT_lower_bound and DW_AT_count attributes.
1358 int64_t LowerBound = SR.getLo();
1359 int64_t DefaultLowerBound = getDefaultLowerBound();
1360 int64_t Count = SR.getCount();
1362 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1363 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1366 // FIXME: An unbounded array should reference the expression that defines
1368 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1371 DIE *DwarfUnit::getIndexTyDie() {
1374 // Construct an integer type to use for indexes.
1375 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1376 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1377 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1378 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1379 dwarf::DW_ATE_unsigned);
1383 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1384 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1386 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1388 // Emit the element type.
1389 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1391 // Get an anonymous type for index type.
1392 // FIXME: This type should be passed down from the front end
1393 // as different languages may have different sizes for indexes.
1394 DIE *IdxTy = getIndexTyDie();
1396 // Add subranges to array type.
1397 DIArray Elements = CTy.getElements();
1398 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1399 DIDescriptor Element = Elements.getElement(i);
1400 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1401 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1405 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1406 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1407 DIArray Elements = CTy.getElements();
1409 // Add enumerators to enumeration type.
1410 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1411 DIEnumerator Enum(Elements.getElement(i));
1412 if (Enum.isEnumerator()) {
1413 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1414 StringRef Name = Enum.getName();
1415 addString(Enumerator, dwarf::DW_AT_name, Name);
1416 int64_t Value = Enum.getEnumValue();
1417 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1421 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1423 addType(Buffer, DTy);
1424 addFlag(Buffer, dwarf::DW_AT_enum_class);
1428 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1430 void DwarfUnit::constructContainingTypeDIEs() {
1431 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1432 CE = ContainingTypeMap.end();
1434 DIE &SPDie = *CI->first;
1435 DIDescriptor D(CI->second);
1438 DIE *NDie = getDIE(D);
1441 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1445 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1446 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1447 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1448 StringRef Name = DT.getName();
1450 addString(MemberDie, dwarf::DW_AT_name, Name);
1452 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1454 addSourceLine(MemberDie, DT);
1456 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1458 // For C++, virtual base classes are not at fixed offset. Use following
1459 // expression to extract appropriate offset from vtable.
1460 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1462 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1463 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1464 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1465 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1466 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1467 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1468 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1469 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1471 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1473 uint64_t Size = DT.getSizeInBits();
1474 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1475 uint64_t OffsetInBytes;
1477 if (Size != FieldSize) {
1478 // Handle bitfield, assume bytes are 8 bits.
1479 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1480 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1482 uint64_t Offset = DT.getOffsetInBits();
1483 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1484 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1485 uint64_t FieldOffset = (HiMark - FieldSize);
1486 Offset -= FieldOffset;
1488 // Maybe we need to work from the other end.
1489 if (Asm->getDataLayout().isLittleEndian())
1490 Offset = FieldSize - (Offset + Size);
1491 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1493 // Here DW_AT_data_member_location points to the anonymous
1494 // field that includes this bit field.
1495 OffsetInBytes = FieldOffset >> 3;
1497 // This is not a bitfield.
1498 OffsetInBytes = DT.getOffsetInBits() >> 3;
1500 if (DD->getDwarfVersion() <= 2) {
1501 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1502 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1503 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1504 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1506 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1510 if (DT.isProtected())
1511 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1512 dwarf::DW_ACCESS_protected);
1513 else if (DT.isPrivate())
1514 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1515 dwarf::DW_ACCESS_private);
1516 // Otherwise C++ member and base classes are considered public.
1517 else if (DT.isPublic())
1518 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1519 dwarf::DW_ACCESS_public);
1521 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1522 dwarf::DW_VIRTUALITY_virtual);
1524 // Objective-C properties.
1525 if (MDNode *PNode = DT.getObjCProperty())
1526 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1527 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1530 if (DT.isArtificial())
1531 addFlag(MemberDie, dwarf::DW_AT_artificial);
1534 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1535 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1539 // Construct the context before querying for the existence of the DIE in case
1540 // such construction creates the DIE.
1541 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1542 assert(dwarf::isType(ContextDIE->getTag()) &&
1543 "Static member should belong to a type.");
1545 if (DIE *StaticMemberDIE = getDIE(DT))
1546 return StaticMemberDIE;
1548 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1550 DIType Ty = resolve(DT.getTypeDerivedFrom());
1552 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1553 addType(StaticMemberDIE, Ty);
1554 addSourceLine(StaticMemberDIE, DT);
1555 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1556 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1558 // FIXME: We could omit private if the parent is a class_type, and
1559 // public if the parent is something else.
1560 if (DT.isProtected())
1561 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562 dwarf::DW_ACCESS_protected);
1563 else if (DT.isPrivate())
1564 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1565 dwarf::DW_ACCESS_private);
1566 else if (DT.isPublic())
1567 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1568 dwarf::DW_ACCESS_public);
1570 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1571 addConstantValue(StaticMemberDIE, CI, Ty);
1572 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1573 addConstantFPValue(StaticMemberDIE, CFP);
1575 return &StaticMemberDIE;
1578 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1579 // Emit size of content not including length itself
1580 Asm->OutStreamer.AddComment("Length of Unit");
1581 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1583 Asm->OutStreamer.AddComment("DWARF version number");
1584 Asm->EmitInt16(DD->getDwarfVersion());
1585 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1586 // We share one abbreviations table across all units so it's always at the
1587 // start of the section. Use a relocatable offset where needed to ensure
1588 // linking doesn't invalidate that offset.
1590 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1592 // Use a constant value when no symbol is provided.
1594 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1595 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1598 void DwarfUnit::initSection(const MCSection *Section) {
1599 assert(!this->Section);
1600 this->Section = Section;
1603 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1604 DwarfUnit::emitHeader(ASectionSym);
1605 Asm->OutStreamer.AddComment("Type Signature");
1606 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1607 Asm->OutStreamer.AddComment("Type DIE Offset");
1608 // In a skeleton type unit there is no type DIE so emit a zero offset.
1609 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1610 sizeof(Ty->getOffset()));
1613 bool DwarfTypeUnit::isDwoUnit() const {
1614 // Since there are no skeleton type units, all type units are dwo type units
1615 // when split DWARF is being used.
1616 return DD->useSplitDwarf();