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   }
1155
1156   // Add function template parameters.
1157   addTemplateParams(SPDie, SP->getTemplateParams());
1158
1159   // Add the linkage name if we have one and it isn't in the Decl.
1160   StringRef LinkageName = SP->getLinkageName();
1161   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1162           LinkageName == DeclLinkageName) &&
1163          "decl has a linkage name and it is different");
1164   if (DeclLinkageName.empty())
1165     addLinkageName(SPDie, LinkageName);
1166
1167   if (!DeclDie)
1168     return false;
1169
1170   // Refer to the function declaration where all the other attributes will be
1171   // found.
1172   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1173   return true;
1174 }
1175
1176 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1177                                           bool Minimal) {
1178   if (!Minimal)
1179     if (applySubprogramDefinitionAttributes(SP, SPDie))
1180       return;
1181
1182   // Constructors and operators for anonymous aggregates do not have names.
1183   if (!SP->getName().empty())
1184     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1185
1186   // Skip the rest of the attributes under -gmlt to save space.
1187   if (Minimal)
1188     return;
1189
1190   addSourceLine(SPDie, SP);
1191
1192   // Add the prototype if we have a prototype and we have a C like
1193   // language.
1194   uint16_t Language = getLanguage();
1195   if (SP->isPrototyped() &&
1196       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1197        Language == dwarf::DW_LANG_ObjC))
1198     addFlag(SPDie, dwarf::DW_AT_prototyped);
1199
1200   DITypeRefArray Args;
1201   if (const DISubroutineType *SPTy = SP->getType())
1202     Args = SPTy->getTypeArray();
1203
1204   // Add a return type. If this is a type like a C/C++ void type we don't add a
1205   // return type.
1206   if (Args.size())
1207     if (auto Ty = resolve(Args[0]))
1208       addType(SPDie, Ty);
1209
1210   unsigned VK = SP->getVirtuality();
1211   if (VK) {
1212     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1213     DIELoc *Block = getDIELoc();
1214     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1215     addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1216     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1217     ContainingTypeMap.insert(
1218         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1219   }
1220
1221   if (!SP->isDefinition()) {
1222     addFlag(SPDie, dwarf::DW_AT_declaration);
1223
1224     // Add arguments. Do not add arguments for subprogram definition. They will
1225     // be handled while processing variables.
1226     constructSubprogramArguments(SPDie, Args);
1227   }
1228
1229   if (SP->isArtificial())
1230     addFlag(SPDie, dwarf::DW_AT_artificial);
1231
1232   if (!SP->isLocalToUnit())
1233     addFlag(SPDie, dwarf::DW_AT_external);
1234
1235   if (SP->isOptimized())
1236     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1237
1238   if (unsigned isa = Asm->getISAEncoding())
1239     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1240
1241   if (SP->isLValueReference())
1242     addFlag(SPDie, dwarf::DW_AT_reference);
1243
1244   if (SP->isRValueReference())
1245     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1246
1247   if (SP->isProtected())
1248     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1249             dwarf::DW_ACCESS_protected);
1250   else if (SP->isPrivate())
1251     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1252             dwarf::DW_ACCESS_private);
1253   else if (SP->isPublic())
1254     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1255             dwarf::DW_ACCESS_public);
1256
1257   if (SP->isExplicit())
1258     addFlag(SPDie, dwarf::DW_AT_explicit);
1259 }
1260
1261 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1262                                      DIE *IndexTy) {
1263   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1264   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1265
1266   // The LowerBound value defines the lower bounds which is typically zero for
1267   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1268   // Count == -1 then the array is unbounded and we do not emit
1269   // DW_AT_lower_bound and DW_AT_count attributes.
1270   int64_t LowerBound = SR->getLowerBound();
1271   int64_t DefaultLowerBound = getDefaultLowerBound();
1272   int64_t Count = SR->getCount();
1273
1274   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1275     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1276
1277   if (Count != -1)
1278     // FIXME: An unbounded array should reference the expression that defines
1279     // the array.
1280     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1281 }
1282
1283 DIE *DwarfUnit::getIndexTyDie() {
1284   if (IndexTyDie)
1285     return IndexTyDie;
1286   // Construct an integer type to use for indexes.
1287   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1288   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1289   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1290   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1291           dwarf::DW_ATE_unsigned);
1292   return IndexTyDie;
1293 }
1294
1295 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1296   if (CTy->isVector())
1297     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1298
1299   // Emit the element type.
1300   addType(Buffer, resolve(CTy->getBaseType()));
1301
1302   // Get an anonymous type for index type.
1303   // FIXME: This type should be passed down from the front end
1304   // as different languages may have different sizes for indexes.
1305   DIE *IdxTy = getIndexTyDie();
1306
1307   // Add subranges to array type.
1308   DINodeArray Elements = CTy->getElements();
1309   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1310     // FIXME: Should this really be such a loose cast?
1311     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1312       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1313         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1314   }
1315 }
1316
1317 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1318   DINodeArray Elements = CTy->getElements();
1319
1320   // Add enumerators to enumeration type.
1321   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1322     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1323     if (Enum) {
1324       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1325       StringRef Name = Enum->getName();
1326       addString(Enumerator, dwarf::DW_AT_name, Name);
1327       int64_t Value = Enum->getValue();
1328       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1329               Value);
1330     }
1331   }
1332   const DIType *DTy = resolve(CTy->getBaseType());
1333   if (DTy) {
1334     addType(Buffer, DTy);
1335     addFlag(Buffer, dwarf::DW_AT_enum_class);
1336   }
1337 }
1338
1339 void DwarfUnit::constructContainingTypeDIEs() {
1340   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1341        CI != CE; ++CI) {
1342     DIE &SPDie = *CI->first;
1343     const DINode *D = CI->second;
1344     if (!D)
1345       continue;
1346     DIE *NDie = getDIE(D);
1347     if (!NDie)
1348       continue;
1349     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1350   }
1351 }
1352
1353 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1354   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1355   StringRef Name = DT->getName();
1356   if (!Name.empty())
1357     addString(MemberDie, dwarf::DW_AT_name, Name);
1358
1359   addType(MemberDie, resolve(DT->getBaseType()));
1360
1361   addSourceLine(MemberDie, DT);
1362
1363   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1364
1365     // For C++, virtual base classes are not at fixed offset. Use following
1366     // expression to extract appropriate offset from vtable.
1367     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1368
1369     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1370     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1371     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1372     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1373     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1374     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1375     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1376     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1377
1378     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1379   } else {
1380     uint64_t Size = DT->getSizeInBits();
1381     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1382     uint64_t OffsetInBytes;
1383
1384     if (FieldSize && Size != FieldSize) {
1385       // Handle bitfield, assume bytes are 8 bits.
1386       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1387       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1388       //
1389       // The DWARF 2 DW_AT_bit_offset is counting the bits between the most
1390       // significant bit of the aligned storage unit containing the bit field to
1391       // the most significan bit of the bit field.
1392       //
1393       // FIXME: DWARF 4 states that DW_AT_data_bit_offset (which
1394       // counts from the beginning, regardless of endianness) should
1395       // be used instead.
1396       //
1397       //
1398       // Struct      Align       Align       Align
1399       // v           v           v           v
1400       // +-----------+-----*-----+-----*-----+--
1401       // | ...             |b1|b2|b3|b4|
1402       // +-----------+-----*-----+-----*-----+--
1403       // |           |     |<-- Size ->|     |
1404       // |<---- Offset --->|           |<--->|
1405       // |           |     |              \_ DW_AT_bit_offset (little endian)
1406       // |           |<--->|
1407       // |<--------->|  \_ StartBitOffset = DW_AT_bit_offset (big endian)
1408       //     \                            = DW_AT_data_bit_offset (biendian)
1409       //      \_ OffsetInBytes
1410       uint64_t Offset = DT->getOffsetInBits();
1411       uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1412       uint64_t AlignMask = ~(Align - 1);
1413       // The bits from the start of the storage unit to the start of the field.
1414       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1415       // The endian-dependent DWARF 2 offset.
1416       uint64_t DwarfBitOffset = Asm->getDataLayout().isLittleEndian()
1417         ? OffsetToAlignment(Offset + Size, Align)
1418         : StartBitOffset;
1419
1420       // The byte offset of the field's aligned storage unit inside the struct.
1421       OffsetInBytes = (Offset - StartBitOffset) / 8;
1422       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, DwarfBitOffset);
1423     } else
1424       // This is not a bitfield.
1425       OffsetInBytes = DT->getOffsetInBits() / 8;
1426
1427     if (DD->getDwarfVersion() <= 2) {
1428       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1429       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1430       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1431       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1432     } else
1433       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1434               OffsetInBytes);
1435   }
1436
1437   if (DT->isProtected())
1438     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1439             dwarf::DW_ACCESS_protected);
1440   else if (DT->isPrivate())
1441     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1442             dwarf::DW_ACCESS_private);
1443   // Otherwise C++ member and base classes are considered public.
1444   else if (DT->isPublic())
1445     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1446             dwarf::DW_ACCESS_public);
1447   if (DT->isVirtual())
1448     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1449             dwarf::DW_VIRTUALITY_virtual);
1450
1451   // Objective-C properties.
1452   if (DINode *PNode = DT->getObjCProperty())
1453     if (DIE *PDie = getDIE(PNode))
1454       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1455                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1456
1457   if (DT->isArtificial())
1458     addFlag(MemberDie, dwarf::DW_AT_artificial);
1459 }
1460
1461 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1462   if (!DT)
1463     return nullptr;
1464
1465   // Construct the context before querying for the existence of the DIE in case
1466   // such construction creates the DIE.
1467   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1468   assert(dwarf::isType(ContextDIE->getTag()) &&
1469          "Static member should belong to a type.");
1470
1471   if (DIE *StaticMemberDIE = getDIE(DT))
1472     return StaticMemberDIE;
1473
1474   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1475
1476   const DIType *Ty = resolve(DT->getBaseType());
1477
1478   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1479   addType(StaticMemberDIE, Ty);
1480   addSourceLine(StaticMemberDIE, DT);
1481   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1482   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1483
1484   // FIXME: We could omit private if the parent is a class_type, and
1485   // public if the parent is something else.
1486   if (DT->isProtected())
1487     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1488             dwarf::DW_ACCESS_protected);
1489   else if (DT->isPrivate())
1490     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1491             dwarf::DW_ACCESS_private);
1492   else if (DT->isPublic())
1493     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1494             dwarf::DW_ACCESS_public);
1495
1496   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1497     addConstantValue(StaticMemberDIE, CI, Ty);
1498   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1499     addConstantFPValue(StaticMemberDIE, CFP);
1500
1501   return &StaticMemberDIE;
1502 }
1503
1504 void DwarfUnit::emitHeader(bool UseOffsets) {
1505   // Emit size of content not including length itself
1506   Asm->OutStreamer->AddComment("Length of Unit");
1507   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1508
1509   Asm->OutStreamer->AddComment("DWARF version number");
1510   Asm->EmitInt16(DD->getDwarfVersion());
1511   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1512
1513   // We share one abbreviations table across all units so it's always at the
1514   // start of the section. Use a relocatable offset where needed to ensure
1515   // linking doesn't invalidate that offset.
1516   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1517   Asm->emitDwarfSymbolReference(TLOF.getDwarfAbbrevSection()->getBeginSymbol(),
1518                                 UseOffsets);
1519
1520   Asm->OutStreamer->AddComment("Address Size (in bytes)");
1521   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1522 }
1523
1524 void DwarfUnit::initSection(MCSection *Section) {
1525   assert(!this->Section);
1526   this->Section = Section;
1527 }
1528
1529 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1530   DwarfUnit::emitHeader(UseOffsets);
1531   Asm->OutStreamer->AddComment("Type Signature");
1532   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1533   Asm->OutStreamer->AddComment("Type DIE Offset");
1534   // In a skeleton type unit there is no type DIE so emit a zero offset.
1535   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1536                                  sizeof(Ty->getOffset()));
1537 }
1538
1539 bool DwarfTypeUnit::isDwoUnit() const {
1540   // Since there are no skeleton type units, all type units are dwo type units
1541   // when split DWARF is being used.
1542   return DD->useSplitDwarf();
1543 }