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