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