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            && Tag != dwarf::DW_TAG_reference_type
 858            && Tag != dwarf::DW_TAG_rvalue_reference_type)
 859     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 860
 861   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 862     addDIEEntry(
 863         Buffer, dwarf::DW_AT_containing_type,
 864         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
 865   // Add source line info if available and TyDesc is not a forward declaration.
 866   if (!DTy->isForwardDecl())
 867     addSourceLine(Buffer, DTy);
 868 }
 869
 870 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
 871   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 872     const DIType *Ty = resolve(Args[i]);
 873     if (!Ty) {
 874       assert(i == N-1 && "Unspecified parameter must be the last argument");
 875       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 876     } else {
 877       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 878       addType(Arg, Ty);
 879       if (Ty->isArtificial())
 880         addFlag(Arg, dwarf::DW_AT_artificial);
 881     }
 882   }
 883 }
 884
 885 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 886   // Add return type.  A void return won't have a type.
 887   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
 888   if (Elements.size())
 889     if (auto RTy = resolve(Elements[0]))
 890       addType(Buffer, RTy);
 891
 892   bool isPrototyped = true;
 893   if (Elements.size() == 2 && !Elements[1])
 894     isPrototyped = false;
 895
 896   constructSubprogramArguments(Buffer, Elements);
 897
 898   // Add prototype flag if we're dealing with a C language and the function has
 899   // been prototyped.
 900   uint16_t Language = getLanguage();
 901   if (isPrototyped &&
 902       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
 903        Language == dwarf::DW_LANG_ObjC))
 904     addFlag(Buffer, dwarf::DW_AT_prototyped);
 905
 906   if (CTy->isLValueReference())
 907     addFlag(Buffer, dwarf::DW_AT_reference);
 908
 909   if (CTy->isRValueReference())
 910     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 911 }
 912
 913 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
 914   if (CTy->isExternalTypeRef()) {
 915     StringRef Identifier = CTy->getIdentifier();
 916     assert(!Identifier.empty() && "external type ref without identifier");
 917     addFlag(Buffer, dwarf::DW_AT_declaration);
 918     return addDIETypeSignature(Buffer, dwarf::DW_AT_signature, Identifier);
 919   }
 920
 921   // Add name if not anonymous or intermediate type.
 922   StringRef Name = CTy->getName();
 923
 924   uint64_t Size = CTy->getSizeInBits() >> 3;
 925   uint16_t Tag = Buffer.getTag();
 926
 927   switch (Tag) {
 928   case dwarf::DW_TAG_array_type:
 929     constructArrayTypeDIE(Buffer, CTy);
 930     break;
 931   case dwarf::DW_TAG_enumeration_type:
 932     constructEnumTypeDIE(Buffer, CTy);
 933     break;
 934   case dwarf::DW_TAG_structure_type:
 935   case dwarf::DW_TAG_union_type:
 936   case dwarf::DW_TAG_class_type: {
 937     // Add elements to structure type.
 938     DINodeArray Elements = CTy->getElements();
 939     for (const auto *Element : Elements) {
 940       if (!Element)
 941         continue;
 942       if (auto *SP = dyn_cast<DISubprogram>(Element))
 943         getOrCreateSubprogramDIE(SP);
 944       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
 945         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
 946           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
 947           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
 948         } else if (DDTy->isStaticMember()) {
 949           getOrCreateStaticMemberDIE(DDTy);
 950         } else {
 951           constructMemberDIE(Buffer, DDTy);
 952         }
 953       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
 954         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
 955         StringRef PropertyName = Property->getName();
 956         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 957         if (Property->getType())
 958           addType(ElemDie, resolve(Property->getType()));
 959         addSourceLine(ElemDie, Property);
 960         StringRef GetterName = Property->getGetterName();
 961         if (!GetterName.empty())
 962           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 963         StringRef SetterName = Property->getSetterName();
 964         if (!SetterName.empty())
 965           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 966         if (unsigned PropertyAttributes = Property->getAttributes())
 967           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
 968                   PropertyAttributes);
 969       }
 970     }
 971
 972     if (CTy->isAppleBlockExtension())
 973       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 974
 975     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
 976     // inside C++ composite types to point to the base class with the vtable.
 977     if (auto *ContainingType =
 978             dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
 979       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 980                   *getOrCreateTypeDIE(ContainingType));
 981
 982     if (CTy->isObjcClassComplete())
 983       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 984
 985     // Add template parameters to a class, structure or union types.
 986     // FIXME: The support isn't in the metadata for this yet.
 987     if (Tag == dwarf::DW_TAG_class_type ||
 988         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 989       addTemplateParams(Buffer, CTy->getTemplateParams());
 990
 991     break;
 992   }
 993   default:
 994     break;
 995   }
 996
 997   // Add name if not anonymous or intermediate type.
 998   if (!Name.empty())
 999     addString(Buffer, dwarf::DW_AT_name, Name);
