lib/CodeGen/AsmPrinter/DwarfUnit.cpp

   1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for constructing a dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "DwarfUnit.h"
  15 #include "DwarfAccelTable.h"
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfDebug.h"
  18 #include "DwarfExpression.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DIBuilder.h"
  23 #include "llvm/IR/DataLayout.h"
  24 #include "llvm/IR/GlobalVariable.h"
  25 #include "llvm/IR/Instructions.h"
  26 #include "llvm/IR/Mangler.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/MC/MCContext.h"
  29 #include "llvm/MC/MCSection.h"
  30 #include "llvm/MC/MCStreamer.h"
  31 #include "llvm/Support/CommandLine.h"
  32 #include "llvm/Target/TargetFrameLowering.h"
  33 #include "llvm/Target/TargetLoweringObjectFile.h"
  34 #include "llvm/Target/TargetMachine.h"
  35 #include "llvm/Target/TargetRegisterInfo.h"
  36 #include "llvm/Target/TargetSubtargetInfo.h"
  37
  38 using namespace llvm;
  39
  40 #define DEBUG_TYPE "dwarfdebug"
  41
  42 static cl::opt<bool>
  43 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  44                        cl::desc("Generate DWARF4 type units."),
  45                        cl::init(false));
  46
  47 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
  48                                        DIELoc &DIE)
  49     : DwarfExpression(*AP.MF->getSubtarget().getRegisterInfo(),
  50                       AP.getDwarfDebug()->getDwarfVersion()),
  51       AP(AP), DU(DU), DIE(DIE) {}
  52
  53 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
  54   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
  55 }
  56 void DIEDwarfExpression::EmitSigned(int64_t Value) {
  57   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
  58 }
  59 void DIEDwarfExpression::EmitUnsigned(uint64_t Value) {
  60   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
  61 }
  62 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
  63   return MachineReg == TRI.getFrameRegister(*AP.MF);
  64 }
  65
  66 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag,
  67                      const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
  68                      DwarfFile *DWU)
  69     : UniqueID(UID), CUNode(Node),
  70       UnitDie(*DIE::get(DIEValueAllocator, UnitTag)), DebugInfoOffset(0),
  71       Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  72   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  73          UnitTag == dwarf::DW_TAG_type_unit);
  74 }
  75
  76 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
  77                              DwarfDebug *DW, DwarfFile *DWU,
  78                              MCDwarfDwoLineTable *SplitLineTable)
  79     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
  80       CU(CU), SplitLineTable(SplitLineTable) {
  81   if (SplitLineTable)
  82     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  83 }
  84
  85 DwarfUnit::~DwarfUnit() {
  86   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  87     DIEBlocks[j]->~DIEBlock();
  88   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  89     DIELocs[j]->~DIELoc();
  90 }
  91
  92 int64_t DwarfUnit::getDefaultLowerBound() const {
  93   switch (getLanguage()) {
  94   default:
  95     break;
  96
  97   case dwarf::DW_LANG_C89:
  98   case dwarf::DW_LANG_C99:
  99   case dwarf::DW_LANG_C:
 100   case dwarf::DW_LANG_C_plus_plus:
 101   case dwarf::DW_LANG_ObjC:
 102   case dwarf::DW_LANG_ObjC_plus_plus:
 103     return 0;
 104
 105   case dwarf::DW_LANG_Fortran77:
 106   case dwarf::DW_LANG_Fortran90:
 107   case dwarf::DW_LANG_Fortran95:
 108     return 1;
 109
 110   // The languages below have valid values only if the DWARF version >= 4.
 111   case dwarf::DW_LANG_Java:
 112   case dwarf::DW_LANG_Python:
 113   case dwarf::DW_LANG_UPC:
 114   case dwarf::DW_LANG_D:
 115     if (dwarf::DWARF_VERSION >= 4)
 116       return 0;
 117     break;
 118
 119   case dwarf::DW_LANG_Ada83:
 120   case dwarf::DW_LANG_Ada95:
 121   case dwarf::DW_LANG_Cobol74:
 122   case dwarf::DW_LANG_Cobol85:
 123   case dwarf::DW_LANG_Modula2:
 124   case dwarf::DW_LANG_Pascal83:
 125   case dwarf::DW_LANG_PLI:
 126     if (dwarf::DWARF_VERSION >= 4)
 127       return 1;
 128     break;
 129
 130   // The languages below have valid values only if the DWARF version >= 5.
 131   case dwarf::DW_LANG_OpenCL:
 132   case dwarf::DW_LANG_Go:
 133   case dwarf::DW_LANG_Haskell:
 134   case dwarf::DW_LANG_C_plus_plus_03:
 135   case dwarf::DW_LANG_C_plus_plus_11:
 136   case dwarf::DW_LANG_OCaml:
 137   case dwarf::DW_LANG_Rust:
 138   case dwarf::DW_LANG_C11:
 139   case dwarf::DW_LANG_Swift:
 140   case dwarf::DW_LANG_Dylan:
 141   case dwarf::DW_LANG_C_plus_plus_14:
 142     if (dwarf::DWARF_VERSION >= 5)
 143       return 0;
 144     break;
 145
 146   case dwarf::DW_LANG_Modula3:
 147   case dwarf::DW_LANG_Julia:
 148   case dwarf::DW_LANG_Fortran03:
 149   case dwarf::DW_LANG_Fortran08:
 150     if (dwarf::DWARF_VERSION >= 5)
 151       return 1;
 152     break;
 153   }
 154
 155   return -1;
 156 }
 157
 158 /// Check whether the DIE for this MDNode can be shared across CUs.
 159 static bool isShareableAcrossCUs(const DINode *D) {
 160   // When the MDNode can be part of the type system, the DIE can be shared
 161   // across CUs.
 162   // Combining type units and cross-CU DIE sharing is lower value (since
 163   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 164   // level already) but may be implementable for some value in projects
 165   // building multiple independent libraries with LTO and then linking those
 166   // together.
 167   return (isa<DIType>(D) ||
 168           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
 169          !GenerateDwarfTypeUnits;
 170 }
 171
 172 DIE *DwarfUnit::getDIE(const DINode *D) const {
 173   if (isShareableAcrossCUs(D))
 174     return DU->getDIE(D);
 175   return MDNodeToDieMap.lookup(D);
 176 }
 177
 178 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
 179   if (isShareableAcrossCUs(Desc)) {
 180     DU->insertDIE(Desc, D);
 181     return;
 182   }
 183   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 184 }
 185
 186 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 187   if (DD->getDwarfVersion() >= 4)
 188     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
 189                  DIEInteger(1));
 190   else
 191     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
 192                  DIEInteger(1));
 193 }
 194
 195 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
 196                         Optional<dwarf::Form> Form, uint64_t Integer) {
 197   if (!Form)
 198     Form = DIEInteger::BestForm(false, Integer);
 199   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 200 }
 201
 202 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
 203   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 204 }
 205
 206 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
 207                         Optional<dwarf::Form> Form, int64_t Integer) {
 208   if (!Form)
 209     Form = DIEInteger::BestForm(true, Integer);
 210   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 211 }
 212
 213 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 214                         int64_t Integer) {
 215   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 216 }
 217
 218 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 219                           StringRef String) {
 220   Die.addValue(DIEValueAllocator, Attribute,
 221                isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
 222                DIEString(DU->getStringPool().getEntry(*Asm, String)));
 223 }
 224
 225 DIE::value_iterator DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute,
 226                                         dwarf::Form Form,
 227                                         const MCSymbol *Label) {
 228   return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
 229 }
 230
 231 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 232   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 233 }
 234
 235 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 236                                  uint64_t Integer) {
 237   if (DD->getDwarfVersion() >= 4)
 238     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 239   else
 240     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 241 }
 242
 243 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
 244   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
 245                         : getCU().getOrCreateSourceID(FileName, DirName);
 246 }
 247
 248 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 249   if (!DD->useSplitDwarf()) {
 250     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 251     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 252   } else {
 253     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 254     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 255             DD->getAddressPool().getIndex(Sym));
 256   }
 257 }
 258
 259 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 260                               const MCSymbol *Hi, const MCSymbol *Lo) {
 261   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
 262                new (DIEValueAllocator) DIEDelta(Hi, Lo));
 263 }
 264
 265 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 266   addDIEEntry(Die, Attribute, DIEEntry(Entry));
 267 }
 268
 269 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
 270   // Flag the type unit reference as a declaration so that if it contains
 271   // members (implicit special members, static data member definitions, member
 272   // declarations for definitions in this CU, etc) consumers don't get confused
 273   // and think this is a full definition.
 274   addFlag(Die, dwarf::DW_AT_declaration);
 275
 276   Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
 277                dwarf::DW_FORM_ref_sig8, DIETypeSignature(Type));
 278 }
 279
 280 void DwarfUnit::addDIETypeSignature(DIE &Die, dwarf::Attribute Attribute,
 281                                     StringRef Identifier) {
 282   uint64_t Signature = DD->makeTypeSignature(Identifier);
 283   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_ref_sig8,
 284                DIEInteger(Signature));
 285 }
 286
 287 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 288                             DIEEntry Entry) {
 289   const DIE *DieCU = Die.getUnitOrNull();
 290   const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
 291   if (!DieCU)
 292     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 293     DieCU = &getUnitDie();
 294   if (!EntryCU)
 295     EntryCU = &getUnitDie();
 296   Die.addValue(DIEValueAllocator, Attribute,
 297                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 298                Entry);
 299 }
 300
 301 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
 302   assert(Tag != dwarf::DW_TAG_auto_variable &&
 303          Tag != dwarf::DW_TAG_arg_variable);
 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())
 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   return getDIE(Context);
 697 }
 698
 699 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
 700   auto *Context = resolve(Ty->getScope());
 701   DIE *ContextDIE = getOrCreateContextDIE(Context);
 702
 703   if (DIE *TyDIE = getDIE(Ty))
 704     return TyDIE;
 705
 706   // Create new type.
 707   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 708
 709   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
 710
 711   if (!Ty->isExternalTypeRef())
 712     updateAcceleratorTables(Context, Ty, TyDIE);
 713   return &TyDIE;
 714 }
 715
 716 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 717   if (!TyNode)
 718     return nullptr;
 719
 720   auto *Ty = cast<DIType>(TyNode);
 721   assert(Ty == resolve(Ty->getRef()) &&
 722          "type was not uniqued, possible ODR violation.");
 723
 724   // DW_TAG_restrict_type is not supported in DWARF2
 725   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 726     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
 727
 728   // Construct the context before querying for the existence of the DIE in case
 729   // such construction creates the DIE.
 730   auto *Context = resolve(Ty->getScope());
 731   DIE *ContextDIE = getOrCreateContextDIE(Context);
 732   assert(ContextDIE);
 733
 734   if (DIE *TyDIE = getDIE(Ty))
 735     return TyDIE;
 736
 737   // Create new type.
 738   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 739
 740   updateAcceleratorTables(Context, Ty, TyDIE);
 741
 742   if (auto *BT = dyn_cast<DIBasicType>(Ty))
 743     constructTypeDIE(TyDIE, BT);
 744   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
 745     constructTypeDIE(TyDIE, STy);
 746   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 747     if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
 748       if (MDString *TypeId = CTy->getRawIdentifier()) {
 749         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 750         // Skip updating the accelerator tables since this is not the full type.
 751         return &TyDIE;
 752       }
 753     constructTypeDIE(TyDIE, CTy);
 754   } else {
 755     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
 756   }
 757
 758   return &TyDIE;
 759 }
 760
 761 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
 762                                         const DIType *Ty, const DIE &TyDIE) {
 763   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
 764     bool IsImplementation = 0;
 765     if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
 766       // A runtime language of 0 actually means C/C++ and that any
 767       // non-negative value is some version of Objective-C/C++.
 768       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
 769     }
 770     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 771     DD->addAccelType(Ty->getName(), TyDIE, Flags);
 772
 773     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
 774         isa<DINamespace>(Context))
 775       addGlobalType(Ty, TyDIE, Context);
 776   }
 777 }
 778
 779 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
 780                         dwarf::Attribute Attribute) {
 781   assert(Ty && "Trying to add a type that doesn't exist?");
 782   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
 783 }
 784
 785 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
 786   if (!Context)
 787     return "";
 788
 789   // FIXME: Decide whether to implement this for non-C++ languages.
 790   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 791     return "";
 792
 793   std::string CS;
 794   SmallVector<const DIScope *, 1> Parents;
 795   while (!isa<DICompileUnit>(Context)) {
 796     Parents.push_back(Context);
 797     if (Context->getScope())
 798       Context = resolve(Context->getScope());
 799     else
 800       // Structure, etc types will have a NULL context if they're at the top
 801       // level.
 802       break;
 803   }
 804
 805   // Reverse iterate over our list to go from the outermost construct to the
 806   // innermost.
 807   for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
 808     StringRef Name = Ctx->getName();
 809     if (Name.empty() && isa<DINamespace>(Ctx))
 810       Name = "(anonymous namespace)";
 811     if (!Name.empty()) {
 812       CS += Name;
 813       CS += "::";
 814     }
 815   }
 816   return CS;
 817 }
 818
 819 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
 820   // Get core information.
 821   StringRef Name = BTy->getName();
 822   // Add name if not anonymous or intermediate type.
 823   if (!Name.empty())
 824     addString(Buffer, dwarf::DW_AT_name, Name);
 825
 826   // An unspecified type only has a name attribute.
 827   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
 828     return;
 829
 830   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 831           BTy->getEncoding());
 832
 833   uint64_t Size = BTy->getSizeInBits() >> 3;
 834   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 835 }
 836
 837 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
 838   // Get core information.
 839   StringRef Name = DTy->getName();
 840   uint64_t Size = DTy->getSizeInBits() >> 3;
 841   uint16_t Tag = Buffer.getTag();
 842
 843   // Map to main type, void will not have a type.
 844   const DIType *FromTy = resolve(DTy->getBaseType());
 845   if (FromTy)
 846     addType(Buffer, FromTy);
 847
 848   // Add name if not anonymous or intermediate type.
 849   if (!Name.empty())
 850     addString(Buffer, dwarf::DW_AT_name, Name);
 851
 852   // Add size if non-zero (derived types might be zero-sized.)
 853   if (Size && Tag != dwarf::DW_TAG_pointer_type
 854            && Tag != dwarf::DW_TAG_ptr_to_member_type)
 855     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 856
 857   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 858     addDIEEntry(
 859         Buffer, dwarf::DW_AT_containing_type,
 860         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
 861   // Add source line info if available and TyDesc is not a forward declaration.
 862   if (!DTy->isForwardDecl())
 863     addSourceLine(Buffer, DTy);
 864 }
 865
 866 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
 867   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 868     const DIType *Ty = resolve(Args[i]);
 869     if (!Ty) {
 870       assert(i == N-1 && "Unspecified parameter must be the last argument");
 871       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 872     } else {
 873       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 874       addType(Arg, Ty);
 875       if (Ty->isArtificial())
 876         addFlag(Arg, dwarf::DW_AT_artificial);
 877     }
 878   }
 879 }
 880
 881 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 882   // Add return type.  A void return won't have a type.
 883   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
 884   if (Elements.size())
 885     if (auto RTy = resolve(Elements[0]))
 886       addType(Buffer, RTy);
 887
 888   bool isPrototyped = true;
 889   if (Elements.size() == 2 && !Elements[1])
 890     isPrototyped = false;
 891
 892   constructSubprogramArguments(Buffer, Elements);
 893
 894   // Add prototype flag if we're dealing with a C language and the function has
 895   // been prototyped.
 896   uint16_t Language = getLanguage();
 897   if (isPrototyped &&
 898       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
 899        Language == dwarf::DW_LANG_ObjC))
 900     addFlag(Buffer, dwarf::DW_AT_prototyped);
 901
 902   if (CTy->isLValueReference())
 903     addFlag(Buffer, dwarf::DW_AT_reference);
 904
 905   if (CTy->isRValueReference())
 906     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 907 }
 908
 909 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
 910   if (CTy->isExternalTypeRef()) {
 911     StringRef Identifier = CTy->getIdentifier();
 912     assert(!Identifier.empty() && "external type ref without identifier");
 913     addFlag(Buffer, dwarf::DW_AT_declaration);
 914     return addDIETypeSignature(Buffer, dwarf::DW_AT_signature, Identifier);
 915   }
 916
 917   // Add name if not anonymous or intermediate type.
 918   StringRef Name = CTy->getName();
 919
 920   uint64_t Size = CTy->getSizeInBits() >> 3;
 921   uint16_t Tag = Buffer.getTag();
 922
 923   switch (Tag) {
 924   case dwarf::DW_TAG_array_type:
 925     constructArrayTypeDIE(Buffer, CTy);
 926     break;
 927   case dwarf::DW_TAG_enumeration_type:
 928     constructEnumTypeDIE(Buffer, CTy);
 929     break;
 930   case dwarf::DW_TAG_structure_type:
 931   case dwarf::DW_TAG_union_type:
 932   case dwarf::DW_TAG_class_type: {
 933     // Add elements to structure type.
 934     DINodeArray Elements = CTy->getElements();
 935     for (const auto *Element : Elements) {
 936       if (!Element)
 937         continue;
 938       if (auto *SP = dyn_cast<DISubprogram>(Element))
 939         getOrCreateSubprogramDIE(SP);
 940       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
 941         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
 942           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
 943           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
 944         } else if (DDTy->isStaticMember()) {
 945           getOrCreateStaticMemberDIE(DDTy);
 946         } else {
 947           constructMemberDIE(Buffer, DDTy);
 948         }
 949       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
 950         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
 951         StringRef PropertyName = Property->getName();
 952         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 953         if (Property->getType())
 954           addType(ElemDie, resolve(Property->getType()));
 955         addSourceLine(ElemDie, Property);
 956         StringRef GetterName = Property->getGetterName();
 957         if (!GetterName.empty())
 958           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 959         StringRef SetterName = Property->getSetterName();
 960         if (!SetterName.empty())
 961           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 962         if (unsigned PropertyAttributes = Property->getAttributes())
 963           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
 964                   PropertyAttributes);
 965       }
 966     }
 967
 968     if (CTy->isAppleBlockExtension())
 969       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 970
 971     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
 972     // inside C++ composite types to point to the base class with the vtable.
 973     if (auto *ContainingType =
 974             dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
 975       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 976                   *getOrCreateTypeDIE(ContainingType));
 977
 978     if (CTy->isObjcClassComplete())
 979       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 980
 981     // Add template parameters to a class, structure or union types.
 982     // FIXME: The support isn't in the metadata for this yet.
 983     if (Tag == dwarf::DW_TAG_class_type ||
 984         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 985       addTemplateParams(Buffer, CTy->getTemplateParams());
 986
 987     break;
 988   }
 989   default:
 990     break;
 991   }
 992
 993   // Add name if not anonymous or intermediate type.
 994   if (!Name.empty())
 995     addString(Buffer, dwarf::DW_AT_name, Name);
 996
 997   if (Tag == dwarf::DW_TAG_enumeration_type ||
 998       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
 999       Tag == dwarf::DW_TAG_union_type) {
1000     // Add size if non-zero (derived types might be zero-sized.)
1001     // TODO: Do we care about size for enum forward declarations?
1002     if (Size)
1003       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1004     else if (!CTy->isForwardDecl())
1005       // Add zero size if it is not a forward declaration.
1006       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1007
1008     // If we're a forward decl, say so.
1009     if (CTy->isForwardDecl())
1010       addFlag(Buffer, dwarf::DW_AT_declaration);
1011
1012     // Add source line info if available.
1013     if (!CTy->isForwardDecl())
1014       addSourceLine(Buffer, CTy);
1015
1016     // No harm in adding the runtime language to the declaration.
1017     unsigned RLang = CTy->getRuntimeLang();
1018     if (RLang)
1019       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1020               RLang);
1021   }
1022 }
1023
1024 void DwarfUnit::constructTemplateTypeParameterDIE(
1025     DIE &Buffer, const DITemplateTypeParameter *TP) {
1026   DIE &ParamDIE =
1027       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1028   // Add the type if it exists, it could be void and therefore no type.
1029   if (TP->getType())
1030     addType(ParamDIE, resolve(TP->getType()));
1031   if (!TP->getName().empty())
1032     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1033 }
1034
1035 void DwarfUnit::constructTemplateValueParameterDIE(
1036     DIE &Buffer, const DITemplateValueParameter *VP) {
1037   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1038
1039   // Add the type if there is one, template template and template parameter
1040   // packs will not have a type.
1041   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1042     addType(ParamDIE, resolve(VP->getType()));
1043   if (!VP->getName().empty())
1044     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1045   if (Metadata *Val = VP->getValue()) {
1046     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1047       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1048     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1049       // For declaration non-type template parameters (such as global values and
1050       // functions)
1051       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1052       addOpAddress(*Loc, Asm->getSymbol(GV));
1053       // Emit DW_OP_stack_value to use the address as the immediate value of the
1054       // parameter, rather than a pointer to it.
1055       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1056       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1057     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1058       assert(isa<MDString>(Val));
1059       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1060                 cast<MDString>(Val)->getString());
1061     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1062       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1063     }
1064   }
1065 }
1066
1067 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1068   // Construct the context before querying for the existence of the DIE in case
1069   // such construction creates the DIE.
1070   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1071
1072   if (DIE *NDie = getDIE(NS))
1073     return NDie;
1074   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1075
1076   StringRef Name = NS->getName();
1077   if (!Name.empty())
1078     addString(NDie, dwarf::DW_AT_name, NS->getName());
1079   else
1080     Name = "(anonymous namespace)";
1081   DD->addAccelNamespace(Name, NDie);
1082   addGlobalName(Name, NDie, NS->getScope());
1083   addSourceLine(NDie, NS);
1084   return &NDie;
1085 }
1086
1087 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1088   // Construct the context before querying for the existence of the DIE in case
1089   // such construction creates the DIE.
1090   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1091
1092   if (DIE *MDie = getDIE(M))
1093     return MDie;
1094   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1095
1096   if (!M->getName().empty()) {
1097     addString(MDie, dwarf::DW_AT_name, M->getName());
1098     addGlobalName(M->getName(), MDie, M->getScope());
1099   }
1100   if (!M->getConfigurationMacros().empty())
1101     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1102               M->getConfigurationMacros());
1103   if (!M->getIncludePath().empty())
1104     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1105   if (!M->getISysRoot().empty())
1106     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1107
1108   return &MDie;
1109 }
1110
1111 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1112   // Construct the context before querying for the existence of the DIE in case
1113   // such construction creates the DIE (as is the case for member function
1114   // declarations).
1115   DIE *ContextDIE =
1116       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1117
1118   if (DIE *SPDie = getDIE(SP))
1119     return SPDie;
1120
1121   if (auto *SPDecl = SP->getDeclaration()) {
1122     if (!Minimal) {
1123       // Add subprogram definitions to the CU die directly.
1124       ContextDIE = &getUnitDie();
1125       // Build the decl now to ensure it precedes the definition.
1126       getOrCreateSubprogramDIE(SPDecl);
1127     }
1128   }
1129
1130   // DW_TAG_inlined_subroutine may refer to this DIE.
1131   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1132
1133   // Stop here and fill this in later, depending on whether or not this
1134   // subprogram turns out to have inlined instances or not.
1135   if (SP->isDefinition())
1136     return &SPDie;
1137
1138   applySubprogramAttributes(SP, SPDie);
1139   return &SPDie;
1140 }
1141
1142 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1143                                                     DIE &SPDie) {
1144   DIE *DeclDie = nullptr;
1145   StringRef DeclLinkageName;
1146   if (auto *SPDecl = SP->getDeclaration()) {
1147     DeclDie = getDIE(SPDecl);
1148     assert(DeclDie && "This DIE should've already been constructed when the "
1149                       "definition DIE was created in "
1150                       "getOrCreateSubprogramDIE");
1151     DeclLinkageName = SPDecl->getLinkageName();
1152   }
1153
1154   // Add function template parameters.
1155   addTemplateParams(SPDie, SP->getTemplateParams());
1156
1157   // Add the linkage name if we have one and it isn't in the Decl.
1158   StringRef LinkageName = SP->getLinkageName();
1159   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1160           LinkageName == DeclLinkageName) &&
1161          "decl has a linkage name and it is different");
1162   if (DeclLinkageName.empty())
1163     addLinkageName(SPDie, LinkageName);
1164
1165   if (!DeclDie)
1166     return false;
1167
1168   // Refer to the function declaration where all the other attributes will be
1169   // found.
1170   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1171   return true;
1172 }
1173
1174 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1175                                           bool Minimal) {
1176   if (!Minimal)
1177     if (applySubprogramDefinitionAttributes(SP, SPDie))
1178       return;
1179
1180   // Constructors and operators for anonymous aggregates do not have names.
1181   if (!SP->getName().empty())
1182     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1183
1184   // Skip the rest of the attributes under -gmlt to save space.
1185   if (Minimal)
1186     return;
1187
1188   addSourceLine(SPDie, SP);
1189
1190   // Add the prototype if we have a prototype and we have a C like
1191   // language.
1192   uint16_t Language = getLanguage();
1193   if (SP->isPrototyped() &&
1194       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1195        Language == dwarf::DW_LANG_ObjC))
1196     addFlag(SPDie, dwarf::DW_AT_prototyped);
1197
1198   const DISubroutineType *SPTy = SP->getType();
1199   assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1200          "the type of a subprogram should be a subroutine");
1201
1202   auto Args = SPTy->getTypeArray();
1203   // Add a return type. If this is a type like a C/C++ void type we don't add a
1204   // return type.
1205   if (Args.size())
1206     if (auto Ty = resolve(Args[0]))
1207       addType(SPDie, Ty);
1208
1209   unsigned VK = SP->getVirtuality();
1210   if (VK) {
1211     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1212     DIELoc *Block = getDIELoc();
1213     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1214     addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1215     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1216     ContainingTypeMap.insert(
1217         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1218   }
1219
1220   if (!SP->isDefinition()) {
1221     addFlag(SPDie, dwarf::DW_AT_declaration);
1222
1223     // Add arguments. Do not add arguments for subprogram definition. They will
1224     // be handled while processing variables.
1225     constructSubprogramArguments(SPDie, Args);
1226   }
1227
1228   if (SP->isArtificial())
1229     addFlag(SPDie, dwarf::DW_AT_artificial);
1230
1231   if (!SP->isLocalToUnit())
1232     addFlag(SPDie, dwarf::DW_AT_external);
1233
1234   if (SP->isOptimized())
1235     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1236
1237   if (unsigned isa = Asm->getISAEncoding())
1238     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1239
1240   if (SP->isLValueReference())
1241     addFlag(SPDie, dwarf::DW_AT_reference);
1242
1243   if (SP->isRValueReference())
1244     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1245
1246   if (SP->isProtected())
1247     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1248             dwarf::DW_ACCESS_protected);
1249   else if (SP->isPrivate())
1250     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1251             dwarf::DW_ACCESS_private);
1252   else if (SP->isPublic())
1253     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1254             dwarf::DW_ACCESS_public);
1255
1256   if (SP->isExplicit())
1257     addFlag(SPDie, dwarf::DW_AT_explicit);
1258 }
1259
1260 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1261                                      DIE *IndexTy) {
1262   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1263   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1264
1265   // The LowerBound value defines the lower bounds which is typically zero for
1266   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1267   // Count == -1 then the array is unbounded and we do not emit
1268   // DW_AT_lower_bound and DW_AT_count attributes.
1269   int64_t LowerBound = SR->getLowerBound();
1270   int64_t DefaultLowerBound = getDefaultLowerBound();
1271   int64_t Count = SR->getCount();
1272
1273   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1274     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1275
1276   if (Count != -1)
1277     // FIXME: An unbounded array should reference the expression that defines
1278     // the array.
1279     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1280 }
1281
1282 DIE *DwarfUnit::getIndexTyDie() {
1283   if (IndexTyDie)
1284     return IndexTyDie;
1285   // Construct an integer type to use for indexes.
1286   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1287   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1288   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1289   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1290           dwarf::DW_ATE_unsigned);
1291   return IndexTyDie;
1292 }
1293
1294 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1295   if (CTy->isVector())
1296     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1297
1298   // Emit the element type.
1299   addType(Buffer, resolve(CTy->getBaseType()));
1300
1301   // Get an anonymous type for index type.
1302   // FIXME: This type should be passed down from the front end
1303   // as different languages may have different sizes for indexes.
1304   DIE *IdxTy = getIndexTyDie();
1305
1306   // Add subranges to array type.
1307   DINodeArray Elements = CTy->getElements();
1308   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1309     // FIXME: Should this really be such a loose cast?
1310     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1311       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1312         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1313   }
1314 }
1315
1316 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1317   DINodeArray Elements = CTy->getElements();
1318
1319   // Add enumerators to enumeration type.
1320   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1321     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1322     if (Enum) {
1323       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1324       StringRef Name = Enum->getName();
1325       addString(Enumerator, dwarf::DW_AT_name, Name);
1326       int64_t Value = Enum->getValue();
1327       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1328               Value);
1329     }
1330   }
1331   const DIType *DTy = resolve(CTy->getBaseType());
1332   if (DTy) {
1333     addType(Buffer, DTy);
1334     addFlag(Buffer, dwarf::DW_AT_enum_class);
1335   }
1336 }
1337
1338 void DwarfUnit::constructContainingTypeDIEs() {
1339   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1340        CI != CE; ++CI) {
1341     DIE &SPDie = *CI->first;
1342     const DINode *D = CI->second;
1343     if (!D)
1344       continue;
1345     DIE *NDie = getDIE(D);
1346     if (!NDie)
1347       continue;
1348     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1349   }
1350 }
1351
1352 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1353   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1354   StringRef Name = DT->getName();
1355   if (!Name.empty())
1356     addString(MemberDie, dwarf::DW_AT_name, Name);
1357
1358   addType(MemberDie, resolve(DT->getBaseType()));
1359
1360   addSourceLine(MemberDie, DT);
1361
1362   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1363
1364     // For C++, virtual base classes are not at fixed offset. Use following
1365     // expression to extract appropriate offset from vtable.
1366     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1367
1368     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1369     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1370     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1371     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1372     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1373     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1374     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1375     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1376
1377     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1378   } else {
1379     uint64_t Size = DT->getSizeInBits();
1380     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1381     uint64_t OffsetInBytes;
1382
1383     if (FieldSize && Size != FieldSize) {
1384       // Handle bitfield, assume bytes are 8 bits.
1385       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1386       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1387       //
1388       // The DWARF 2 DW_AT_bit_offset is counting the bits between the most
1389       // significant bit of the aligned storage unit containing the bit field to
1390       // the most significan bit of the bit field.
1391       //
1392       // FIXME: DWARF 4 states that DW_AT_data_bit_offset (which
1393       // counts from the beginning, regardless of endianness) should
1394       // be used instead.
1395       //
1396       //
1397       // Struct      Align       Align       Align
1398       // v           v           v           v
1399       // +-----------+-----*-----+-----*-----+--
1400       // | ...             |b1|b2|b3|b4|
1401       // +-----------+-----*-----+-----*-----+--
1402       // |           |     |<-- Size ->|     |
1403       // |<---- Offset --->|           |<--->|
1404       // |           |     |              \_ DW_AT_bit_offset (little endian)
1405       // |           |<--->|
1406       // |<--------->|  \_ StartBitOffset = DW_AT_bit_offset (big endian)
1407       //     \                            = DW_AT_data_bit_offset (biendian)
1408       //      \_ OffsetInBytes
1409       uint64_t Offset = DT->getOffsetInBits();
1410       uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1411       uint64_t AlignMask = ~(Align - 1);
1412       // The bits from the start of the storage unit to the start of the field.
1413       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1414       // The endian-dependent DWARF 2 offset.
1415       uint64_t DwarfBitOffset = Asm->getDataLayout().isLittleEndian()
1416         ? OffsetToAlignment(Offset + Size, Align)
1417         : StartBitOffset;
1418
1419       // The byte offset of the field's aligned storage unit inside the struct.
1420       OffsetInBytes = (Offset - StartBitOffset) / 8;
1421       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, DwarfBitOffset);
1422     } else
1423       // This is not a bitfield.
1424       OffsetInBytes = DT->getOffsetInBits() / 8;
1425
1426     if (DD->getDwarfVersion() <= 2) {
1427       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1428       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1429       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1430       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1431     } else
1432       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1433               OffsetInBytes);
1434   }
1435
1436   if (DT->isProtected())
1437     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1438             dwarf::DW_ACCESS_protected);
1439   else if (DT->isPrivate())
1440     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1441             dwarf::DW_ACCESS_private);
1442   // Otherwise C++ member and base classes are considered public.
1443   else if (DT->isPublic())
1444     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1445             dwarf::DW_ACCESS_public);
1446   if (DT->isVirtual())
1447     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1448             dwarf::DW_VIRTUALITY_virtual);
1449
1450   // Objective-C properties.
1451   if (DINode *PNode = DT->getObjCProperty())
1452     if (DIE *PDie = getDIE(PNode))
1453       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1454                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1455
1456   if (DT->isArtificial())
1457     addFlag(MemberDie, dwarf::DW_AT_artificial);
1458 }
1459
1460 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1461   if (!DT)
1462     return nullptr;
1463
1464   // Construct the context before querying for the existence of the DIE in case
1465   // such construction creates the DIE.
1466   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1467   assert(dwarf::isType(ContextDIE->getTag()) &&
1468          "Static member should belong to a type.");
1469
1470   if (DIE *StaticMemberDIE = getDIE(DT))
1471     return StaticMemberDIE;
1472
1473   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1474
1475   const DIType *Ty = resolve(DT->getBaseType());
1476
1477   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1478   addType(StaticMemberDIE, Ty);
1479   addSourceLine(StaticMemberDIE, DT);
1480   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1481   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1482
1483   // FIXME: We could omit private if the parent is a class_type, and
1484   // public if the parent is something else.
1485   if (DT->isProtected())
1486     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1487             dwarf::DW_ACCESS_protected);
1488   else if (DT->isPrivate())
1489     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1490             dwarf::DW_ACCESS_private);
1491   else if (DT->isPublic())
1492     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1493             dwarf::DW_ACCESS_public);
1494
1495   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1496     addConstantValue(StaticMemberDIE, CI, Ty);
1497   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1498     addConstantFPValue(StaticMemberDIE, CFP);
1499
1500   return &StaticMemberDIE;
1501 }
1502
1503 void DwarfUnit::emitHeader(bool UseOffsets) {
1504   // Emit size of content not including length itself
1505   Asm->OutStreamer->AddComment("Length of Unit");
1506   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1507
1508   Asm->OutStreamer->AddComment("DWARF version number");
1509   Asm->EmitInt16(DD->getDwarfVersion());
1510   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1511
1512   // We share one abbreviations table across all units so it's always at the
1513   // start of the section. Use a relocatable offset where needed to ensure
1514   // linking doesn't invalidate that offset.
1515   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1516   Asm->emitDwarfSymbolReference(TLOF.getDwarfAbbrevSection()->getBeginSymbol(),
1517                                 UseOffsets);
1518
1519   Asm->OutStreamer->AddComment("Address Size (in bytes)");
1520   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1521 }
1522
1523 void DwarfUnit::initSection(MCSection *Section) {
1524   assert(!this->Section);
1525   this->Section = Section;
1526 }
1527
1528 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1529   DwarfUnit::emitHeader(UseOffsets);
1530   Asm->OutStreamer->AddComment("Type Signature");
1531   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1532   Asm->OutStreamer->AddComment("Type DIE Offset");
1533   // In a skeleton type unit there is no type DIE so emit a zero offset.
1534   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1535                                  sizeof(Ty->getOffset()));
1536 }
1537
1538 bool DwarfTypeUnit::isDwoUnit() const {
1539   // Since there are no skeleton type units, all type units are dwo type units
1540   // when split DWARF is being used.
1541   return DD->useSplitDwarf();
1542 }