[SROA] Refactor the integer and vector promotion testing logic to
[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     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
991   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
992     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
993                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
994   // Add source line info if available and TyDesc is not a forward declaration.
995   if (!DTy.isForwardDecl())
996     addSourceLine(Buffer, DTy);
999 /// constructSubprogramArguments - Construct function argument DIEs.
1000 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1001   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1002     DIType Ty = resolve(Args.getElement(i));
1003     if (!Ty) {
1004       assert(i == N-1 && "Unspecified parameter must be the last argument");
1005       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1006     } else {
1007       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1008       addType(Arg, Ty);
1009       if (Ty.isArtificial())
1010         addFlag(Arg, dwarf::DW_AT_artificial);
1011     }
1012   }
1015 /// constructTypeDIE - Construct type DIE from DICompositeType.
1016 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1017   // Add name if not anonymous or intermediate type.
1018   StringRef Name = CTy.getName();
1020   uint64_t Size = CTy.getSizeInBits() >> 3;
1021   uint16_t Tag = Buffer.getTag();
1023   switch (Tag) {
1024   case dwarf::DW_TAG_array_type:
1025     constructArrayTypeDIE(Buffer, CTy);
1026     break;
1027   case dwarf::DW_TAG_enumeration_type:
1028     constructEnumTypeDIE(Buffer, CTy);
1029     break;
1030   case dwarf::DW_TAG_subroutine_type: {
1031     // Add return type. A void return won't have a type.
1032     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1033     DIType RTy(resolve(Elements.getElement(0)));
1034     if (RTy)
1035       addType(Buffer, RTy);
1037     bool isPrototyped = true;
1038     if (Elements.getNumElements() == 2 &&
1039         !Elements.getElement(1))
1040       isPrototyped = false;
1042     constructSubprogramArguments(Buffer, Elements);
1044     // Add prototype flag if we're dealing with a C language and the
1045     // function has been prototyped.
1046     uint16_t Language = getLanguage();
1047     if (isPrototyped &&
1048         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1049          Language == dwarf::DW_LANG_ObjC))
1050       addFlag(Buffer, dwarf::DW_AT_prototyped);
1052     if (CTy.isLValueReference())
1053       addFlag(Buffer, dwarf::DW_AT_reference);
1055     if (CTy.isRValueReference())
1056       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1057   } break;
1058   case dwarf::DW_TAG_structure_type:
1059   case dwarf::DW_TAG_union_type:
1060   case dwarf::DW_TAG_class_type: {
1061     // Add elements to structure type.
1062     DIArray Elements = CTy.getElements();
1063     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1064       DIDescriptor Element = Elements.getElement(i);
1065       if (Element.isSubprogram())
1066         getOrCreateSubprogramDIE(DISubprogram(Element));
1067       else if (Element.isDerivedType()) {
1068         DIDerivedType DDTy(Element);
1069         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1070           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1071           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1072                   dwarf::DW_AT_friend);
1073         } else if (DDTy.isStaticMember()) {
1074           getOrCreateStaticMemberDIE(DDTy);
1075         } else {
1076           constructMemberDIE(Buffer, DDTy);
1077         }
1078       } else if (Element.isObjCProperty()) {
1079         DIObjCProperty Property(Element);
1080         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1081         StringRef PropertyName = Property.getObjCPropertyName();
1082         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1083         if (Property.getType())
1084           addType(ElemDie, Property.getType());
1085         addSourceLine(ElemDie, Property);
1086         StringRef GetterName = Property.getObjCPropertyGetterName();
1087         if (!GetterName.empty())
1088           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1089         StringRef SetterName = Property.getObjCPropertySetterName();
1090         if (!SetterName.empty())
1091           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1092         unsigned PropertyAttributes = 0;
1093         if (Property.isReadOnlyObjCProperty())
1094           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1095         if (Property.isReadWriteObjCProperty())
1096           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1097         if (Property.isAssignObjCProperty())
1098           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1099         if (Property.isRetainObjCProperty())
1100           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1101         if (Property.isCopyObjCProperty())
1102           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1103         if (Property.isNonAtomicObjCProperty())
1104           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1105         if (PropertyAttributes)
1106           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1107                   PropertyAttributes);
1109         DIEEntry *Entry = getDIEEntry(Element);
1110         if (!Entry) {
1111           Entry = createDIEEntry(ElemDie);
1112           insertDIEEntry(Element, Entry);
1113         }
1114       } else
1115         continue;
1116     }
1118     if (CTy.isAppleBlockExtension())
1119       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1121     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1122     // inside C++ composite types to point to the base class with the vtable.
1123     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1124     if (ContainingType)
1125       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1126                   *getOrCreateTypeDIE(ContainingType));
1128     if (CTy.isObjcClassComplete())
1129       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1131     // Add template parameters to a class, structure or union types.
1132     // FIXME: The support isn't in the metadata for this yet.
1133     if (Tag == dwarf::DW_TAG_class_type ||
1134         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1135       addTemplateParams(Buffer, CTy.getTemplateParams());
1137     break;
1138   }
1139   default:
1140     break;
1141   }
1143   // Add name if not anonymous or intermediate type.
1144   if (!Name.empty())
1145     addString(Buffer, dwarf::DW_AT_name, Name);
1147   if (Tag == dwarf::DW_TAG_enumeration_type ||
1148       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1149       Tag == dwarf::DW_TAG_union_type) {
1150     // Add size if non-zero (derived types might be zero-sized.)
1151     // TODO: Do we care about size for enum forward declarations?
1152     if (Size)
1153       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1154     else if (!CTy.isForwardDecl())
1155       // Add zero size if it is not a forward declaration.
1156       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1158     // If we're a forward decl, say so.
1159     if (CTy.isForwardDecl())
1160       addFlag(Buffer, dwarf::DW_AT_declaration);
1162     // Add source line info if available.
1163     if (!CTy.isForwardDecl())
1164       addSourceLine(Buffer, CTy);
1166     // No harm in adding the runtime language to the declaration.
1167     unsigned RLang = CTy.getRunTimeLang();
1168     if (RLang)
1169       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1170               RLang);
1171   }
1174 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1175 /// DITemplateTypeParameter.
1176 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1177                                                   DITemplateTypeParameter TP) {
1178   DIE &ParamDIE =
1179       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1180   // Add the type if it exists, it could be void and therefore no type.
1181   if (TP.getType())
1182     addType(ParamDIE, resolve(TP.getType()));
1183   if (!TP.getName().empty())
1184     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1187 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1188 /// DITemplateValueParameter.
1189 void
1190 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1191                                               DITemplateValueParameter VP) {
1192   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1194   // Add the type if there is one, template template and template parameter
1195   // packs will not have a type.
1196   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1197     addType(ParamDIE, resolve(VP.getType()));
1198   if (!VP.getName().empty())
1199     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1200   if (Metadata *Val = VP.getValue()) {
1201     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1202       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1203     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1204       // For declaration non-type template parameters (such as global values and
1205       // functions)
1206       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1207       addOpAddress(*Loc, Asm->getSymbol(GV));
1208       // Emit DW_OP_stack_value to use the address as the immediate value of the
1209       // parameter, rather than a pointer to it.
1210       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1211       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1212     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1213       assert(isa<MDString>(Val));
1214       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1215                 cast<MDString>(Val)->getString());
1216     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1217       assert(isa<MDNode>(Val));
1218       DIArray A(cast<MDNode>(Val));
1219       addTemplateParams(ParamDIE, A);
1220     }
1221   }
1224 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1225 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1226   // Construct the context before querying for the existence of the DIE in case
1227   // such construction creates the DIE.
1228   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1230   if (DIE *NDie = getDIE(NS))
1231     return NDie;
1232   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1234   StringRef Name = NS.getName();
1235   if (!Name.empty())
1236     addString(NDie, dwarf::DW_AT_name, NS.getName());
1237   else
1238     Name = "(anonymous namespace)";
1239   DD->addAccelNamespace(Name, NDie);
1240   addGlobalName(Name, NDie, NS.getContext());
1241   addSourceLine(NDie, NS);
1242   return &NDie;
1245 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1246 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1247   // Construct the context before querying for the existence of the DIE in case
1248   // such construction creates the DIE (as is the case for member function
1249   // declarations).
1250   DIE *ContextDIE =
1251       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1253   if (DIE *SPDie = getDIE(SP))
1254     return SPDie;
1256   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1257     if (!Minimal) {
1258       // Add subprogram definitions to the CU die directly.
1259       ContextDIE = &getUnitDie();
1260       // Build the decl now to ensure it precedes the definition.
1261       getOrCreateSubprogramDIE(SPDecl);
1262     }
1263   }
1265   // DW_TAG_inlined_subroutine may refer to this DIE.
1266   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1268   // Stop here and fill this in later, depending on whether or not this
1269   // subprogram turns out to have inlined instances or not.
1270   if (SP.isDefinition())
1271     return &SPDie;
1273   applySubprogramAttributes(SP, SPDie);
1274   return &SPDie;
1277 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1278                                                     DIE &SPDie) {
1279   DIE *DeclDie = nullptr;
1280   StringRef DeclLinkageName;
1281   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1282     DeclDie = getDIE(SPDecl);
1283     assert(DeclDie && "This DIE should've already been constructed when the "
1284                       "definition DIE was created in "
1285                       "getOrCreateSubprogramDIE");
1286     DeclLinkageName = SPDecl.getLinkageName();
1287   }
1289   // Add function template parameters.
1290   addTemplateParams(SPDie, SP.getTemplateParams());
1292   // Add the linkage name if we have one and it isn't in the Decl.
1293   StringRef LinkageName = SP.getLinkageName();
1294   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1295           LinkageName == DeclLinkageName) &&
1296          "decl has a linkage name and it is different");
1297   if (!LinkageName.empty() && DeclLinkageName.empty())
1298     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1299               GlobalValue::getRealLinkageName(LinkageName));
1301   if (!DeclDie)
1302     return false;
1304   // Refer to the function declaration where all the other attributes will be
1305   // found.
1306   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1307   return true;
1310 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1311                                           bool Minimal) {
1312   if (!Minimal)
1313     if (applySubprogramDefinitionAttributes(SP, SPDie))
1314       return;
1316   // Constructors and operators for anonymous aggregates do not have names.
1317   if (!SP.getName().empty())
1318     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1320   // Skip the rest of the attributes under -gmlt to save space.
1321   if (Minimal)
1322     return;
1324   addSourceLine(SPDie, SP);
1326   // Add the prototype if we have a prototype and we have a C like
1327   // language.
1328   uint16_t Language = getLanguage();
1329   if (SP.isPrototyped() &&
1330       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1331        Language == dwarf::DW_LANG_ObjC))
1332     addFlag(SPDie, dwarf::DW_AT_prototyped);
1334   DISubroutineType SPTy = SP.getType();
1335   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1336          "the type of a subprogram should be a subroutine");
1338   DITypeArray Args = SPTy.getTypeArray();
1339   // Add a return type. If this is a type like a C/C++ void type we don't add a
1340   // return type.
1341   if (resolve(Args.getElement(0)))
1342     addType(SPDie, DIType(resolve(Args.getElement(0))));
1344   unsigned VK = SP.getVirtuality();
1345   if (VK) {
1346     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1347     DIELoc *Block = getDIELoc();
1348     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1349     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1350     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1351     ContainingTypeMap.insert(
1352         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1353   }
1355   if (!SP.isDefinition()) {
1356     addFlag(SPDie, dwarf::DW_AT_declaration);
1358     // Add arguments. Do not add arguments for subprogram definition. They will
1359     // be handled while processing variables.
1360     constructSubprogramArguments(SPDie, Args);
1361   }
1363   if (SP.isArtificial())
1364     addFlag(SPDie, dwarf::DW_AT_artificial);
1366   if (!SP.isLocalToUnit())
1367     addFlag(SPDie, dwarf::DW_AT_external);
1369   if (SP.isOptimized())
1370     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1372   if (unsigned isa = Asm->getISAEncoding()) {
1373     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1374   }
1376   if (SP.isLValueReference())
1377     addFlag(SPDie, dwarf::DW_AT_reference);
1379   if (SP.isRValueReference())
1380     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1382   if (SP.isProtected())
1383     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1384             dwarf::DW_ACCESS_protected);
1385   else if (SP.isPrivate())
1386     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1387             dwarf::DW_ACCESS_private);
1388   else if (SP.isPublic())
1389     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1390             dwarf::DW_ACCESS_public);
1392   if (SP.isExplicit())
1393     addFlag(SPDie, dwarf::DW_AT_explicit);
1396 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1397 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1398   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1399   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1401   // The LowerBound value defines the lower bounds which is typically zero for
1402   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1403   // Count == -1 then the array is unbounded and we do not emit
1404   // DW_AT_lower_bound and DW_AT_count attributes.
1405   int64_t LowerBound = SR.getLo();
1406   int64_t DefaultLowerBound = getDefaultLowerBound();
1407   int64_t Count = SR.getCount();
1409   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1410     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1412   if (Count != -1)
1413     // FIXME: An unbounded array should reference the expression that defines
1414     // the array.
1415     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1418 DIE *DwarfUnit::getIndexTyDie() {
1419   if (IndexTyDie)
1420     return IndexTyDie;
1421   // Construct an integer type to use for indexes.
1422   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1423   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1424   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1425   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1426           dwarf::DW_ATE_unsigned);
1427   return IndexTyDie;
1430 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1431 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1432   if (CTy.isVector())
1433     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1435   // Emit the element type.
1436   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1438   // Get an anonymous type for index type.
1439   // FIXME: This type should be passed down from the front end
1440   // as different languages may have different sizes for indexes.
1441   DIE *IdxTy = getIndexTyDie();
1443   // Add subranges to array type.
1444   DIArray Elements = CTy.getElements();
1445   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1446     DIDescriptor Element = Elements.getElement(i);
1447     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1448       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1449   }
1452 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1453 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1454   DIArray Elements = CTy.getElements();
1456   // Add enumerators to enumeration type.
1457   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1458     DIEnumerator Enum(Elements.getElement(i));
1459     if (Enum.isEnumerator()) {
1460       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1461       StringRef Name = Enum.getName();
1462       addString(Enumerator, dwarf::DW_AT_name, Name);
1463       int64_t Value = Enum.getEnumValue();
1464       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1465               Value);
1466     }
1467   }
1468   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1469   if (DTy) {
1470     addType(Buffer, DTy);
1471     addFlag(Buffer, dwarf::DW_AT_enum_class);
1472   }
1475 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1476 /// vtables.
1477 void DwarfUnit::constructContainingTypeDIEs() {
1478   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1479                                                  CE = ContainingTypeMap.end();
1480        CI != CE; ++CI) {
1481     DIE &SPDie = *CI->first;
1482     DIDescriptor D(CI->second);
1483     if (!D)
1484       continue;
1485     DIE *NDie = getDIE(D);
1486     if (!NDie)
1487       continue;
1488     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1489   }
1492 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1493 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1494   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1495   StringRef Name = DT.getName();
1496   if (!Name.empty())
1497     addString(MemberDie, dwarf::DW_AT_name, Name);
1499   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1501   addSourceLine(MemberDie, DT);
1503   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1505     // For C++, virtual base classes are not at fixed offset. Use following
1506     // expression to extract appropriate offset from vtable.
1507     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1509     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1510     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1511     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1512     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1513     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1514     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1515     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1516     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1518     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1519   } else {
1520     uint64_t Size = DT.getSizeInBits();
1521     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1522     uint64_t OffsetInBytes;
1524     if (Size != FieldSize) {
1525       // Handle bitfield, assume bytes are 8 bits.
1526       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1527       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1529       uint64_t Offset = DT.getOffsetInBits();
1530       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1531       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1532       uint64_t FieldOffset = (HiMark - FieldSize);
1533       Offset -= FieldOffset;
1535       // Maybe we need to work from the other end.
1536       if (Asm->getDataLayout().isLittleEndian())
1537         Offset = FieldSize - (Offset + Size);
1538       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1540       // Here DW_AT_data_member_location points to the anonymous
1541       // field that includes this bit field.
1542       OffsetInBytes = FieldOffset >> 3;
1543     } else
1544       // This is not a bitfield.
1545       OffsetInBytes = DT.getOffsetInBits() >> 3;
1547     if (DD->getDwarfVersion() <= 2) {
1548       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1549       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1550       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1551       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1552     } else
1553       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1554               OffsetInBytes);
1555   }
1557   if (DT.isProtected())
1558     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1559             dwarf::DW_ACCESS_protected);
1560   else if (DT.isPrivate())
1561     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562             dwarf::DW_ACCESS_private);
1563   // Otherwise C++ member and base classes are considered public.
1564   else if (DT.isPublic())
1565     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1566             dwarf::DW_ACCESS_public);
1567   if (DT.isVirtual())
1568     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1569             dwarf::DW_VIRTUALITY_virtual);
1571   // Objective-C properties.
1572   if (MDNode *PNode = DT.getObjCProperty())
1573     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1574       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1575                          PropertyDie);
1577   if (DT.isArtificial())
1578     addFlag(MemberDie, dwarf::DW_AT_artificial);
1581 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1582 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1583   if (!DT.Verify())
1584     return nullptr;
1586   // Construct the context before querying for the existence of the DIE in case
1587   // such construction creates the DIE.
1588   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1589   assert(dwarf::isType(ContextDIE->getTag()) &&
1590          "Static member should belong to a type.");
1592   if (DIE *StaticMemberDIE = getDIE(DT))
1593     return StaticMemberDIE;
1595   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1597   DIType Ty = resolve(DT.getTypeDerivedFrom());
1599   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1600   addType(StaticMemberDIE, Ty);
1601   addSourceLine(StaticMemberDIE, DT);
1602   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1603   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1605   // FIXME: We could omit private if the parent is a class_type, and
1606   // public if the parent is something else.
1607   if (DT.isProtected())
1608     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1609             dwarf::DW_ACCESS_protected);
1610   else if (DT.isPrivate())
1611     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1612             dwarf::DW_ACCESS_private);
1613   else if (DT.isPublic())
1614     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1615             dwarf::DW_ACCESS_public);
1617   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1618     addConstantValue(StaticMemberDIE, CI, Ty);
1619   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1620     addConstantFPValue(StaticMemberDIE, CFP);
1622   return &StaticMemberDIE;
1625 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1626   // Emit size of content not including length itself
1627   Asm->OutStreamer.AddComment("Length of Unit");
1628   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1630   Asm->OutStreamer.AddComment("DWARF version number");
1631   Asm->EmitInt16(DD->getDwarfVersion());
1632   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1633   // We share one abbreviations table across all units so it's always at the
1634   // start of the section. Use a relocatable offset where needed to ensure
1635   // linking doesn't invalidate that offset.
1636   if (ASectionSym)
1637     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1638   else
1639     // Use a constant value when no symbol is provided.
1640     Asm->EmitInt32(0);
1641   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1642   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1645 void DwarfUnit::initSection(const MCSection *Section) {
1646   assert(!this->Section);
1647   this->Section = Section;
1650 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1651   DwarfUnit::emitHeader(ASectionSym);
1652   Asm->OutStreamer.AddComment("Type Signature");
1653   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1654   Asm->OutStreamer.AddComment("Type DIE Offset");
1655   // In a skeleton type unit there is no type DIE so emit a zero offset.
1656   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1657                                 sizeof(Ty->getOffset()));
1660 bool DwarfTypeUnit::isDwoUnit() const {
1661   // Since there are no skeleton type units, all type units are dwo type units
1662   // when split DWARF is being used.
1663   return DD->useSplitDwarf();