1000
1001   if (Tag == dwarf::DW_TAG_enumeration_type ||
1002       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1003       Tag == dwarf::DW_TAG_union_type) {
1004     // Add size if non-zero (derived types might be zero-sized.)
1005     // TODO: Do we care about size for enum forward declarations?
1006     if (Size)
1007       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1008     else if (!CTy->isForwardDecl())
1009       // Add zero size if it is not a forward declaration.
1010       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1011
1012     // If we're a forward decl, say so.
1013     if (CTy->isForwardDecl())
1014       addFlag(Buffer, dwarf::DW_AT_declaration);
1015
1016     // Add source line info if available.
1017     if (!CTy->isForwardDecl())
1018       addSourceLine(Buffer, CTy);
1019
1020     // No harm in adding the runtime language to the declaration.
1021     unsigned RLang = CTy->getRuntimeLang();
1022     if (RLang)
1023       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1024               RLang);
1025   }
1026 }
1027
1028 void DwarfUnit::constructTemplateTypeParameterDIE(
1029     DIE &Buffer, const DITemplateTypeParameter *TP) {
1030   DIE &ParamDIE =
1031       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1032   // Add the type if it exists, it could be void and therefore no type.
1033   if (TP->getType())
1034     addType(ParamDIE, resolve(TP->getType()));
1035   if (!TP->getName().empty())
1036     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1037 }
1038
1039 void DwarfUnit::constructTemplateValueParameterDIE(
1040     DIE &Buffer, const DITemplateValueParameter *VP) {
1041   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1042
1043   // Add the type if there is one, template template and template parameter
1044   // packs will not have a type.
1045   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1046     addType(ParamDIE, resolve(VP->getType()));
1047   if (!VP->getName().empty())
1048     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1049   if (Metadata *Val = VP->getValue()) {
1050     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1051       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1052     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1053       // For declaration non-type template parameters (such as global values and
1054       // functions)
1055       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1056       addOpAddress(*Loc, Asm->getSymbol(GV));
1057       // Emit DW_OP_stack_value to use the address as the immediate value of the
1058       // parameter, rather than a pointer to it.
1059       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1060       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1061     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1062       assert(isa<MDString>(Val));
1063       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1064                 cast<MDString>(Val)->getString());
1065     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1066       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1067     }
1068   }
1069 }
1070
1071 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1072   // Construct the context before querying for the existence of the DIE in case
1073   // such construction creates the DIE.
1074   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1075
1076   if (DIE *NDie = getDIE(NS))
1077     return NDie;
1078   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1079
1080   StringRef Name = NS->getName();
1081   if (!Name.empty())
1082     addString(NDie, dwarf::DW_AT_name, NS->getName());
1083   else
1084     Name = "(anonymous namespace)";
1085   DD->addAccelNamespace(Name, NDie);
1086   addGlobalName(Name, NDie, NS->getScope());
1087   addSourceLine(NDie, NS);
1088   return &NDie;
1089 }
1090
1091 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1092   // Construct the context before querying for the existence of the DIE in case
1093   // such construction creates the DIE.
1094   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1095
1096   if (DIE *MDie = getDIE(M))
1097     return MDie;
1098   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1099
1100   if (!M->getName().empty()) {
1101     addString(MDie, dwarf::DW_AT_name, M->getName());
1102     addGlobalName(M->getName(), MDie, M->getScope());
1103   }
1104   if (!M->getConfigurationMacros().empty())
1105     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1106               M->getConfigurationMacros());
1107   if (!M->getIncludePath().empty())
1108     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1109   if (!M->getISysRoot().empty())
1110     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1111
1112   return &MDie;
1113 }
1114
1115 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1116   // Construct the context before querying for the existence of the DIE in case
1117   // such construction creates the DIE (as is the case for member function
1118   // declarations).
1119   DIE *ContextDIE =
1120       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1121
1122   if (DIE *SPDie = getDIE(SP))
1123     return SPDie;
1124
1125   if (auto *SPDecl = SP->getDeclaration()) {
1126     if (!Minimal) {
1127       // Add subprogram definitions to the CU die directly.
1128       ContextDIE = &getUnitDie();
1129       // Build the decl now to ensure it precedes the definition.
1130       getOrCreateSubprogramDIE(SPDecl);
1131     }
1132   }
1133
1134   // DW_TAG_inlined_subroutine may refer to this DIE.
1135   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1136
1137   // Stop here and fill this in later, depending on whether or not this
1138   // subprogram turns out to have inlined instances or not.
1139   if (SP->isDefinition())
1140     return &SPDie;
1141
1142   applySubprogramAttributes(SP, SPDie);
1143   return &SPDie;
1144 }
1145
1146 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1147                                                     DIE &SPDie) {
1148   DIE *DeclDie = nullptr;
1149   StringRef DeclLinkageName;
1150   if (auto *SPDecl = SP->getDeclaration()) {
1151     DeclDie = getDIE(SPDecl);
1152     assert(DeclDie && "This DIE should've already been constructed when the "
1153                       "definition DIE was created in "
1154                       "getOrCreateSubprogramDIE");
1155     DeclLinkageName = SPDecl->getLinkageName();
1156     unsigned DeclID =
1157         getOrCreateSourceID(SPDecl->getFilename(), SPDecl->getDirectory());
1158     unsigned DefID = getOrCreateSourceID(SP->getFilename(), SP->getDirectory());
1159     if (DeclID != DefID)
1160       addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1161
1162     if (SP->getLine() != SPDecl->getLine())
1163       addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1164   }
1165
1166   // Add function template parameters.
1167   addTemplateParams(SPDie, SP->getTemplateParams());
1168
1169   // Add the linkage name if we have one and it isn't in the Decl.
1170   StringRef LinkageName = SP->getLinkageName();
1171   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1172           LinkageName == DeclLinkageName) &&
1173          "decl has a linkage name and it is different");
1174   if (DeclLinkageName.empty())
1175     addLinkageName(SPDie, LinkageName);
1176
1177   if (!DeclDie)
1178     return false;
1179
1180   // Refer to the function declaration where all the other attributes will be
1181   // found.
1182   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1183   return true;
1184 }
1185
1186 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1187                                           bool Minimal) {
1188   if (!Minimal)
1189     if (applySubprogramDefinitionAttributes(SP, SPDie))
1190       return;
1191
1192   // Constructors and operators for anonymous aggregates do not have names.
1193   if (!SP->getName().empty())
1194     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1195
1196   // Skip the rest of the attributes under -gmlt to save space.
1197   if (Minimal)
1198     return;
1199
1200   addSourceLine(SPDie, SP);
1201
1202   // Add the prototype if we have a prototype and we have a C like
1203   // language.
1204   uint16_t Language = getLanguage();
1205   if (SP->isPrototyped() &&
1206       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1207        Language == dwarf::DW_LANG_ObjC))
1208     addFlag(SPDie, dwarf::DW_AT_prototyped);
1209
1210   DITypeRefArray Args;
1211   if (const DISubroutineType *SPTy = SP->getType())
1212     Args = SPTy->getTypeArray();
1213
1214   // Add a return type. If this is a type like a C/C++ void type we don't add a
1215   // return type.
1216   if (Args.size())
1217     if (auto Ty = resolve(Args[0]))
1218       addType(SPDie, Ty);
1219
1220   unsigned VK = SP->getVirtuality();
1221   if (VK) {
1222     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1223     DIELoc *Block = getDIELoc();
1224     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1225     addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1226     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1227     ContainingTypeMap.insert(
1228         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1229   }
1230
1231   if (!SP->isDefinition()) {
1232     addFlag(SPDie, dwarf::DW_AT_declaration);
1233
1234     // Add arguments. Do not add arguments for subprogram definition. They will
1235     // be handled while processing variables.
1236     constructSubprogramArguments(SPDie, Args);
1237   }
1238
1239   if (SP->isArtificial())
1240     addFlag(SPDie, dwarf::DW_AT_artificial);
1241
1242   if (!SP->isLocalToUnit())
1243     addFlag(SPDie, dwarf::DW_AT_external);
1244
1245   if (SP->isOptimized())
1246     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1247
1248   if (unsigned isa = Asm->getISAEncoding())
1249     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1250
1251   if (SP->isLValueReference())
1252     addFlag(SPDie, dwarf::DW_AT_reference);
1253
1254   if (SP->isRValueReference())
1255     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1256
1257   if (SP->isProtected())
1258     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1259             dwarf::DW_ACCESS_protected);
1260   else if (SP->isPrivate())
1261     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1262             dwarf::DW_ACCESS_private);
1263   else if (SP->isPublic())
1264     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1265             dwarf::DW_ACCESS_public);
1266
1267   if (SP->isExplicit())
1268     addFlag(SPDie, dwarf::DW_AT_explicit);
1269 }
1270
1271 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1272                                      DIE *IndexTy) {
1273   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1274   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1275
1276   // The LowerBound value defines the lower bounds which is typically zero for
1277   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1278   // Count == -1 then the array is unbounded and we do not emit
1279   // DW_AT_lower_bound and DW_AT_count attributes.
1280   int64_t LowerBound = SR->getLowerBound();
1281   int64_t DefaultLowerBound = getDefaultLowerBound();
1282   int64_t Count = SR->getCount();
1283
1284   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1285     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1286
1287   if (Count != -1)
1288     // FIXME: An unbounded array should reference the expression that defines
1289     // the array.
1290     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1291 }
1292
1293 DIE *DwarfUnit::getIndexTyDie() {
1294   if (IndexTyDie)
1295     return IndexTyDie;
1296   // Construct an integer type to use for indexes.
1297   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1298   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1299   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1300   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1301           dwarf::DW_ATE_unsigned);
1302   return IndexTyDie;
1303 }
1304
1305 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1306   if (CTy->isVector())
1307     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1308
1309   // Emit the element type.
1310   addType(Buffer, resolve(CTy->getBaseType()));
1311
1312   // Get an anonymous type for index type.
1313   // FIXME: This type should be passed down from the front end
1314   // as different languages may have different sizes for indexes.
1315   DIE *IdxTy = getIndexTyDie();
1316
1317   // Add subranges to array type.
1318   DINodeArray Elements = CTy->getElements();
1319   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1320     // FIXME: Should this really be such a loose cast?
1321     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1322       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1323         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1324   }
1325 }
1326
1327 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1328   DINodeArray Elements = CTy->getElements();
1329
1330   // Add enumerators to enumeration type.
1331   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1332     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1333     if (Enum) {
1334       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1335       StringRef Name = Enum->getName();
1336       addString(Enumerator, dwarf::DW_AT_name, Name);
1337       int64_t Value = Enum->getValue();
1338       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1339               Value);
1340     }
1341   }
1342   const DIType *DTy = resolve(CTy->getBaseType());
1343   if (DTy) {
1344     addType(Buffer, DTy);
1345     addFlag(Buffer, dwarf::DW_AT_enum_class);
1346   }
1347 }
1348
1349 void DwarfUnit::constructContainingTypeDIEs() {
1350   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1351        CI != CE; ++CI) {
1352     DIE &SPDie = *CI->first;
1353     const DINode *D = CI->second;
1354     if (!D)
1355       continue;
1356     DIE *NDie = getDIE(D);
1357     if (!NDie)
1358       continue;
1359     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1360   }
1361 }
1362
1363 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1364   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1365   StringRef Name = DT->getName();
1366   if (!Name.empty())
1367     addString(MemberDie, dwarf::DW_AT_name, Name);
1368
1369   addType(MemberDie, resolve(DT->getBaseType()));
1370
1371   addSourceLine(MemberDie, DT);
1372
1373   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1374
1375     // For C++, virtual base classes are not at fixed offset. Use following
1376     // expression to extract appropriate offset from vtable.
1377     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1378
1379     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1380     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1381     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1382     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1383     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1384     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1385     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1386     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1387
1388     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1389   } else {
1390     uint64_t Size = DT->getSizeInBits();
1391     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1392     uint64_t OffsetInBytes;
1393
1394     if (FieldSize && Size != FieldSize) {
1395       // Handle bitfield, assume bytes are 8 bits.
1396       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1397       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1398       //
1399       // The DWARF 2 DW_AT_bit_offset is counting the bits between the most
1400       // significant bit of the aligned storage unit containing the bit field to
1401       // the most significan bit of the bit field.
1402       //
1403       // FIXME: DWARF 4 states that DW_AT_data_bit_offset (which
1404       // counts from the beginning, regardless of endianness) should
1405       // be used instead.
1406       //
1407       //
1408       // Struct      Align       Align       Align
1409       // v           v           v           v
1410       // +-----------+-----*-----+-----*-----+--
1411       // | ...             |b1|b2|b3|b4|
1412       // +-----------+-----*-----+-----*-----+--
1413       // |           |     |<-- Size ->|     |
1414       // |<---- Offset --->|           |<--->|
1415       // |           |     |              \_ DW_AT_bit_offset (little endian)
1416       // |           |<--->|
1417       // |<--------->|  \_ StartBitOffset = DW_AT_bit_offset (big endian)
1418       //     \                            = DW_AT_data_bit_offset (biendian)
1419       //      \_ OffsetInBytes
1420       uint64_t Offset = DT->getOffsetInBits();
1421       uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1422       uint64_t AlignMask = ~(Align - 1);
1423       // The bits from the start of the storage unit to the start of the field.
1424       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1425       // The endian-dependent DWARF 2 offset.
1426       uint64_t DwarfBitOffset = Asm->getDataLayout().isLittleEndian()
1427         ? OffsetToAlignment(Offset + Size, Align)
1428         : StartBitOffset;
1429
1430       // The byte offset of the field's aligned storage unit inside the struct.
1431       OffsetInBytes = (Offset - StartBitOffset) / 8;
1432       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, DwarfBitOffset);
1433     } else
1434       // This is not a bitfield.
1435       OffsetInBytes = DT->getOffsetInBits() / 8;
1436
1437     if (DD->getDwarfVersion() <= 2) {
1438       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1439       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1440       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1441       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1442     } else
1443       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1444               OffsetInBytes);
1445   }
1446
1447   if (DT->isProtected())
1448     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1449             dwarf::DW_ACCESS_protected);
1450   else if (DT->isPrivate())
1451     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1452             dwarf::DW_ACCESS_private);
1453   // Otherwise C++ member and base classes are considered public.
1454   else if (DT->isPublic())
1455     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1456             dwarf::DW_ACCESS_public);
1457   if (DT->isVirtual())
1458     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1459             dwarf::DW_VIRTUALITY_virtual);
1460
1461   // Objective-C properties.
1462   if (DINode *PNode = DT->getObjCProperty())
1463     if (DIE *PDie = getDIE(PNode))
1464       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1465                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1466
1467   if (DT->isArtificial())
1468     addFlag(MemberDie, dwarf::DW_AT_artificial);
1469 }
1470
1471 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1472   if (!DT)
1473     return nullptr;
1474
1475   // Construct the context before querying for the existence of the DIE in case
1476   // such construction creates the DIE.
1477   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1478   assert(dwarf::isType(ContextDIE->getTag()) &&
1479          "Static member should belong to a type.");
1480
1481   if (DIE *StaticMemberDIE = getDIE(DT))
1482     return StaticMemberDIE;
1483
1484   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1485
1486   const DIType *Ty = resolve(DT->getBaseType());
1487
1488   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1489   addType(StaticMemberDIE, Ty);
1490   addSourceLine(StaticMemberDIE, DT);
1491   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1492   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1493
1494   // FIXME: We could omit private if the parent is a class_type, and
1495   // public if the parent is something else.
1496   if (DT->isProtected())
1497     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1498             dwarf::DW_ACCESS_protected);
1499   else if (DT->isPrivate())
1500     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1501             dwarf::DW_ACCESS_private);
1502   else if (DT->isPublic())
1503     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1504             dwarf::DW_ACCESS_public);
1505
1506   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1507     addConstantValue(StaticMemberDIE, CI, Ty);
1508   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1509     addConstantFPValue(StaticMemberDIE, CFP);
1510
1511   return &StaticMemberDIE;
1512 }
1513
1514 void DwarfUnit::emitHeader(bool UseOffsets) {
1515   // Emit size of content not including length itself
1516   Asm->OutStreamer->AddComment("Length of Unit");
1517   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1518
1519   Asm->OutStreamer->AddComment("DWARF version number");
1520   Asm->EmitInt16(DD->getDwarfVersion());
1521   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1522
1523   // We share one abbreviations table across all units so it's always at the
1524   // start of the section. Use a relocatable offset where needed to ensure
1525   // linking doesn't invalidate that offset.
1526   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1527   Asm->emitDwarfSymbolReference(TLOF.getDwarfAbbrevSection()->getBeginSymbol(),
1528                                 UseOffsets);
1529
1530   Asm->OutStreamer->AddComment("Address Size (in bytes)");
1531   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1532 }
1533
1534 void DwarfUnit::initSection(MCSection *Section) {
1535   assert(!this->Section);
1536   this->Section = Section;
1537 }
1538
1539 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1540   DwarfUnit::emitHeader(UseOffsets);
1541   Asm->OutStreamer->AddComment("Type Signature");
1542   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1543   Asm->OutStreamer->AddComment("Type DIE Offset");
1544   // In a skeleton type unit there is no type DIE so emit a zero offset.
1545   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1546                                  sizeof(Ty->getOffset()));
1547 }
1548
1549 bool DwarfTypeUnit::isDwoUnit() const {
1550   // Since there are no skeleton type units, all type units are dwo type units
1551   // when split DWARF is being used.
1552   return DD->useSplitDwarf();
1553 }