Debug Info: In symmetry to DW_TAG_pointer_type, do not emit the byte size
[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 "llvm/ADT/APFloat.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DIBuilder.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Mangler.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetSubtargetInfo.h"
37 using namespace llvm;
39 #define DEBUG_TYPE "dwarfdebug"
41 static cl::opt<bool>
42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
43                        cl::desc("Generate DWARF4 type units."),
44                        cl::init(false));
46 /// Unit - Unit constructor.
47 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
48                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
49     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
50       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
51   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
52          UnitTag == dwarf::DW_TAG_type_unit);
53   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
54 }
56 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
57                              DwarfDebug *DW, DwarfFile *DWU,
58                              MCDwarfDwoLineTable *SplitLineTable)
59     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
60       CU(CU), SplitLineTable(SplitLineTable) {
61   if (SplitLineTable)
62     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
63 }
65 /// ~Unit - Destructor for compile unit.
66 DwarfUnit::~DwarfUnit() {
67   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
68     DIEBlocks[j]->~DIEBlock();
69   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
70     DIELocs[j]->~DIELoc();
71 }
73 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
74 /// information entry.
75 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
76   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
77   return Value;
78 }
80 /// getDefaultLowerBound - Return the default lower bound for an array. If the
81 /// DWARF version doesn't handle the language, return -1.
82 int64_t DwarfUnit::getDefaultLowerBound() const {
83   switch (getLanguage()) {
84   default:
85     break;
87   case dwarf::DW_LANG_C89:
88   case dwarf::DW_LANG_C99:
89   case dwarf::DW_LANG_C:
90   case dwarf::DW_LANG_C_plus_plus:
91   case dwarf::DW_LANG_ObjC:
92   case dwarf::DW_LANG_ObjC_plus_plus:
93     return 0;
95   case dwarf::DW_LANG_Fortran77:
96   case dwarf::DW_LANG_Fortran90:
97   case dwarf::DW_LANG_Fortran95:
98     return 1;
100   // The languages below have valid values only if the DWARF version >= 4.
101   case dwarf::DW_LANG_Java:
102   case dwarf::DW_LANG_Python:
103   case dwarf::DW_LANG_UPC:
104   case dwarf::DW_LANG_D:
105     if (dwarf::DWARF_VERSION >= 4)
106       return 0;
107     break;
109   case dwarf::DW_LANG_Ada83:
110   case dwarf::DW_LANG_Ada95:
111   case dwarf::DW_LANG_Cobol74:
112   case dwarf::DW_LANG_Cobol85:
113   case dwarf::DW_LANG_Modula2:
114   case dwarf::DW_LANG_Pascal83:
115   case dwarf::DW_LANG_PLI:
116     if (dwarf::DWARF_VERSION >= 4)
117       return 1;
118     break;
119   }
121   return -1;
124 /// Check whether the DIE for this MDNode can be shared across CUs.
125 static bool isShareableAcrossCUs(DIDescriptor D) {
126   // When the MDNode can be part of the type system, the DIE can be shared
127   // across CUs.
128   // Combining type units and cross-CU DIE sharing is lower value (since
129   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
130   // level already) but may be implementable for some value in projects
131   // building multiple independent libraries with LTO and then linking those
132   // together.
133   return (D.isType() ||
134           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
135          !GenerateDwarfTypeUnits;
138 /// getDIE - Returns the debug information entry map slot for the
139 /// specified debug variable. We delegate the request to DwarfDebug
140 /// when the DIE for this MDNode can be shared across CUs. The mappings
141 /// will be kept in DwarfDebug for shareable DIEs.
142 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
143   if (isShareableAcrossCUs(D))
144     return DU->getDIE(D);
145   return MDNodeToDieMap.lookup(D);
148 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
149 /// when the DIE for this MDNode can be shared across CUs. The mappings
150 /// will be kept in DwarfDebug for shareable DIEs.
151 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
152   if (isShareableAcrossCUs(Desc)) {
153     DU->insertDIE(Desc, D);
154     return;
155   }
156   MDNodeToDieMap.insert(std::make_pair(Desc, D));
159 /// addFlag - Add a flag that is true.
160 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
161   if (DD->getDwarfVersion() >= 4)
162     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
163   else
164     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
167 /// addUInt - Add an unsigned integer attribute data and value.
168 ///
169 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
170                         Optional<dwarf::Form> Form, uint64_t Integer) {
171   if (!Form)
172     Form = DIEInteger::BestForm(false, Integer);
173   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
174                         DIEInteger(Integer);
175   Die.addValue(Attribute, *Form, Value);
178 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
179   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
182 /// addSInt - Add an signed integer attribute data and value.
183 ///
184 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
185                         Optional<dwarf::Form> Form, int64_t Integer) {
186   if (!Form)
187     Form = DIEInteger::BestForm(true, Integer);
188   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
189   Die.addValue(Attribute, *Form, Value);
192 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
193                         int64_t Integer) {
194   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
197 /// addString - Add a string attribute data and value. We always emit a
198 /// reference to the string pool instead of immediate strings so that DIEs have
199 /// more predictable sizes. In the case of split dwarf we emit an index
200 /// into another table which gets us the static offset into the string
201 /// table.
202 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
203                           StringRef String) {
204   if (!isDwoUnit())
205     return addLocalString(Die, Attribute, String);
207   addIndexedString(Die, Attribute, String);
210 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
211                                  StringRef String) {
212   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
213   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
214   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
215   Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
218 /// addLocalString - Add a string attribute data and value. This is guaranteed
219 /// to be in the local string pool instead of indirected.
220 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
221                                StringRef String) {
222   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
223   DIEValue *Value;
224   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
225     Value = new (DIEValueAllocator) DIELabel(Symb);
226   else
227     Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
228   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
229   Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
232 /// addLabel - Add a Dwarf label attribute data and value.
233 ///
234 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
235                          const MCSymbol *Label) {
236   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
237   Die.addValue(Attribute, Form, Value);
240 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
241   addLabel(Die, (dwarf::Attribute)0, Form, Label);
244 /// addSectionOffset - Add an offset into a section attribute data and value.
245 ///
246 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
247                                  uint64_t Integer) {
248   if (DD->getDwarfVersion() >= 4)
249     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
250   else
251     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
254 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
255   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
256                         : getCU().getOrCreateSourceID(FileName, DirName);
259 /// addOpAddress - Add a dwarf op address data and value using the
260 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
261 ///
262 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
263   if (!DD->useSplitDwarf()) {
264     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
265     addLabel(Die, dwarf::DW_FORM_udata, Sym);
266   } else {
267     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
268     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
269             DD->getAddressPool().getIndex(Sym));
270   }
273 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
274                               const MCSymbol *Hi, const MCSymbol *Lo) {
275   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
276   Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
279 /// addDIEEntry - Add a DIE attribute data and value.
280 ///
281 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
282   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
285 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
286   // Flag the type unit reference as a declaration so that if it contains
287   // members (implicit special members, static data member definitions, member
288   // declarations for definitions in this CU, etc) consumers don't get confused
289   // and think this is a full definition.
290   addFlag(Die, dwarf::DW_AT_declaration);
292   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
293                new (DIEValueAllocator) DIETypeSignature(Type));
296 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
297                             DIEEntry *Entry) {
298   const DIE *DieCU = Die.getUnitOrNull();
299   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
300   if (!DieCU)
301     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
302     DieCU = &getUnitDie();
303   if (!EntryCU)
304     EntryCU = &getUnitDie();
305   Die.addValue(Attribute,
306                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
307                Entry);
310 /// Create a DIE with the given Tag, add the DIE to its parent, and
311 /// call insertDIE if MD is not null.
312 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
313   assert(Tag != dwarf::DW_TAG_auto_variable &&
314          Tag != dwarf::DW_TAG_arg_variable);
315   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
316   DIE &Die = *Parent.getChildren().back();
317   if (N)
318     insertDIE(N, &Die);
319   return Die;
322 /// addBlock - Add block data.
323 ///
324 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
325   Loc->ComputeSize(Asm);
326   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
327   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
330 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
331                          DIEBlock *Block) {
332   Block->ComputeSize(Asm);
333   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
334   Die.addValue(Attribute, Block->BestForm(), Block);
337 /// addSourceLine - Add location information to specified debug information
338 /// entry.
339 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
340                               StringRef Directory) {
341   if (Line == 0)
342     return;
344   unsigned FileID = getOrCreateSourceID(File, Directory);
345   assert(FileID && "Invalid file id");
346   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
347   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
350 /// addSourceLine - Add location information to specified debug information
351 /// entry.
352 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
353   assert(V.isVariable());
355   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
356                 V.getContext().getDirectory());
359 /// addSourceLine - Add location information to specified debug information
360 /// entry.
361 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
362   assert(G.isGlobalVariable());
364   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
367 /// addSourceLine - Add location information to specified debug information
368 /// entry.
369 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
370   assert(SP.isSubprogram());
372   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
375 /// addSourceLine - Add location information to specified debug information
376 /// entry.
377 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
378   assert(Ty.isType());
380   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
383 /// addSourceLine - Add location information to specified debug information
384 /// entry.
385 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
386   assert(Ty.isObjCProperty());
388   DIFile File = Ty.getFile();
389   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
390                 File.getDirectory());
393 /// addSourceLine - Add location information to specified debug information
394 /// entry.
395 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
396   assert(NS.Verify());
398   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
401 /// addRegisterOp - Add register operand.
402 // FIXME: Ideally, this would share the implementation with
403 // AsmPrinter::EmitDwarfRegOpPiece.
404 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
405                                    unsigned SizeInBits, unsigned OffsetInBits) {
406   const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
407   int DWReg = RI->getDwarfRegNum(Reg, false);
408   bool isSubRegister = DWReg < 0;
410   unsigned Idx = 0;
412   // Go up the super-register chain until we hit a valid dwarf register number.
413   for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
414     DWReg = RI->getDwarfRegNum(*SR, false);
415     if (DWReg >= 0)
416       Idx = RI->getSubRegIndex(*SR, Reg);
417   }
419   if (DWReg < 0)
420     return false;
422   // Emit register.
423   if (DWReg < 32)
424     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
425   else {
426     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
427     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
428   }
430   // Emit mask.
431   bool isPiece = SizeInBits > 0;
432   if (isSubRegister || isPiece) {
433     const unsigned SizeOfByte = 8;
434     unsigned RegSizeInBits = RI->getSubRegIdxSize(Idx);
435     unsigned RegOffsetInBits = RI->getSubRegIdxOffset(Idx);
436     unsigned PieceSizeInBits = std::max(SizeInBits, RegSizeInBits);
437     unsigned PieceOffsetInBits = OffsetInBits ? OffsetInBits : RegOffsetInBits;
438     assert(RegSizeInBits >= SizeInBits && "register smaller than value");
440     if (RegOffsetInBits != PieceOffsetInBits) {
441       // Manually shift the value into place, since the DW_OP_piece
442       // describes the part of the variable, not the position of the
443       // subregister.
444       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
445       addUInt(TheDie, dwarf::DW_FORM_data1, RegOffsetInBits);
446       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_shr);
447     }
449     if (PieceOffsetInBits > 0 || PieceSizeInBits % SizeOfByte) {
450       assert(PieceSizeInBits > 0 && "piece has zero size");
451       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
452       addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits);
453       addUInt(TheDie, dwarf::DW_FORM_data1, PieceOffsetInBits);
454      } else {
455       assert(PieceSizeInBits > 0 && "piece has zero size");
456       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
457       addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits/SizeOfByte);
458     }
459   }
460   return true;
463 /// addRegisterOffset - Add register offset.
464 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
465                                   int64_t Offset) {
466   const TargetRegisterInfo *TRI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
467   int DWReg = TRI->getDwarfRegNum(Reg, false);
468   if (DWReg < 0)
469     return false;
471   if (Reg == TRI->getFrameRegister(*Asm->MF))
472     // If variable offset is based in frame register then use fbreg.
473     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
474   else if (DWReg < 32)
475     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
476   else {
477     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
478     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
479   }
480   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
481   return true;
484 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
485    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
486    gives the variable VarName either the struct, or a pointer to the struct, as
487    its type.  This is necessary for various behind-the-scenes things the
488    compiler needs to do with by-reference variables in Blocks.
490    However, as far as the original *programmer* is concerned, the variable
491    should still have type 'SomeType', as originally declared.
493    The function getBlockByrefType dives into the __Block_byref_x_VarName
494    struct to find the original type of the variable, which is then assigned to
495    the variable's Debug Information Entry as its real type.  So far, so good.
496    However now the debugger will expect the variable VarName to have the type
497    SomeType.  So we need the location attribute for the variable to be an
498    expression that explains to the debugger how to navigate through the
499    pointers and struct to find the actual variable of type SomeType.
501    The following function does just that.  We start by getting
502    the "normal" location for the variable. This will be the location
503    of either the struct __Block_byref_x_VarName or the pointer to the
504    struct __Block_byref_x_VarName.
506    The struct will look something like:
508    struct __Block_byref_x_VarName {
509      ... <various fields>
510      struct __Block_byref_x_VarName *forwarding;
511      ... <various other fields>
512      SomeType VarName;
513      ... <maybe more fields>
514    };
516    If we are given the struct directly (as our starting point) we
517    need to tell the debugger to:
519    1).  Add the offset of the forwarding field.
521    2).  Follow that pointer to get the real __Block_byref_x_VarName
522    struct to use (the real one may have been copied onto the heap).
524    3).  Add the offset for the field VarName, to find the actual variable.
526    If we started with a pointer to the struct, then we need to
527    dereference that pointer first, before the other steps.
528    Translating this into DWARF ops, we will need to append the following
529    to the current location description for the variable:
531    DW_OP_deref                    -- optional, if we start with a pointer
532    DW_OP_plus_uconst <forward_fld_offset>
533    DW_OP_deref
534    DW_OP_plus_uconst <varName_fld_offset>
536    That is what this function does.  */
538 /// addBlockByrefAddress - Start with the address based on the location
539 /// provided, and generate the DWARF information necessary to find the
540 /// actual Block variable (navigating the Block struct) based on the
541 /// starting location.  Add the DWARF information to the die.  For
542 /// more information, read large comment just above here.
543 ///
544 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
545                                      dwarf::Attribute Attribute,
546                                      const MachineLocation &Location) {
547   DIType Ty = DV.getType();
548   DIType TmpTy = Ty;
549   uint16_t Tag = Ty.getTag();
550   bool isPointer = false;
552   StringRef varName = DV.getName();
554   if (Tag == dwarf::DW_TAG_pointer_type) {
555     DIDerivedType DTy(Ty);
556     TmpTy = resolve(DTy.getTypeDerivedFrom());
557     isPointer = true;
558   }
560   DICompositeType blockStruct(TmpTy);
562   // Find the __forwarding field and the variable field in the __Block_byref
563   // struct.
564   DIArray Fields = blockStruct.getElements();
565   DIDerivedType varField;
566   DIDerivedType forwardingField;
568   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
569     DIDerivedType DT(Fields.getElement(i));
570     StringRef fieldName = DT.getName();
571     if (fieldName == "__forwarding")
572       forwardingField = DT;
573     else if (fieldName == varName)
574       varField = DT;
575   }
577   // Get the offsets for the forwarding field and the variable field.
578   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
579   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
581   // Decode the original location, and use that as the start of the byref
582   // variable's location.
583   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
585   bool validReg;
586   if (Location.isReg())
587     validReg = addRegisterOpPiece(*Loc, Location.getReg());
588   else
589     validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
591   if (!validReg)
592     return;
594   // If we started with a pointer to the __Block_byref... struct, then
595   // the first thing we need to do is dereference the pointer (DW_OP_deref).
596   if (isPointer)
597     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
599   // Next add the offset for the '__forwarding' field:
600   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
601   // adding the offset if it's 0.
602   if (forwardingFieldOffset > 0) {
603     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
604     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
605   }
607   // Now dereference the __forwarding field to get to the real __Block_byref
608   // struct:  DW_OP_deref.
609   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
611   // Now that we've got the real __Block_byref... struct, add the offset
612   // for the variable's field to get to the location of the actual variable:
613   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
614   if (varFieldOffset > 0) {
615     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
616     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
617   }
619   // Now attach the location information to the DIE.
620   addBlock(Die, Attribute, Loc);
623 /// Return true if type encoding is unsigned.
624 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
625   DIDerivedType DTy(Ty);
626   if (DTy.isDerivedType()) {
627     dwarf::Tag T = (dwarf::Tag)Ty.getTag();
628     // Encode pointer constants as unsigned bytes. This is used at least for
629     // null pointer constant emission.
630     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
631     // here, but accept them for now due to a bug in SROA producing bogus
632     // dbg.values.
633     if (T == dwarf::DW_TAG_pointer_type ||
634         T == dwarf::DW_TAG_ptr_to_member_type ||
635         T == dwarf::DW_TAG_reference_type ||
636         T == dwarf::DW_TAG_rvalue_reference_type)
637       return true;
638     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
639            T == dwarf::DW_TAG_volatile_type ||
640            T == dwarf::DW_TAG_restrict_type ||
641            T == dwarf::DW_TAG_enumeration_type);
642     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
643       return isUnsignedDIType(DD, DD->resolve(Deriv));
644     // FIXME: Enums without a fixed underlying type have unknown signedness
645     // here, leading to incorrectly emitted constants.
646     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
647     return false;
648   }
650   DIBasicType BTy(Ty);
651   assert(BTy.isBasicType());
652   unsigned Encoding = BTy.getEncoding();
653   assert((Encoding == dwarf::DW_ATE_unsigned ||
654           Encoding == dwarf::DW_ATE_unsigned_char ||
655           Encoding == dwarf::DW_ATE_signed ||
656           Encoding == dwarf::DW_ATE_signed_char ||
657           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
658           (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
659            Ty.getName() == "decltype(nullptr)")) &&
660          "Unsupported encoding");
661   return (Encoding == dwarf::DW_ATE_unsigned ||
662           Encoding == dwarf::DW_ATE_unsigned_char ||
663           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
664           Ty.getTag() == dwarf::DW_TAG_unspecified_type);
667 /// If this type is derived from a base type then return base type size.
668 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
669   unsigned Tag = Ty.getTag();
671   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
672       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
673       Tag != dwarf::DW_TAG_restrict_type)
674     return Ty.getSizeInBits();
676   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
678   // If this type is not derived from any type or the type is a declaration then
679   // take conservative approach.
680   if (!BaseType.isValid() || BaseType.isForwardDecl())
681     return Ty.getSizeInBits();
683   // If this is a derived type, go ahead and get the base type, unless it's a
684   // reference then it's just the size of the field. Pointer types have no need
685   // of this since they're a different type of qualification on the type.
686   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
687       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
688     return Ty.getSizeInBits();
690   if (BaseType.isDerivedType())
691     return getBaseTypeSize(DD, DIDerivedType(BaseType));
693   return BaseType.getSizeInBits();
696 /// addConstantFPValue - Add constant value entry in variable DIE.
697 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
698   assert(MO.isFPImm() && "Invalid machine operand!");
699   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
700   APFloat FPImm = MO.getFPImm()->getValueAPF();
702   // Get the raw data form of the floating point.
703   const APInt FltVal = FPImm.bitcastToAPInt();
704   const char *FltPtr = (const char *)FltVal.getRawData();
706   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
707   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
708   int Incr = (LittleEndian ? 1 : -1);
709   int Start = (LittleEndian ? 0 : NumBytes - 1);
710   int Stop = (LittleEndian ? NumBytes : -1);
712   // Output the constant to DWARF one byte at a time.
713   for (; Start != Stop; Start += Incr)
714     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
716   addBlock(Die, dwarf::DW_AT_const_value, Block);
719 /// addConstantFPValue - Add constant value entry in variable DIE.
720 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
721   // Pass this down to addConstantValue as an unsigned bag of bits.
722   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
725 /// addConstantValue - Add constant value entry in variable DIE.
726 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
727   addConstantValue(Die, CI->getValue(), Ty);
730 /// addConstantValue - Add constant value entry in variable DIE.
731 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
732                                  DIType Ty) {
733   assert(MO.isImm() && "Invalid machine operand!");
735   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
738 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
739   // FIXME: This is a bit conservative/simple - it emits negative values always
740   // sign extended to 64 bits rather than minimizing the number of bytes.
741   addUInt(Die, dwarf::DW_AT_const_value,
742           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
745 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
746   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
749 // addConstantValue - Add constant value entry in variable DIE.
750 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
751   unsigned CIBitWidth = Val.getBitWidth();
752   if (CIBitWidth <= 64) {
753     addConstantValue(Die, Unsigned,
754                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
755     return;
756   }
758   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
760   // Get the raw data form of the large APInt.
761   const uint64_t *Ptr64 = Val.getRawData();
763   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
764   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
766   // Output the constant to DWARF one byte at a time.
767   for (int i = 0; i < NumBytes; i++) {
768     uint8_t c;
769     if (LittleEndian)
770       c = Ptr64[i / 8] >> (8 * (i & 7));
771     else
772       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
773     addUInt(*Block, dwarf::DW_FORM_data1, c);
774   }
776   addBlock(Die, dwarf::DW_AT_const_value, Block);
779 /// addTemplateParams - Add template parameters into buffer.
780 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
781   // Add template parameters.
782   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
783     DIDescriptor Element = TParams.getElement(i);
784     if (Element.isTemplateTypeParameter())
785       constructTemplateTypeParameterDIE(Buffer,
786                                         DITemplateTypeParameter(Element));
787     else if (Element.isTemplateValueParameter())
788       constructTemplateValueParameterDIE(Buffer,
789                                          DITemplateValueParameter(Element));
790   }
793 /// getOrCreateContextDIE - Get context owner's DIE.
794 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
795   if (!Context || Context.isFile())
796     return &getUnitDie();
797   if (Context.isType())
798     return getOrCreateTypeDIE(DIType(Context));
799   if (Context.isNameSpace())
800     return getOrCreateNameSpace(DINameSpace(Context));
801   if (Context.isSubprogram())
802     return getOrCreateSubprogramDIE(DISubprogram(Context));
803   return getDIE(Context);
806 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
807   DIScope Context = resolve(Ty.getContext());
808   DIE *ContextDIE = getOrCreateContextDIE(Context);
810   if (DIE *TyDIE = getDIE(Ty))
811     return TyDIE;
813   // Create new type.
814   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
816   constructTypeDIE(TyDIE, Ty);
818   updateAcceleratorTables(Context, Ty, TyDIE);
819   return &TyDIE;
822 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
823 /// given DIType.
824 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
825   if (!TyNode)
826     return nullptr;
828   DIType Ty(TyNode);
829   assert(Ty.isType());
830   assert(Ty == resolve(Ty.getRef()) &&
831          "type was not uniqued, possible ODR violation.");
833   // DW_TAG_restrict_type is not supported in DWARF2
834   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
835     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
837   // Construct the context before querying for the existence of the DIE in case
838   // such construction creates the DIE.
839   DIScope Context = resolve(Ty.getContext());
840   DIE *ContextDIE = getOrCreateContextDIE(Context);
841   assert(ContextDIE);
843   if (DIE *TyDIE = getDIE(Ty))
844     return TyDIE;
846   // Create new type.
847   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
849   updateAcceleratorTables(Context, Ty, TyDIE);
851   if (Ty.isBasicType())
852     constructTypeDIE(TyDIE, DIBasicType(Ty));
853   else if (Ty.isCompositeType()) {
854     DICompositeType CTy(Ty);
855     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
856       if (MDString *TypeId = CTy.getIdentifier()) {
857         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
858         // Skip updating the accelerator tables since this is not the full type.
859         return &TyDIE;
860       }
861     constructTypeDIE(TyDIE, CTy);
862   } else {
863     assert(Ty.isDerivedType() && "Unknown kind of DIType");
864     constructTypeDIE(TyDIE, DIDerivedType(Ty));
865   }
867   return &TyDIE;
870 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
871                                         const DIE &TyDIE) {
872   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
873     bool IsImplementation = 0;
874     if (Ty.isCompositeType()) {
875       DICompositeType CT(Ty);
876       // A runtime language of 0 actually means C/C++ and that any
877       // non-negative value is some version of Objective-C/C++.
878       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
879     }
880     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
881     DD->addAccelType(Ty.getName(), TyDIE, Flags);
883     if (!Context || Context.isCompileUnit() || Context.isFile() ||
884         Context.isNameSpace())
885       addGlobalType(Ty, TyDIE, Context);
886   }
889 /// addType - Add a new type attribute to the specified entity.
890 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
891   assert(Ty && "Trying to add a type that doesn't exist?");
893   // Check for pre-existence.
894   DIEEntry *Entry = getDIEEntry(Ty);
895   // If it exists then use the existing value.
896   if (Entry) {
897     addDIEEntry(Entity, Attribute, Entry);
898     return;
899   }
901   // Construct type.
902   DIE *Buffer = getOrCreateTypeDIE(Ty);
904   // Set up proxy.
905   Entry = createDIEEntry(*Buffer);
906   insertDIEEntry(Ty, Entry);
907   addDIEEntry(Entity, Attribute, Entry);
910 /// getParentContextString - Walks the metadata parent chain in a language
911 /// specific manner (using the compile unit language) and returns
912 /// it as a string. This is done at the metadata level because DIEs may
913 /// not currently have been added to the parent context and walking the
914 /// DIEs looking for names is more expensive than walking the metadata.
915 std::string DwarfUnit::getParentContextString(DIScope Context) const {
916   if (!Context)
917     return "";
919   // FIXME: Decide whether to implement this for non-C++ languages.
920   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
921     return "";
923   std::string CS;
924   SmallVector<DIScope, 1> Parents;
925   while (!Context.isCompileUnit()) {
926     Parents.push_back(Context);
927     if (Context.getContext())
928       Context = resolve(Context.getContext());
929     else
930       // Structure, etc types will have a NULL context if they're at the top
931       // level.
932       break;
933   }
935   // Reverse iterate over our list to go from the outermost construct to the
936   // innermost.
937   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
938                                                   E = Parents.rend();
939        I != E; ++I) {
940     DIScope Ctx = *I;
941     StringRef Name = Ctx.getName();
942     if (Name.empty() && Ctx.isNameSpace())
943       Name = "(anonymous namespace)";
944     if (!Name.empty()) {
945       CS += Name;
946       CS += "::";
947     }
948   }
949   return CS;
952 /// constructTypeDIE - Construct basic type die from DIBasicType.
953 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
954   // Get core information.
955   StringRef Name = BTy.getName();
956   // Add name if not anonymous or intermediate type.
957   if (!Name.empty())
958     addString(Buffer, dwarf::DW_AT_name, Name);
960   // An unspecified type only has a name attribute.
961   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
962     return;
964   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
965           BTy.getEncoding());
967   uint64_t Size = BTy.getSizeInBits() >> 3;
968   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
971 /// constructTypeDIE - Construct derived type die from DIDerivedType.
972 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
973   // Get core information.
974   StringRef Name = DTy.getName();
975   uint64_t Size = DTy.getSizeInBits() >> 3;
976   uint16_t Tag = Buffer.getTag();
978   // Map to main type, void will not have a type.
979   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
980   if (FromTy)
981     addType(Buffer, FromTy);
983   // Add name if not anonymous or intermediate type.
984   if (!Name.empty())
985     addString(Buffer, dwarf::DW_AT_name, Name);
987   // Add size if non-zero (derived types might be zero-sized.)
988   if (Size && Tag != dwarf::DW_TAG_pointer_type
989            && Tag != dwarf::DW_TAG_ptr_to_member_type)
990     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
992   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
993     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
994                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
995   // Add source line info if available and TyDesc is not a forward declaration.
996   if (!DTy.isForwardDecl())
997     addSourceLine(Buffer, DTy);
1000 /// constructSubprogramArguments - Construct function argument DIEs.
1001 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1002   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1003     DIType Ty = resolve(Args.getElement(i));
1004     if (!Ty) {
1005       assert(i == N-1 && "Unspecified parameter must be the last argument");
1006       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1007     } else {
1008       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1009       addType(Arg, Ty);
1010       if (Ty.isArtificial())
1011         addFlag(Arg, dwarf::DW_AT_artificial);
1012     }
1013   }
1016 /// constructTypeDIE - Construct type DIE from DICompositeType.
1017 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1018   // Add name if not anonymous or intermediate type.
1019   StringRef Name = CTy.getName();
1021   uint64_t Size = CTy.getSizeInBits() >> 3;
1022   uint16_t Tag = Buffer.getTag();
1024   switch (Tag) {
1025   case dwarf::DW_TAG_array_type:
1026     constructArrayTypeDIE(Buffer, CTy);
1027     break;
1028   case dwarf::DW_TAG_enumeration_type:
1029     constructEnumTypeDIE(Buffer, CTy);
1030     break;
1031   case dwarf::DW_TAG_subroutine_type: {
1032     // Add return type. A void return won't have a type.
1033     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1034     DIType RTy(resolve(Elements.getElement(0)));
1035     if (RTy)
1036       addType(Buffer, RTy);
1038     bool isPrototyped = true;
1039     if (Elements.getNumElements() == 2 &&
1040         !Elements.getElement(1))
1041       isPrototyped = false;
1043     constructSubprogramArguments(Buffer, Elements);
1045     // Add prototype flag if we're dealing with a C language and the
1046     // function has been prototyped.
1047     uint16_t Language = getLanguage();
1048     if (isPrototyped &&
1049         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1050          Language == dwarf::DW_LANG_ObjC))
1051       addFlag(Buffer, dwarf::DW_AT_prototyped);
1053     if (CTy.isLValueReference())
1054       addFlag(Buffer, dwarf::DW_AT_reference);
1056     if (CTy.isRValueReference())
1057       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1058   } break;
1059   case dwarf::DW_TAG_structure_type:
1060   case dwarf::DW_TAG_union_type:
1061   case dwarf::DW_TAG_class_type: {
1062     // Add elements to structure type.
1063     DIArray Elements = CTy.getElements();
1064     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1065       DIDescriptor Element = Elements.getElement(i);
1066       if (Element.isSubprogram())
1067         getOrCreateSubprogramDIE(DISubprogram(Element));
1068       else if (Element.isDerivedType()) {
1069         DIDerivedType DDTy(Element);
1070         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1071           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1072           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1073                   dwarf::DW_AT_friend);
1074         } else if (DDTy.isStaticMember()) {
1075           getOrCreateStaticMemberDIE(DDTy);
1076         } else {
1077           constructMemberDIE(Buffer, DDTy);
1078         }
1079       } else if (Element.isObjCProperty()) {
1080         DIObjCProperty Property(Element);
1081         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1082         StringRef PropertyName = Property.getObjCPropertyName();
1083         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1084         if (Property.getType())
1085           addType(ElemDie, Property.getType());
1086         addSourceLine(ElemDie, Property);
1087         StringRef GetterName = Property.getObjCPropertyGetterName();
1088         if (!GetterName.empty())
1089           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1090         StringRef SetterName = Property.getObjCPropertySetterName();
1091         if (!SetterName.empty())
1092           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1093         unsigned PropertyAttributes = 0;
1094         if (Property.isReadOnlyObjCProperty())
1095           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1096         if (Property.isReadWriteObjCProperty())
1097           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1098         if (Property.isAssignObjCProperty())
1099           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1100         if (Property.isRetainObjCProperty())
1101           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1102         if (Property.isCopyObjCProperty())
1103           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1104         if (Property.isNonAtomicObjCProperty())
1105           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1106         if (PropertyAttributes)
1107           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1108                   PropertyAttributes);
1110         DIEEntry *Entry = getDIEEntry(Element);
1111         if (!Entry) {
1112           Entry = createDIEEntry(ElemDie);
1113           insertDIEEntry(Element, Entry);
1114         }
1115       } else
1116         continue;
1117     }
1119     if (CTy.isAppleBlockExtension())
1120       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1122     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1123     // inside C++ composite types to point to the base class with the vtable.
1124     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1125     if (ContainingType)
1126       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1127                   *getOrCreateTypeDIE(ContainingType));
1129     if (CTy.isObjcClassComplete())
1130       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1132     // Add template parameters to a class, structure or union types.
1133     // FIXME: The support isn't in the metadata for this yet.
1134     if (Tag == dwarf::DW_TAG_class_type ||
1135         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1136       addTemplateParams(Buffer, CTy.getTemplateParams());
1138     break;
1139   }
1140   default:
1141     break;
1142   }
1144   // Add name if not anonymous or intermediate type.
1145   if (!Name.empty())
1146     addString(Buffer, dwarf::DW_AT_name, Name);
1148   if (Tag == dwarf::DW_TAG_enumeration_type ||
1149       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1150       Tag == dwarf::DW_TAG_union_type) {
1151     // Add size if non-zero (derived types might be zero-sized.)
1152     // TODO: Do we care about size for enum forward declarations?
1153     if (Size)
1154       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1155     else if (!CTy.isForwardDecl())
1156       // Add zero size if it is not a forward declaration.
1157       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1159     // If we're a forward decl, say so.
1160     if (CTy.isForwardDecl())
1161       addFlag(Buffer, dwarf::DW_AT_declaration);
1163     // Add source line info if available.
1164     if (!CTy.isForwardDecl())
1165       addSourceLine(Buffer, CTy);
1167     // No harm in adding the runtime language to the declaration.
1168     unsigned RLang = CTy.getRunTimeLang();
1169     if (RLang)
1170       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1171               RLang);
1172   }
1175 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1176 /// DITemplateTypeParameter.
1177 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1178                                                   DITemplateTypeParameter TP) {
1179   DIE &ParamDIE =
1180       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1181   // Add the type if it exists, it could be void and therefore no type.
1182   if (TP.getType())
1183     addType(ParamDIE, resolve(TP.getType()));
1184   if (!TP.getName().empty())
1185     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1188 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1189 /// DITemplateValueParameter.
1190 void
1191 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1192                                               DITemplateValueParameter VP) {
1193   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1195   // Add the type if there is one, template template and template parameter
1196   // packs will not have a type.
1197   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1198     addType(ParamDIE, resolve(VP.getType()));
1199   if (!VP.getName().empty())
1200     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1201   if (Metadata *Val = VP.getValue()) {
1202     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1203       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1204     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1205       // For declaration non-type template parameters (such as global values and
1206       // functions)
1207       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1208       addOpAddress(*Loc, Asm->getSymbol(GV));
1209       // Emit DW_OP_stack_value to use the address as the immediate value of the
1210       // parameter, rather than a pointer to it.
1211       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1212       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1213     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1214       assert(isa<MDString>(Val));
1215       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1216                 cast<MDString>(Val)->getString());
1217     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1218       assert(isa<MDNode>(Val));
1219       DIArray A(cast<MDNode>(Val));
1220       addTemplateParams(ParamDIE, A);
1221     }
1222   }
1225 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1226 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1227   // Construct the context before querying for the existence of the DIE in case
1228   // such construction creates the DIE.
1229   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1231   if (DIE *NDie = getDIE(NS))
1232     return NDie;
1233   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1235   StringRef Name = NS.getName();
1236   if (!Name.empty())
1237     addString(NDie, dwarf::DW_AT_name, NS.getName());
1238   else
1239     Name = "(anonymous namespace)";
1240   DD->addAccelNamespace(Name, NDie);
1241   addGlobalName(Name, NDie, NS.getContext());
1242   addSourceLine(NDie, NS);
1243   return &NDie;
1246 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1247 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1248   // Construct the context before querying for the existence of the DIE in case
1249   // such construction creates the DIE (as is the case for member function
1250   // declarations).
1251   DIE *ContextDIE =
1252       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1254   if (DIE *SPDie = getDIE(SP))
1255     return SPDie;
1257   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1258     if (!Minimal) {
1259       // Add subprogram definitions to the CU die directly.
1260       ContextDIE = &getUnitDie();
1261       // Build the decl now to ensure it precedes the definition.
1262       getOrCreateSubprogramDIE(SPDecl);
1263     }
1264   }
1266   // DW_TAG_inlined_subroutine may refer to this DIE.
1267   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1269   // Stop here and fill this in later, depending on whether or not this
1270   // subprogram turns out to have inlined instances or not.
1271   if (SP.isDefinition())
1272     return &SPDie;
1274   applySubprogramAttributes(SP, SPDie);
1275   return &SPDie;
1278 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1279                                                     DIE &SPDie) {
1280   DIE *DeclDie = nullptr;
1281   StringRef DeclLinkageName;
1282   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1283     DeclDie = getDIE(SPDecl);
1284     assert(DeclDie && "This DIE should've already been constructed when the "
1285                       "definition DIE was created in "
1286                       "getOrCreateSubprogramDIE");
1287     DeclLinkageName = SPDecl.getLinkageName();
1288   }
1290   // Add function template parameters.
1291   addTemplateParams(SPDie, SP.getTemplateParams());
1293   // Add the linkage name if we have one and it isn't in the Decl.
1294   StringRef LinkageName = SP.getLinkageName();
1295   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1296           LinkageName == DeclLinkageName) &&
1297          "decl has a linkage name and it is different");
1298   if (!LinkageName.empty() && DeclLinkageName.empty())
1299     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1300               GlobalValue::getRealLinkageName(LinkageName));
1302   if (!DeclDie)
1303     return false;
1305   // Refer to the function declaration where all the other attributes will be
1306   // found.
1307   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1308   return true;
1311 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1312                                           bool Minimal) {
1313   if (!Minimal)
1314     if (applySubprogramDefinitionAttributes(SP, SPDie))
1315       return;
1317   // Constructors and operators for anonymous aggregates do not have names.
1318   if (!SP.getName().empty())
1319     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1321   // Skip the rest of the attributes under -gmlt to save space.
1322   if (Minimal)
1323     return;
1325   addSourceLine(SPDie, SP);
1327   // Add the prototype if we have a prototype and we have a C like
1328   // language.
1329   uint16_t Language = getLanguage();
1330   if (SP.isPrototyped() &&
1331       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1332        Language == dwarf::DW_LANG_ObjC))
1333     addFlag(SPDie, dwarf::DW_AT_prototyped);
1335   DISubroutineType SPTy = SP.getType();
1336   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1337          "the type of a subprogram should be a subroutine");
1339   DITypeArray Args = SPTy.getTypeArray();
1340   // Add a return type. If this is a type like a C/C++ void type we don't add a
1341   // return type.
1342   if (resolve(Args.getElement(0)))
1343     addType(SPDie, DIType(resolve(Args.getElement(0))));
1345   unsigned VK = SP.getVirtuality();
1346   if (VK) {
1347     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1348     DIELoc *Block = getDIELoc();
1349     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1350     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1351     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1352     ContainingTypeMap.insert(
1353         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1354   }
1356   if (!SP.isDefinition()) {
1357     addFlag(SPDie, dwarf::DW_AT_declaration);
1359     // Add arguments. Do not add arguments for subprogram definition. They will
1360     // be handled while processing variables.
1361     constructSubprogramArguments(SPDie, Args);
1362   }
1364   if (SP.isArtificial())
1365     addFlag(SPDie, dwarf::DW_AT_artificial);
1367   if (!SP.isLocalToUnit())
1368     addFlag(SPDie, dwarf::DW_AT_external);
1370   if (SP.isOptimized())
1371     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1373   if (unsigned isa = Asm->getISAEncoding()) {
1374     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1375   }
1377   if (SP.isLValueReference())
1378     addFlag(SPDie, dwarf::DW_AT_reference);
1380   if (SP.isRValueReference())
1381     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1383   if (SP.isProtected())
1384     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1385             dwarf::DW_ACCESS_protected);
1386   else if (SP.isPrivate())
1387     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1388             dwarf::DW_ACCESS_private);
1389   else if (SP.isPublic())
1390     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1391             dwarf::DW_ACCESS_public);
1393   if (SP.isExplicit())
1394     addFlag(SPDie, dwarf::DW_AT_explicit);
1397 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1398 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1399   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1400   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1402   // The LowerBound value defines the lower bounds which is typically zero for
1403   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1404   // Count == -1 then the array is unbounded and we do not emit
1405   // DW_AT_lower_bound and DW_AT_count attributes.
1406   int64_t LowerBound = SR.getLo();
1407   int64_t DefaultLowerBound = getDefaultLowerBound();
1408   int64_t Count = SR.getCount();
1410   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1411     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1413   if (Count != -1)
1414     // FIXME: An unbounded array should reference the expression that defines
1415     // the array.
1416     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1419 DIE *DwarfUnit::getIndexTyDie() {
1420   if (IndexTyDie)
1421     return IndexTyDie;
1422   // Construct an integer type to use for indexes.
1423   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1424   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1425   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1426   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1427           dwarf::DW_ATE_unsigned);
1428   return IndexTyDie;
1431 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1432 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1433   if (CTy.isVector())
1434     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1436   // Emit the element type.
1437   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1439   // Get an anonymous type for index type.
1440   // FIXME: This type should be passed down from the front end
1441   // as different languages may have different sizes for indexes.
1442   DIE *IdxTy = getIndexTyDie();
1444   // Add subranges to array type.
1445   DIArray Elements = CTy.getElements();
1446   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1447     DIDescriptor Element = Elements.getElement(i);
1448     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1449       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1450   }
1453 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1454 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1455   DIArray Elements = CTy.getElements();
1457   // Add enumerators to enumeration type.
1458   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1459     DIEnumerator Enum(Elements.getElement(i));
1460     if (Enum.isEnumerator()) {
1461       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1462       StringRef Name = Enum.getName();
1463       addString(Enumerator, dwarf::DW_AT_name, Name);
1464       int64_t Value = Enum.getEnumValue();
1465       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1466               Value);
1467     }
1468   }
1469   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1470   if (DTy) {
1471     addType(Buffer, DTy);
1472     addFlag(Buffer, dwarf::DW_AT_enum_class);
1473   }
1476 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1477 /// vtables.
1478 void DwarfUnit::constructContainingTypeDIEs() {
1479   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1480                                                  CE = ContainingTypeMap.end();
1481        CI != CE; ++CI) {
1482     DIE &SPDie = *CI->first;
1483     DIDescriptor D(CI->second);
1484     if (!D)
1485       continue;
1486     DIE *NDie = getDIE(D);
1487     if (!NDie)
1488       continue;
1489     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1490   }
1493 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1494 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1495   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1496   StringRef Name = DT.getName();
1497   if (!Name.empty())
1498     addString(MemberDie, dwarf::DW_AT_name, Name);
1500   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1502   addSourceLine(MemberDie, DT);
1504   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1506     // For C++, virtual base classes are not at fixed offset. Use following
1507     // expression to extract appropriate offset from vtable.
1508     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1510     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1511     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1512     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1513     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1514     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1515     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1516     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1517     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1519     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1520   } else {
1521     uint64_t Size = DT.getSizeInBits();
1522     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1523     uint64_t OffsetInBytes;
1525     if (Size != FieldSize) {
1526       // Handle bitfield, assume bytes are 8 bits.
1527       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1528       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1530       uint64_t Offset = DT.getOffsetInBits();
1531       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1532       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1533       uint64_t FieldOffset = (HiMark - FieldSize);
1534       Offset -= FieldOffset;
1536       // Maybe we need to work from the other end.
1537       if (Asm->getDataLayout().isLittleEndian())
1538         Offset = FieldSize - (Offset + Size);
1539       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1541       // Here DW_AT_data_member_location points to the anonymous
1542       // field that includes this bit field.
1543       OffsetInBytes = FieldOffset >> 3;
1544     } else
1545       // This is not a bitfield.
1546       OffsetInBytes = DT.getOffsetInBits() >> 3;
1548     if (DD->getDwarfVersion() <= 2) {
1549       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1550       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1551       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1552       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1553     } else
1554       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1555               OffsetInBytes);
1556   }
1558   if (DT.isProtected())
1559     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1560             dwarf::DW_ACCESS_protected);
1561   else if (DT.isPrivate())
1562     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1563             dwarf::DW_ACCESS_private);
1564   // Otherwise C++ member and base classes are considered public.
1565   else if (DT.isPublic())
1566     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1567             dwarf::DW_ACCESS_public);
1568   if (DT.isVirtual())
1569     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1570             dwarf::DW_VIRTUALITY_virtual);
1572   // Objective-C properties.
1573   if (MDNode *PNode = DT.getObjCProperty())
1574     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1575       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1576                          PropertyDie);
1578   if (DT.isArtificial())
1579     addFlag(MemberDie, dwarf::DW_AT_artificial);
1582 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1583 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1584   if (!DT.Verify())
1585     return nullptr;
1587   // Construct the context before querying for the existence of the DIE in case
1588   // such construction creates the DIE.
1589   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1590   assert(dwarf::isType(ContextDIE->getTag()) &&
1591          "Static member should belong to a type.");
1593   if (DIE *StaticMemberDIE = getDIE(DT))
1594     return StaticMemberDIE;
1596   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1598   DIType Ty = resolve(DT.getTypeDerivedFrom());
1600   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1601   addType(StaticMemberDIE, Ty);
1602   addSourceLine(StaticMemberDIE, DT);
1603   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1604   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1606   // FIXME: We could omit private if the parent is a class_type, and
1607   // public if the parent is something else.
1608   if (DT.isProtected())
1609     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1610             dwarf::DW_ACCESS_protected);
1611   else if (DT.isPrivate())
1612     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1613             dwarf::DW_ACCESS_private);
1614   else if (DT.isPublic())
1615     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1616             dwarf::DW_ACCESS_public);
1618   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1619     addConstantValue(StaticMemberDIE, CI, Ty);
1620   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1621     addConstantFPValue(StaticMemberDIE, CFP);
1623   return &StaticMemberDIE;
1626 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1627   // Emit size of content not including length itself
1628   Asm->OutStreamer.AddComment("Length of Unit");
1629   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1631   Asm->OutStreamer.AddComment("DWARF version number");
1632   Asm->EmitInt16(DD->getDwarfVersion());
1633   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1634   // We share one abbreviations table across all units so it's always at the
1635   // start of the section. Use a relocatable offset where needed to ensure
1636   // linking doesn't invalidate that offset.
1637   if (ASectionSym)
1638     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1639   else
1640     // Use a constant value when no symbol is provided.
1641     Asm->EmitInt32(0);
1642   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1643   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1646 void DwarfUnit::initSection(const MCSection *Section) {
1647   assert(!this->Section);
1648   this->Section = Section;
1651 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1652   DwarfUnit::emitHeader(ASectionSym);
1653   Asm->OutStreamer.AddComment("Type Signature");
1654   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1655   Asm->OutStreamer.AddComment("Type DIE Offset");
1656   // In a skeleton type unit there is no type DIE so emit a zero offset.
1657   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1658                                 sizeof(Ty->getOffset()));
1661 bool DwarfTypeUnit::isDwoUnit() const {
1662   // Since there are no skeleton type units, all type units are dwo type units
1663   // when split DWARF is being used.
1664   return DD->useSplitDwarf();