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