Make DwarfExpression store the AsmPrinter instead of the TargetMachine.
[opencl/llvm.git] / lib / CodeGen / AsmPrinter / DwarfUnit.cpp
1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for constructing a dwarf compile unit.
11 //
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"
38 using namespace llvm;
40 #define DEBUG_TYPE "dwarfdebug"
42 static cl::opt<bool>
43 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
44                        cl::desc("Generate DWARF4 type units."),
45                        cl::init(false));
47 /// DwarfExpression implementation for DwarfUnit.
48 class DIEDwarfExpression : public DwarfExpression {
49   DwarfUnit &DU;
50   DIELoc &DIE;
51 public:
52   DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU, DIELoc &DIE)
53   : DwarfExpression(AP), DU(DU), DIE(DIE) {}
55   void EmitOp(uint8_t Op, const char* Comment = nullptr) override;
56   void EmitSigned(int Value) override;
57   void EmitUnsigned(unsigned Value) override;
58   unsigned getFrameRegister() override;
59 };
61 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
62   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
63 }
64 void DIEDwarfExpression::EmitSigned(int Value) {
65   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
66 }
67 void DIEDwarfExpression::EmitUnsigned(unsigned Value) {
68   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
69 }
70 unsigned DIEDwarfExpression::getFrameRegister() {
71   return getTRI()->getFrameRegister(*AP.MF);
72 }
75 /// Unit - Unit constructor.
76 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
77                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
78     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
79       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
80   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
81          UnitTag == dwarf::DW_TAG_type_unit);
82   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
83 }
85 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
86                              DwarfDebug *DW, DwarfFile *DWU,
87                              MCDwarfDwoLineTable *SplitLineTable)
88     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
89       CU(CU), SplitLineTable(SplitLineTable) {
90   if (SplitLineTable)
91     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
92 }
94 /// ~Unit - Destructor for compile unit.
95 DwarfUnit::~DwarfUnit() {
96   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
97     DIEBlocks[j]->~DIEBlock();
98   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
99     DIELocs[j]->~DIELoc();
102 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
103 /// information entry.
104 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
105   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
106   return Value;
109 /// getDefaultLowerBound - Return the default lower bound for an array. If the
110 /// DWARF version doesn't handle the language, return -1.
111 int64_t DwarfUnit::getDefaultLowerBound() const {
112   switch (getLanguage()) {
113   default:
114     break;
116   case dwarf::DW_LANG_C89:
117   case dwarf::DW_LANG_C99:
118   case dwarf::DW_LANG_C:
119   case dwarf::DW_LANG_C_plus_plus:
120   case dwarf::DW_LANG_ObjC:
121   case dwarf::DW_LANG_ObjC_plus_plus:
122     return 0;
124   case dwarf::DW_LANG_Fortran77:
125   case dwarf::DW_LANG_Fortran90:
126   case dwarf::DW_LANG_Fortran95:
127     return 1;
129   // The languages below have valid values only if the DWARF version >= 4.
130   case dwarf::DW_LANG_Java:
131   case dwarf::DW_LANG_Python:
132   case dwarf::DW_LANG_UPC:
133   case dwarf::DW_LANG_D:
134     if (dwarf::DWARF_VERSION >= 4)
135       return 0;
136     break;
138   case dwarf::DW_LANG_Ada83:
139   case dwarf::DW_LANG_Ada95:
140   case dwarf::DW_LANG_Cobol74:
141   case dwarf::DW_LANG_Cobol85:
142   case dwarf::DW_LANG_Modula2:
143   case dwarf::DW_LANG_Pascal83:
144   case dwarf::DW_LANG_PLI:
145     if (dwarf::DWARF_VERSION >= 4)
146       return 1;
147     break;
148   }
150   return -1;
153 /// Check whether the DIE for this MDNode can be shared across CUs.
154 static bool isShareableAcrossCUs(DIDescriptor D) {
155   // When the MDNode can be part of the type system, the DIE can be shared
156   // across CUs.
157   // Combining type units and cross-CU DIE sharing is lower value (since
158   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
159   // level already) but may be implementable for some value in projects
160   // building multiple independent libraries with LTO and then linking those
161   // together.
162   return (D.isType() ||
163           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
164          !GenerateDwarfTypeUnits;
167 /// getDIE - Returns the debug information entry map slot for the
168 /// specified debug variable. We delegate the request to DwarfDebug
169 /// when the DIE for this MDNode can be shared across CUs. The mappings
170 /// will be kept in DwarfDebug for shareable DIEs.
171 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
172   if (isShareableAcrossCUs(D))
173     return DU->getDIE(D);
174   return MDNodeToDieMap.lookup(D);
177 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
178 /// when the DIE for this MDNode can be shared across CUs. The mappings
179 /// will be kept in DwarfDebug for shareable DIEs.
180 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
181   if (isShareableAcrossCUs(Desc)) {
182     DU->insertDIE(Desc, D);
183     return;
184   }
185   MDNodeToDieMap.insert(std::make_pair(Desc, D));
188 /// addFlag - Add a flag that is true.
189 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
190   if (DD->getDwarfVersion() >= 4)
191     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
192   else
193     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
196 /// addUInt - Add an unsigned integer attribute data and value.
197 ///
198 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
199                         Optional<dwarf::Form> Form, uint64_t Integer) {
200   if (!Form)
201     Form = DIEInteger::BestForm(false, Integer);
202   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
203                         DIEInteger(Integer);
204   Die.addValue(Attribute, *Form, Value);
207 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
208   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
211 /// addSInt - Add an signed integer attribute data and value.
212 ///
213 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
214                         Optional<dwarf::Form> Form, int64_t Integer) {
215   if (!Form)
216     Form = DIEInteger::BestForm(true, Integer);
217   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
218   Die.addValue(Attribute, *Form, Value);
221 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
222                         int64_t Integer) {
223   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
226 /// addString - Add a string attribute data and value. We always emit a
227 /// reference to the string pool instead of immediate strings so that DIEs have
228 /// more predictable sizes. In the case of split dwarf we emit an index
229 /// into another table which gets us the static offset into the string
230 /// table.
231 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
232                           StringRef String) {
233   if (!isDwoUnit())
234     return addLocalString(Die, Attribute, String);
236   addIndexedString(Die, Attribute, String);
239 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
240                                  StringRef String) {
241   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
242   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
243   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
244   Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
247 /// addLocalString - Add a string attribute data and value. This is guaranteed
248 /// to be in the local string pool instead of indirected.
249 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
250                                StringRef String) {
251   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
252   DIEValue *Value;
253   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
254     Value = new (DIEValueAllocator) DIELabel(Symb);
255   else
256     Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
257   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
258   Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
261 /// addLabel - Add a Dwarf label attribute data and value.
262 ///
263 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
264                          const MCSymbol *Label) {
265   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
266   Die.addValue(Attribute, Form, Value);
269 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
270   addLabel(Die, (dwarf::Attribute)0, Form, Label);
273 /// addSectionOffset - Add an offset into a section attribute data and value.
274 ///
275 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
276                                  uint64_t Integer) {
277   if (DD->getDwarfVersion() >= 4)
278     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
279   else
280     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
283 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
284   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
285                         : getCU().getOrCreateSourceID(FileName, DirName);
288 /// addOpAddress - Add a dwarf op address data and value using the
289 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
290 ///
291 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
292   if (!DD->useSplitDwarf()) {
293     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
294     addLabel(Die, dwarf::DW_FORM_udata, Sym);
295   } else {
296     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
297     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
298             DD->getAddressPool().getIndex(Sym));
299   }
302 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
303                               const MCSymbol *Hi, const MCSymbol *Lo) {
304   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
305   Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
308 /// addDIEEntry - Add a DIE attribute data and value.
309 ///
310 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
311   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
314 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
315   // Flag the type unit reference as a declaration so that if it contains
316   // members (implicit special members, static data member definitions, member
317   // declarations for definitions in this CU, etc) consumers don't get confused
318   // and think this is a full definition.
319   addFlag(Die, dwarf::DW_AT_declaration);
321   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
322                new (DIEValueAllocator) DIETypeSignature(Type));
325 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
326                             DIEEntry *Entry) {
327   const DIE *DieCU = Die.getUnitOrNull();
328   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
329   if (!DieCU)
330     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
331     DieCU = &getUnitDie();
332   if (!EntryCU)
333     EntryCU = &getUnitDie();
334   Die.addValue(Attribute,
335                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
336                Entry);
339 /// Create a DIE with the given Tag, add the DIE to its parent, and
340 /// call insertDIE if MD is not null.
341 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
342   assert(Tag != dwarf::DW_TAG_auto_variable &&
343          Tag != dwarf::DW_TAG_arg_variable);
344   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
345   DIE &Die = *Parent.getChildren().back();
346   if (N)
347     insertDIE(N, &Die);
348   return Die;
351 /// addBlock - Add block data.
352 ///
353 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
354   Loc->ComputeSize(Asm);
355   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
356   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
359 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
360                          DIEBlock *Block) {
361   Block->ComputeSize(Asm);
362   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
363   Die.addValue(Attribute, Block->BestForm(), Block);
366 /// addSourceLine - Add location information to specified debug information
367 /// entry.
368 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
369                               StringRef Directory) {
370   if (Line == 0)
371     return;
373   unsigned FileID = getOrCreateSourceID(File, Directory);
374   assert(FileID && "Invalid file id");
375   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
376   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
379 /// addSourceLine - Add location information to specified debug information
380 /// entry.
381 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
382   assert(V.isVariable());
384   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
385                 V.getContext().getDirectory());
388 /// addSourceLine - Add location information to specified debug information
389 /// entry.
390 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
391   assert(G.isGlobalVariable());
393   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
396 /// addSourceLine - Add location information to specified debug information
397 /// entry.
398 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
399   assert(SP.isSubprogram());
401   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
404 /// addSourceLine - Add location information to specified debug information
405 /// entry.
406 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
407   assert(Ty.isType());
409   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
412 /// addSourceLine - Add location information to specified debug information
413 /// entry.
414 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
415   assert(Ty.isObjCProperty());
417   DIFile File = Ty.getFile();
418   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
419                 File.getDirectory());
422 /// addSourceLine - Add location information to specified debug information
423 /// entry.
424 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
425   assert(NS.Verify());
427   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
430 /// addRegisterOp - Add register operand.
431 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
432                                    unsigned SizeInBits, unsigned OffsetInBits) {
433   DIEDwarfExpression Expr(*Asm, *this, TheDie);
434   Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
435   return true;
438 /// addRegisterOffset - Add register offset.
439 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
440                                   int64_t Offset) {
441   DIEDwarfExpression Expr(*Asm, *this, TheDie);
442   return Expr.AddMachineRegIndirect(Reg, Offset);
445 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
446    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
447    gives the variable VarName either the struct, or a pointer to the struct, as
448    its type.  This is necessary for various behind-the-scenes things the
449    compiler needs to do with by-reference variables in Blocks.
451    However, as far as the original *programmer* is concerned, the variable
452    should still have type 'SomeType', as originally declared.
454    The function getBlockByrefType dives into the __Block_byref_x_VarName
455    struct to find the original type of the variable, which is then assigned to
456    the variable's Debug Information Entry as its real type.  So far, so good.
457    However now the debugger will expect the variable VarName to have the type
458    SomeType.  So we need the location attribute for the variable to be an
459    expression that explains to the debugger how to navigate through the
460    pointers and struct to find the actual variable of type SomeType.
462    The following function does just that.  We start by getting
463    the "normal" location for the variable. This will be the location
464    of either the struct __Block_byref_x_VarName or the pointer to the
465    struct __Block_byref_x_VarName.
467    The struct will look something like:
469    struct __Block_byref_x_VarName {
470      ... <various fields>
471      struct __Block_byref_x_VarName *forwarding;
472      ... <various other fields>
473      SomeType VarName;
474      ... <maybe more fields>
475    };
477    If we are given the struct directly (as our starting point) we
478    need to tell the debugger to:
480    1).  Add the offset of the forwarding field.
482    2).  Follow that pointer to get the real __Block_byref_x_VarName
483    struct to use (the real one may have been copied onto the heap).
485    3).  Add the offset for the field VarName, to find the actual variable.
487    If we started with a pointer to the struct, then we need to
488    dereference that pointer first, before the other steps.
489    Translating this into DWARF ops, we will need to append the following
490    to the current location description for the variable:
492    DW_OP_deref                    -- optional, if we start with a pointer
493    DW_OP_plus_uconst <forward_fld_offset>
494    DW_OP_deref
495    DW_OP_plus_uconst <varName_fld_offset>
497    That is what this function does.  */
499 /// addBlockByrefAddress - Start with the address based on the location
500 /// provided, and generate the DWARF information necessary to find the
501 /// actual Block variable (navigating the Block struct) based on the
502 /// starting location.  Add the DWARF information to the die.  For
503 /// more information, read large comment just above here.
504 ///
505 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
506                                      dwarf::Attribute Attribute,
507                                      const MachineLocation &Location) {
508   DIType Ty = DV.getType();
509   DIType TmpTy = Ty;
510   uint16_t Tag = Ty.getTag();
511   bool isPointer = false;
513   StringRef varName = DV.getName();
515   if (Tag == dwarf::DW_TAG_pointer_type) {
516     DIDerivedType DTy(Ty);
517     TmpTy = resolve(DTy.getTypeDerivedFrom());
518     isPointer = true;
519   }
521   DICompositeType blockStruct(TmpTy);
523   // Find the __forwarding field and the variable field in the __Block_byref
524   // struct.
525   DIArray Fields = blockStruct.getElements();
526   DIDerivedType varField;
527   DIDerivedType forwardingField;
529   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
530     DIDerivedType DT(Fields.getElement(i));
531     StringRef fieldName = DT.getName();
532     if (fieldName == "__forwarding")
533       forwardingField = DT;
534     else if (fieldName == varName)
535       varField = DT;
536   }
538   // Get the offsets for the forwarding field and the variable field.
539   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
540   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
542   // Decode the original location, and use that as the start of the byref
543   // variable's location.
544   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
546   bool validReg;
547   if (Location.isReg())
548     validReg = addRegisterOpPiece(*Loc, Location.getReg());
549   else
550     validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
552   if (!validReg)
553     return;
555   // If we started with a pointer to the __Block_byref... struct, then
556   // the first thing we need to do is dereference the pointer (DW_OP_deref).
557   if (isPointer)
558     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
560   // Next add the offset for the '__forwarding' field:
561   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
562   // adding the offset if it's 0.
563   if (forwardingFieldOffset > 0) {
564     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
565     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
566   }
568   // Now dereference the __forwarding field to get to the real __Block_byref
569   // struct:  DW_OP_deref.
570   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
572   // Now that we've got the real __Block_byref... struct, add the offset
573   // for the variable's field to get to the location of the actual variable:
574   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
575   if (varFieldOffset > 0) {
576     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
577     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
578   }
580   // Now attach the location information to the DIE.
581   addBlock(Die, Attribute, Loc);
584 /// Return true if type encoding is unsigned.
585 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
586   DIDerivedType DTy(Ty);
587   if (DTy.isDerivedType()) {
588     dwarf::Tag T = (dwarf::Tag)Ty.getTag();
589     // Encode pointer constants as unsigned bytes. This is used at least for
590     // null pointer constant emission.
591     // (Pieces of) aggregate types that get hacked apart by SROA may also be
592     // represented by a constant. Encode them as unsigned bytes.
593     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
594     // here, but accept them for now due to a bug in SROA producing bogus
595     // dbg.values.
596     if (T == dwarf::DW_TAG_array_type ||
597         T == dwarf::DW_TAG_class_type ||
598         T == dwarf::DW_TAG_pointer_type ||
599         T == dwarf::DW_TAG_ptr_to_member_type ||
600         T == dwarf::DW_TAG_reference_type ||
601         T == dwarf::DW_TAG_rvalue_reference_type ||
602         T == dwarf::DW_TAG_structure_type)
603       return true;
604     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
605            T == dwarf::DW_TAG_volatile_type ||
606            T == dwarf::DW_TAG_restrict_type ||
607            T == dwarf::DW_TAG_enumeration_type);
608     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
609       return isUnsignedDIType(DD, DD->resolve(Deriv));
610     // FIXME: Enums without a fixed underlying type have unknown signedness
611     // here, leading to incorrectly emitted constants.
612     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
613     return false;
614   }
616   DIBasicType BTy(Ty);
617   assert(BTy.isBasicType());
618   unsigned Encoding = BTy.getEncoding();
619   assert((Encoding == dwarf::DW_ATE_unsigned ||
620           Encoding == dwarf::DW_ATE_unsigned_char ||
621           Encoding == dwarf::DW_ATE_signed ||
622           Encoding == dwarf::DW_ATE_signed_char ||
623           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
624           (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
625            Ty.getName() == "decltype(nullptr)")) &&
626          "Unsupported encoding");
627   return (Encoding == dwarf::DW_ATE_unsigned ||
628           Encoding == dwarf::DW_ATE_unsigned_char ||
629           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
630           Ty.getTag() == dwarf::DW_TAG_unspecified_type);
633 /// If this type is derived from a base type then return base type size.
634 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
635   unsigned Tag = Ty.getTag();
637   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
638       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
639       Tag != dwarf::DW_TAG_restrict_type)
640     return Ty.getSizeInBits();
642   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
644   // If this type is not derived from any type or the type is a declaration then
645   // take conservative approach.
646   if (!BaseType.isValid() || BaseType.isForwardDecl())
647     return Ty.getSizeInBits();
649   // If this is a derived type, go ahead and get the base type, unless it's a
650   // reference then it's just the size of the field. Pointer types have no need
651   // of this since they're a different type of qualification on the type.
652   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
653       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
654     return Ty.getSizeInBits();
656   if (BaseType.isDerivedType())
657     return getBaseTypeSize(DD, DIDerivedType(BaseType));
659   return BaseType.getSizeInBits();
662 /// addConstantFPValue - Add constant value entry in variable DIE.
663 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
664   assert(MO.isFPImm() && "Invalid machine operand!");
665   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
666   APFloat FPImm = MO.getFPImm()->getValueAPF();
668   // Get the raw data form of the floating point.
669   const APInt FltVal = FPImm.bitcastToAPInt();
670   const char *FltPtr = (const char *)FltVal.getRawData();
672   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
673   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
674   int Incr = (LittleEndian ? 1 : -1);
675   int Start = (LittleEndian ? 0 : NumBytes - 1);
676   int Stop = (LittleEndian ? NumBytes : -1);
678   // Output the constant to DWARF one byte at a time.
679   for (; Start != Stop; Start += Incr)
680     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
682   addBlock(Die, dwarf::DW_AT_const_value, Block);
685 /// addConstantFPValue - Add constant value entry in variable DIE.
686 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
687   // Pass this down to addConstantValue as an unsigned bag of bits.
688   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
691 /// addConstantValue - Add constant value entry in variable DIE.
692 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
693   addConstantValue(Die, CI->getValue(), Ty);
696 /// addConstantValue - Add constant value entry in variable DIE.
697 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
698                                  DIType Ty) {
699   assert(MO.isImm() && "Invalid machine operand!");
701   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
704 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
705   // FIXME: This is a bit conservative/simple - it emits negative values always
706   // sign extended to 64 bits rather than minimizing the number of bytes.
707   addUInt(Die, dwarf::DW_AT_const_value,
708           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
711 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
712   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
715 // addConstantValue - Add constant value entry in variable DIE.
716 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
717   unsigned CIBitWidth = Val.getBitWidth();
718   if (CIBitWidth <= 64) {
719     addConstantValue(Die, Unsigned,
720                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
721     return;
722   }
724   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
726   // Get the raw data form of the large APInt.
727   const uint64_t *Ptr64 = Val.getRawData();
729   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
730   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
732   // Output the constant to DWARF one byte at a time.
733   for (int i = 0; i < NumBytes; i++) {
734     uint8_t c;
735     if (LittleEndian)
736       c = Ptr64[i / 8] >> (8 * (i & 7));
737     else
738       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
739     addUInt(*Block, dwarf::DW_FORM_data1, c);
740   }
742   addBlock(Die, dwarf::DW_AT_const_value, Block);
745 /// addTemplateParams - Add template parameters into buffer.
746 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
747   // Add template parameters.
748   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
749     DIDescriptor Element = TParams.getElement(i);
750     if (Element.isTemplateTypeParameter())
751       constructTemplateTypeParameterDIE(Buffer,
752                                         DITemplateTypeParameter(Element));
753     else if (Element.isTemplateValueParameter())
754       constructTemplateValueParameterDIE(Buffer,
755                                          DITemplateValueParameter(Element));
756   }
759 /// getOrCreateContextDIE - Get context owner's DIE.
760 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
761   if (!Context || Context.isFile())
762     return &getUnitDie();
763   if (Context.isType())
764     return getOrCreateTypeDIE(DIType(Context));
765   if (Context.isNameSpace())
766     return getOrCreateNameSpace(DINameSpace(Context));
767   if (Context.isSubprogram())
768     return getOrCreateSubprogramDIE(DISubprogram(Context));
769   return getDIE(Context);
772 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
773   DIScope Context = resolve(Ty.getContext());
774   DIE *ContextDIE = getOrCreateContextDIE(Context);
776   if (DIE *TyDIE = getDIE(Ty))
777     return TyDIE;
779   // Create new type.
780   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
782   constructTypeDIE(TyDIE, Ty);
784   updateAcceleratorTables(Context, Ty, TyDIE);
785   return &TyDIE;
788 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
789 /// given DIType.
790 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
791   if (!TyNode)
792     return nullptr;
794   DIType Ty(TyNode);
795   assert(Ty.isType());
796   assert(Ty == resolve(Ty.getRef()) &&
797          "type was not uniqued, possible ODR violation.");
799   // DW_TAG_restrict_type is not supported in DWARF2
800   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
801     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
803   // Construct the context before querying for the existence of the DIE in case
804   // such construction creates the DIE.
805   DIScope Context = resolve(Ty.getContext());
806   DIE *ContextDIE = getOrCreateContextDIE(Context);
807   assert(ContextDIE);
809   if (DIE *TyDIE = getDIE(Ty))
810     return TyDIE;
812   // Create new type.
813   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
815   updateAcceleratorTables(Context, Ty, TyDIE);
817   if (Ty.isBasicType())
818     constructTypeDIE(TyDIE, DIBasicType(Ty));
819   else if (Ty.isCompositeType()) {
820     DICompositeType CTy(Ty);
821     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
822       if (MDString *TypeId = CTy.getIdentifier()) {
823         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
824         // Skip updating the accelerator tables since this is not the full type.
825         return &TyDIE;
826       }
827     constructTypeDIE(TyDIE, CTy);
828   } else {
829     assert(Ty.isDerivedType() && "Unknown kind of DIType");
830     constructTypeDIE(TyDIE, DIDerivedType(Ty));
831   }
833   return &TyDIE;
836 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
837                                         const DIE &TyDIE) {
838   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
839     bool IsImplementation = 0;
840     if (Ty.isCompositeType()) {
841       DICompositeType CT(Ty);
842       // A runtime language of 0 actually means C/C++ and that any
843       // non-negative value is some version of Objective-C/C++.
844       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
845     }
846     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
847     DD->addAccelType(Ty.getName(), TyDIE, Flags);
849     if (!Context || Context.isCompileUnit() || Context.isFile() ||
850         Context.isNameSpace())
851       addGlobalType(Ty, TyDIE, Context);
852   }
855 /// addType - Add a new type attribute to the specified entity.
856 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
857   assert(Ty && "Trying to add a type that doesn't exist?");
859   // Check for pre-existence.
860   DIEEntry *Entry = getDIEEntry(Ty);
861   // If it exists then use the existing value.
862   if (Entry) {
863     addDIEEntry(Entity, Attribute, Entry);
864     return;
865   }
867   // Construct type.
868   DIE *Buffer = getOrCreateTypeDIE(Ty);
870   // Set up proxy.
871   Entry = createDIEEntry(*Buffer);
872   insertDIEEntry(Ty, Entry);
873   addDIEEntry(Entity, Attribute, Entry);
876 /// getParentContextString - Walks the metadata parent chain in a language
877 /// specific manner (using the compile unit language) and returns
878 /// it as a string. This is done at the metadata level because DIEs may
879 /// not currently have been added to the parent context and walking the
880 /// DIEs looking for names is more expensive than walking the metadata.
881 std::string DwarfUnit::getParentContextString(DIScope Context) const {
882   if (!Context)
883     return "";
885   // FIXME: Decide whether to implement this for non-C++ languages.
886   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
887     return "";
889   std::string CS;
890   SmallVector<DIScope, 1> Parents;
891   while (!Context.isCompileUnit()) {
892     Parents.push_back(Context);
893     if (Context.getContext())
894       Context = resolve(Context.getContext());
895     else
896       // Structure, etc types will have a NULL context if they're at the top
897       // level.
898       break;
899   }
901   // Reverse iterate over our list to go from the outermost construct to the
902   // innermost.
903   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
904                                                   E = Parents.rend();
905        I != E; ++I) {
906     DIScope Ctx = *I;
907     StringRef Name = Ctx.getName();
908     if (Name.empty() && Ctx.isNameSpace())
909       Name = "(anonymous namespace)";
910     if (!Name.empty()) {
911       CS += Name;
912       CS += "::";
913     }
914   }
915   return CS;
918 /// constructTypeDIE - Construct basic type die from DIBasicType.
919 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
920   // Get core information.
921   StringRef Name = BTy.getName();
922   // Add name if not anonymous or intermediate type.
923   if (!Name.empty())
924     addString(Buffer, dwarf::DW_AT_name, Name);
926   // An unspecified type only has a name attribute.
927   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
928     return;
930   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
931           BTy.getEncoding());
933   uint64_t Size = BTy.getSizeInBits() >> 3;
934   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
937 /// constructTypeDIE - Construct derived type die from DIDerivedType.
938 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
939   // Get core information.
940   StringRef Name = DTy.getName();
941   uint64_t Size = DTy.getSizeInBits() >> 3;
942   uint16_t Tag = Buffer.getTag();
944   // Map to main type, void will not have a type.
945   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
946   if (FromTy)
947     addType(Buffer, FromTy);
949   // Add name if not anonymous or intermediate type.
950   if (!Name.empty())
951     addString(Buffer, dwarf::DW_AT_name, Name);
953   // Add size if non-zero (derived types might be zero-sized.)
954   if (Size && Tag != dwarf::DW_TAG_pointer_type
955            && Tag != dwarf::DW_TAG_ptr_to_member_type)
956     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
958   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
959     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
960                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
961   // Add source line info if available and TyDesc is not a forward declaration.
962   if (!DTy.isForwardDecl())
963     addSourceLine(Buffer, DTy);
966 /// constructSubprogramArguments - Construct function argument DIEs.
967 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
968   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
969     DIType Ty = resolve(Args.getElement(i));
970     if (!Ty) {
971       assert(i == N-1 && "Unspecified parameter must be the last argument");
972       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
973     } else {
974       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
975       addType(Arg, Ty);
976       if (Ty.isArtificial())
977         addFlag(Arg, dwarf::DW_AT_artificial);
978     }
979   }
982 /// constructTypeDIE - Construct type DIE from DICompositeType.
983 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
984   // Add name if not anonymous or intermediate type.
985   StringRef Name = CTy.getName();
987   uint64_t Size = CTy.getSizeInBits() >> 3;
988   uint16_t Tag = Buffer.getTag();
990   switch (Tag) {
991   case dwarf::DW_TAG_array_type:
992     constructArrayTypeDIE(Buffer, CTy);
993     break;
994   case dwarf::DW_TAG_enumeration_type:
995     constructEnumTypeDIE(Buffer, CTy);
996     break;
997   case dwarf::DW_TAG_subroutine_type: {
998     // Add return type. A void return won't have a type.
999     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1000     DIType RTy(resolve(Elements.getElement(0)));
1001     if (RTy)
1002       addType(Buffer, RTy);
1004     bool isPrototyped = true;
1005     if (Elements.getNumElements() == 2 &&
1006         !Elements.getElement(1))
1007       isPrototyped = false;
1009     constructSubprogramArguments(Buffer, Elements);
1011     // Add prototype flag if we're dealing with a C language and the
1012     // function has been prototyped.
1013     uint16_t Language = getLanguage();
1014     if (isPrototyped &&
1015         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1016          Language == dwarf::DW_LANG_ObjC))
1017       addFlag(Buffer, dwarf::DW_AT_prototyped);
1019     if (CTy.isLValueReference())
1020       addFlag(Buffer, dwarf::DW_AT_reference);
1022     if (CTy.isRValueReference())
1023       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1024   } break;
1025   case dwarf::DW_TAG_structure_type:
1026   case dwarf::DW_TAG_union_type:
1027   case dwarf::DW_TAG_class_type: {
1028     // Add elements to structure type.
1029     DIArray Elements = CTy.getElements();
1030     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1031       DIDescriptor Element = Elements.getElement(i);
1032       if (Element.isSubprogram())
1033         getOrCreateSubprogramDIE(DISubprogram(Element));
1034       else if (Element.isDerivedType()) {
1035         DIDerivedType DDTy(Element);
1036         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1037           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1038           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1039                   dwarf::DW_AT_friend);
1040         } else if (DDTy.isStaticMember()) {
1041           getOrCreateStaticMemberDIE(DDTy);
1042         } else {
1043           constructMemberDIE(Buffer, DDTy);
1044         }
1045       } else if (Element.isObjCProperty()) {
1046         DIObjCProperty Property(Element);
1047         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1048         StringRef PropertyName = Property.getObjCPropertyName();
1049         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1050         if (Property.getType())
1051           addType(ElemDie, Property.getType());
1052         addSourceLine(ElemDie, Property);
1053         StringRef GetterName = Property.getObjCPropertyGetterName();
1054         if (!GetterName.empty())
1055           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1056         StringRef SetterName = Property.getObjCPropertySetterName();
1057         if (!SetterName.empty())
1058           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1059         unsigned PropertyAttributes = 0;
1060         if (Property.isReadOnlyObjCProperty())
1061           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1062         if (Property.isReadWriteObjCProperty())
1063           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1064         if (Property.isAssignObjCProperty())
1065           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1066         if (Property.isRetainObjCProperty())
1067           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1068         if (Property.isCopyObjCProperty())
1069           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1070         if (Property.isNonAtomicObjCProperty())
1071           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1072         if (PropertyAttributes)
1073           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1074                   PropertyAttributes);
1076         DIEEntry *Entry = getDIEEntry(Element);
1077         if (!Entry) {
1078           Entry = createDIEEntry(ElemDie);
1079           insertDIEEntry(Element, Entry);
1080         }
1081       } else
1082         continue;
1083     }
1085     if (CTy.isAppleBlockExtension())
1086       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1088     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1089     // inside C++ composite types to point to the base class with the vtable.
1090     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1091     if (ContainingType)
1092       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1093                   *getOrCreateTypeDIE(ContainingType));
1095     if (CTy.isObjcClassComplete())
1096       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1098     // Add template parameters to a class, structure or union types.
1099     // FIXME: The support isn't in the metadata for this yet.
1100     if (Tag == dwarf::DW_TAG_class_type ||
1101         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1102       addTemplateParams(Buffer, CTy.getTemplateParams());
1104     break;
1105   }
1106   default:
1107     break;
1108   }
1110   // Add name if not anonymous or intermediate type.
1111   if (!Name.empty())
1112     addString(Buffer, dwarf::DW_AT_name, Name);
1114   if (Tag == dwarf::DW_TAG_enumeration_type ||
1115       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1116       Tag == dwarf::DW_TAG_union_type) {
1117     // Add size if non-zero (derived types might be zero-sized.)
1118     // TODO: Do we care about size for enum forward declarations?
1119     if (Size)
1120       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1121     else if (!CTy.isForwardDecl())
1122       // Add zero size if it is not a forward declaration.
1123       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1125     // If we're a forward decl, say so.
1126     if (CTy.isForwardDecl())
1127       addFlag(Buffer, dwarf::DW_AT_declaration);
1129     // Add source line info if available.
1130     if (!CTy.isForwardDecl())
1131       addSourceLine(Buffer, CTy);
1133     // No harm in adding the runtime language to the declaration.
1134     unsigned RLang = CTy.getRunTimeLang();
1135     if (RLang)
1136       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1137               RLang);
1138   }
1141 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1142 /// DITemplateTypeParameter.
1143 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1144                                                   DITemplateTypeParameter TP) {
1145   DIE &ParamDIE =
1146       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1147   // Add the type if it exists, it could be void and therefore no type.
1148   if (TP.getType())
1149     addType(ParamDIE, resolve(TP.getType()));
1150   if (!TP.getName().empty())
1151     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1154 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1155 /// DITemplateValueParameter.
1156 void
1157 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1158                                               DITemplateValueParameter VP) {
1159   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1161   // Add the type if there is one, template template and template parameter
1162   // packs will not have a type.
1163   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1164     addType(ParamDIE, resolve(VP.getType()));
1165   if (!VP.getName().empty())
1166     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1167   if (Metadata *Val = VP.getValue()) {
1168     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1169       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1170     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1171       // For declaration non-type template parameters (such as global values and
1172       // functions)
1173       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1174       addOpAddress(*Loc, Asm->getSymbol(GV));
1175       // Emit DW_OP_stack_value to use the address as the immediate value of the
1176       // parameter, rather than a pointer to it.
1177       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1178       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1179     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1180       assert(isa<MDString>(Val));
1181       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1182                 cast<MDString>(Val)->getString());
1183     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1184       assert(isa<MDNode>(Val));
1185       DIArray A(cast<MDNode>(Val));
1186       addTemplateParams(ParamDIE, A);
1187     }
1188   }
1191 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1192 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1193   // Construct the context before querying for the existence of the DIE in case
1194   // such construction creates the DIE.
1195   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1197   if (DIE *NDie = getDIE(NS))
1198     return NDie;
1199   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1201   StringRef Name = NS.getName();
1202   if (!Name.empty())
1203     addString(NDie, dwarf::DW_AT_name, NS.getName());
1204   else
1205     Name = "(anonymous namespace)";
1206   DD->addAccelNamespace(Name, NDie);
1207   addGlobalName(Name, NDie, NS.getContext());
1208   addSourceLine(NDie, NS);
1209   return &NDie;
1212 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1213 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1214   // Construct the context before querying for the existence of the DIE in case
1215   // such construction creates the DIE (as is the case for member function
1216   // declarations).
1217   DIE *ContextDIE =
1218       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1220   if (DIE *SPDie = getDIE(SP))
1221     return SPDie;
1223   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1224     if (!Minimal) {
1225       // Add subprogram definitions to the CU die directly.
1226       ContextDIE = &getUnitDie();
1227       // Build the decl now to ensure it precedes the definition.
1228       getOrCreateSubprogramDIE(SPDecl);
1229     }
1230   }
1232   // DW_TAG_inlined_subroutine may refer to this DIE.
1233   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1235   // Stop here and fill this in later, depending on whether or not this
1236   // subprogram turns out to have inlined instances or not.
1237   if (SP.isDefinition())
1238     return &SPDie;
1240   applySubprogramAttributes(SP, SPDie);
1241   return &SPDie;
1244 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1245                                                     DIE &SPDie) {
1246   DIE *DeclDie = nullptr;
1247   StringRef DeclLinkageName;
1248   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1249     DeclDie = getDIE(SPDecl);
1250     assert(DeclDie && "This DIE should've already been constructed when the "
1251                       "definition DIE was created in "
1252                       "getOrCreateSubprogramDIE");
1253     DeclLinkageName = SPDecl.getLinkageName();
1254   }
1256   // Add function template parameters.
1257   addTemplateParams(SPDie, SP.getTemplateParams());
1259   // Add the linkage name if we have one and it isn't in the Decl.
1260   StringRef LinkageName = SP.getLinkageName();
1261   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1262           LinkageName == DeclLinkageName) &&
1263          "decl has a linkage name and it is different");
1264   if (!LinkageName.empty() && DeclLinkageName.empty())
1265     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1266               GlobalValue::getRealLinkageName(LinkageName));
1268   if (!DeclDie)
1269     return false;
1271   // Refer to the function declaration where all the other attributes will be
1272   // found.
1273   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1274   return true;
1277 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1278                                           bool Minimal) {
1279   if (!Minimal)
1280     if (applySubprogramDefinitionAttributes(SP, SPDie))
1281       return;
1283   // Constructors and operators for anonymous aggregates do not have names.
1284   if (!SP.getName().empty())
1285     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1287   // Skip the rest of the attributes under -gmlt to save space.
1288   if (Minimal)
1289     return;
1291   addSourceLine(SPDie, SP);
1293   // Add the prototype if we have a prototype and we have a C like
1294   // language.
1295   uint16_t Language = getLanguage();
1296   if (SP.isPrototyped() &&
1297       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1298        Language == dwarf::DW_LANG_ObjC))
1299     addFlag(SPDie, dwarf::DW_AT_prototyped);
1301   DISubroutineType SPTy = SP.getType();
1302   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1303          "the type of a subprogram should be a subroutine");
1305   DITypeArray Args = SPTy.getTypeArray();
1306   // Add a return type. If this is a type like a C/C++ void type we don't add a
1307   // return type.
1308   if (resolve(Args.getElement(0)))
1309     addType(SPDie, DIType(resolve(Args.getElement(0))));
1311   unsigned VK = SP.getVirtuality();
1312   if (VK) {
1313     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1314     DIELoc *Block = getDIELoc();
1315     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1316     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1317     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1318     ContainingTypeMap.insert(
1319         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1320   }
1322   if (!SP.isDefinition()) {
1323     addFlag(SPDie, dwarf::DW_AT_declaration);
1325     // Add arguments. Do not add arguments for subprogram definition. They will
1326     // be handled while processing variables.
1327     constructSubprogramArguments(SPDie, Args);
1328   }
1330   if (SP.isArtificial())
1331     addFlag(SPDie, dwarf::DW_AT_artificial);
1333   if (!SP.isLocalToUnit())
1334     addFlag(SPDie, dwarf::DW_AT_external);
1336   if (SP.isOptimized())
1337     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1339   if (unsigned isa = Asm->getISAEncoding()) {
1340     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1341   }
1343   if (SP.isLValueReference())
1344     addFlag(SPDie, dwarf::DW_AT_reference);
1346   if (SP.isRValueReference())
1347     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1349   if (SP.isProtected())
1350     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1351             dwarf::DW_ACCESS_protected);
1352   else if (SP.isPrivate())
1353     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1354             dwarf::DW_ACCESS_private);
1355   else if (SP.isPublic())
1356     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1357             dwarf::DW_ACCESS_public);
1359   if (SP.isExplicit())
1360     addFlag(SPDie, dwarf::DW_AT_explicit);
1363 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1364 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1365   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1366   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1368   // The LowerBound value defines the lower bounds which is typically zero for
1369   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1370   // Count == -1 then the array is unbounded and we do not emit
1371   // DW_AT_lower_bound and DW_AT_count attributes.
1372   int64_t LowerBound = SR.getLo();
1373   int64_t DefaultLowerBound = getDefaultLowerBound();
1374   int64_t Count = SR.getCount();
1376   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1377     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1379   if (Count != -1)
1380     // FIXME: An unbounded array should reference the expression that defines
1381     // the array.
1382     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1385 DIE *DwarfUnit::getIndexTyDie() {
1386   if (IndexTyDie)
1387     return IndexTyDie;
1388   // Construct an integer type to use for indexes.
1389   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1390   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1391   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1392   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1393           dwarf::DW_ATE_unsigned);
1394   return IndexTyDie;
1397 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1398 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1399   if (CTy.isVector())
1400     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1402   // Emit the element type.
1403   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1405   // Get an anonymous type for index type.
1406   // FIXME: This type should be passed down from the front end
1407   // as different languages may have different sizes for indexes.
1408   DIE *IdxTy = getIndexTyDie();
1410   // Add subranges to array type.
1411   DIArray Elements = CTy.getElements();
1412   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1413     DIDescriptor Element = Elements.getElement(i);
1414     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1415       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1416   }
1419 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1420 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1421   DIArray Elements = CTy.getElements();
1423   // Add enumerators to enumeration type.
1424   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1425     DIEnumerator Enum(Elements.getElement(i));
1426     if (Enum.isEnumerator()) {
1427       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1428       StringRef Name = Enum.getName();
1429       addString(Enumerator, dwarf::DW_AT_name, Name);
1430       int64_t Value = Enum.getEnumValue();
1431       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1432               Value);
1433     }
1434   }
1435   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1436   if (DTy) {
1437     addType(Buffer, DTy);
1438     addFlag(Buffer, dwarf::DW_AT_enum_class);
1439   }
1442 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1443 /// vtables.
1444 void DwarfUnit::constructContainingTypeDIEs() {
1445   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1446                                                  CE = ContainingTypeMap.end();
1447        CI != CE; ++CI) {
1448     DIE &SPDie = *CI->first;
1449     DIDescriptor D(CI->second);
1450     if (!D)
1451       continue;
1452     DIE *NDie = getDIE(D);
1453     if (!NDie)
1454       continue;
1455     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1456   }
1459 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1460 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1461   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1462   StringRef Name = DT.getName();
1463   if (!Name.empty())
1464     addString(MemberDie, dwarf::DW_AT_name, Name);
1466   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1468   addSourceLine(MemberDie, DT);
1470   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1472     // For C++, virtual base classes are not at fixed offset. Use following
1473     // expression to extract appropriate offset from vtable.
1474     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1476     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1477     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1478     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1479     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1480     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1481     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1482     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1483     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1485     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1486   } else {
1487     uint64_t Size = DT.getSizeInBits();
1488     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1489     uint64_t OffsetInBytes;
1491     if (Size != FieldSize) {
1492       // Handle bitfield, assume bytes are 8 bits.
1493       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1494       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1496       uint64_t Offset = DT.getOffsetInBits();
1497       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1498       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1499       uint64_t FieldOffset = (HiMark - FieldSize);
1500       Offset -= FieldOffset;
1502       // Maybe we need to work from the other end.
1503       if (Asm->getDataLayout().isLittleEndian())
1504         Offset = FieldSize - (Offset + Size);
1505       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1507       // Here DW_AT_data_member_location points to the anonymous
1508       // field that includes this bit field.
1509       OffsetInBytes = FieldOffset >> 3;
1510     } else
1511       // This is not a bitfield.
1512       OffsetInBytes = DT.getOffsetInBits() >> 3;
1514     if (DD->getDwarfVersion() <= 2) {
1515       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1516       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1517       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1518       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1519     } else
1520       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1521               OffsetInBytes);
1522   }
1524   if (DT.isProtected())
1525     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1526             dwarf::DW_ACCESS_protected);
1527   else if (DT.isPrivate())
1528     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1529             dwarf::DW_ACCESS_private);
1530   // Otherwise C++ member and base classes are considered public.
1531   else if (DT.isPublic())
1532     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1533             dwarf::DW_ACCESS_public);
1534   if (DT.isVirtual())
1535     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1536             dwarf::DW_VIRTUALITY_virtual);
1538   // Objective-C properties.
1539   if (MDNode *PNode = DT.getObjCProperty())
1540     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1541       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1542                          PropertyDie);
1544   if (DT.isArtificial())
1545     addFlag(MemberDie, dwarf::DW_AT_artificial);
1548 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1549 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1550   if (!DT.Verify())
1551     return nullptr;
1553   // Construct the context before querying for the existence of the DIE in case
1554   // such construction creates the DIE.
1555   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1556   assert(dwarf::isType(ContextDIE->getTag()) &&
1557          "Static member should belong to a type.");
1559   if (DIE *StaticMemberDIE = getDIE(DT))
1560     return StaticMemberDIE;
1562   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1564   DIType Ty = resolve(DT.getTypeDerivedFrom());
1566   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1567   addType(StaticMemberDIE, Ty);
1568   addSourceLine(StaticMemberDIE, DT);
1569   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1570   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1572   // FIXME: We could omit private if the parent is a class_type, and
1573   // public if the parent is something else.
1574   if (DT.isProtected())
1575     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1576             dwarf::DW_ACCESS_protected);
1577   else if (DT.isPrivate())
1578     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1579             dwarf::DW_ACCESS_private);
1580   else if (DT.isPublic())
1581     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1582             dwarf::DW_ACCESS_public);
1584   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1585     addConstantValue(StaticMemberDIE, CI, Ty);
1586   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1587     addConstantFPValue(StaticMemberDIE, CFP);
1589   return &StaticMemberDIE;
1592 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1593   // Emit size of content not including length itself
1594   Asm->OutStreamer.AddComment("Length of Unit");
1595   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1597   Asm->OutStreamer.AddComment("DWARF version number");
1598   Asm->EmitInt16(DD->getDwarfVersion());
1599   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1600   // We share one abbreviations table across all units so it's always at the
1601   // start of the section. Use a relocatable offset where needed to ensure
1602   // linking doesn't invalidate that offset.
1603   if (ASectionSym)
1604     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1605   else
1606     // Use a constant value when no symbol is provided.
1607     Asm->EmitInt32(0);
1608   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1609   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1612 void DwarfUnit::initSection(const MCSection *Section) {
1613   assert(!this->Section);
1614   this->Section = Section;
1617 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1618   DwarfUnit::emitHeader(ASectionSym);
1619   Asm->OutStreamer.AddComment("Type Signature");
1620   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1621   Asm->OutStreamer.AddComment("Type DIE Offset");
1622   // In a skeleton type unit there is no type DIE so emit a zero offset.
1623   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1624                                 sizeof(Ty->getOffset()));
1627 bool DwarfTypeUnit::isDwoUnit() const {
1628   // Since there are no skeleton type units, all type units are dwo type units
1629   // when split DWARF is being used.
1630   return DD->useSplitDwarf();