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