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<DICompositeTypeBase>(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 (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
 808     const DIScope *Ctx = *I;
 809     StringRef Name = Ctx->getName();
 810     if (Name.empty() && isa<DINamespace>(Ctx))
 811       Name = "(anonymous namespace)";
 812     if (!Name.empty()) {
 813       CS += Name;
 814       CS += "::";
 815     }
 816   }
 817   return CS;
 818 }
 819
 820 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
 821   // Get core information.
 822   StringRef Name = BTy->getName();
 823   // Add name if not anonymous or intermediate type.
 824   if (!Name.empty())
 825     addString(Buffer, dwarf::DW_AT_name, Name);
 826
 827   // An unspecified type only has a name attribute.
 828   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
 829     return;
 830
 831   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 832           BTy->getEncoding());
 833
 834   uint64_t Size = BTy->getSizeInBits() >> 3;
 835   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 836 }
 837
 838 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
 839   // Get core information.
 840   StringRef Name = DTy->getName();
 841   uint64_t Size = DTy->getSizeInBits() >> 3;
 842   uint16_t Tag = Buffer.getTag();
 843
 844   // Map to main type, void will not have a type.
 845   const DIType *FromTy = resolve(DTy->getBaseType());
 846   if (FromTy)
 847     addType(Buffer, FromTy);
 848
 849   // Add name if not anonymous or intermediate type.
 850   if (!Name.empty())
 851     addString(Buffer, dwarf::DW_AT_name, Name);
 852
 853   // Add size if non-zero (derived types might be zero-sized.)
 854   if (Size && Tag != dwarf::DW_TAG_pointer_type
 855            && Tag != dwarf::DW_TAG_ptr_to_member_type)
 856     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 857
 858   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 859     addDIEEntry(
 860         Buffer, dwarf::DW_AT_containing_type,
 861         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
 862   // Add source line info if available and TyDesc is not a forward declaration.
 863   if (!DTy->isForwardDecl())
 864     addSourceLine(Buffer, DTy);
 865 }
 866
 867 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
 868   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 869     const DIType *Ty = resolve(Args[i]);
 870     if (!Ty) {
 871       assert(i == N-1 && "Unspecified parameter must be the last argument");
 872       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 873     } else {
 874       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 875       addType(Arg, Ty);
 876       if (Ty->isArtificial())
 877         addFlag(Arg, dwarf::DW_AT_artificial);
 878     }
 879   }
 880 }
 881
 882 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 883   // Add return type.  A void return won't have a type.
 884   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
 885   if (Elements.size())
 886     if (auto RTy = resolve(Elements[0]))
 887       addType(Buffer, RTy);
 888
 889   bool isPrototyped = true;
 890   if (Elements.size() == 2 && !Elements[1])
 891     isPrototyped = false;
 892
 893   constructSubprogramArguments(Buffer, Elements);
 894
 895   // Add prototype flag if we're dealing with a C language and the function has
 896   // been prototyped.
 897   uint16_t Language = getLanguage();
 898   if (isPrototyped &&
 899       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
 900        Language == dwarf::DW_LANG_ObjC))
 901     addFlag(Buffer, dwarf::DW_AT_prototyped);
 902
 903   if (CTy->isLValueReference())
 904     addFlag(Buffer, dwarf::DW_AT_reference);
 905
 906   if (CTy->isRValueReference())
 907     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 908 }
 909
 910 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
 911   if (CTy->isExternalTypeRef()) {
 912     StringRef Identifier = CTy->getIdentifier();
 913     assert(!Identifier.empty() && "external type ref without identifier");
 914     addFlag(Buffer, dwarf::DW_AT_declaration);
 915     return addDIETypeSignature(Buffer, dwarf::DW_AT_signature, Identifier);
 916   }
 917
 918   // Add name if not anonymous or intermediate type.
 919   StringRef Name = CTy->getName();
 920
 921   uint64_t Size = CTy->getSizeInBits() >> 3;
 922   uint16_t Tag = Buffer.getTag();
 923
 924   switch (Tag) {
 925   case dwarf::DW_TAG_array_type:
 926     constructArrayTypeDIE(Buffer, CTy);
 927     break;
 928   case dwarf::DW_TAG_enumeration_type:
 929     constructEnumTypeDIE(Buffer, CTy);
 930     break;
 931   case dwarf::DW_TAG_structure_type:
 932   case dwarf::DW_TAG_union_type:
 933   case dwarf::DW_TAG_class_type: {
 934     // Add elements to structure type.
 935     DINodeArray Elements = CTy->getElements();
 936     for (const auto *Element : Elements) {
 937       if (!Element)
 938         continue;
 939       if (auto *SP = dyn_cast<DISubprogram>(Element))
 940         getOrCreateSubprogramDIE(SP);
 941       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
 942         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
 943           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
 944           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
 945         } else if (DDTy->isStaticMember()) {
 946           getOrCreateStaticMemberDIE(DDTy);
 947         } else {
 948           constructMemberDIE(Buffer, DDTy);
 949         }
 950       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
 951         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
 952         StringRef PropertyName = Property->getName();
 953         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 954         if (Property->getType())
 955           addType(ElemDie, resolve(Property->getType()));
 956         addSourceLine(ElemDie, Property);
 957         StringRef GetterName = Property->getGetterName();
 958         if (!GetterName.empty())
 959           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 960         StringRef SetterName = Property->getSetterName();
 961         if (!SetterName.empty())
 962           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 963         if (unsigned PropertyAttributes = Property->getAttributes())
 964           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
 965                   PropertyAttributes);
 966       }
 967     }
 968
 969     if (CTy->isAppleBlockExtension())
 970       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 971
 972     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
 973     // inside C++ composite types to point to the base class with the vtable.
 974     if (auto *ContainingType =
 975             dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
 976       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 977                   *getOrCreateTypeDIE(ContainingType));
 978
 979     if (CTy->isObjcClassComplete())
 980       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 981
 982     // Add template parameters to a class, structure or union types.
 983     // FIXME: The support isn't in the metadata for this yet.
 984     if (Tag == dwarf::DW_TAG_class_type ||
 985         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 986       addTemplateParams(Buffer, CTy->getTemplateParams());
 987
 988     break;
 989   }
 990   default:
 991     break;
 992   }
 993
 994   // Add name if not anonymous or intermediate type.
 995   if (!Name.empty())
 996     addString(Buffer, dwarf::DW_AT_name, Name);
 997
 998   if (Tag == dwarf::DW_TAG_enumeration_type ||
 999       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1000       Tag == dwarf::DW_TAG_union_type) {
1001     // Add size if non-zero (derived types might be zero-sized.)
1002     // TODO: Do we care about size for enum forward declarations?
1003     if (Size)
1004       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1005     else if (!CTy->isForwardDecl())
1006       // Add zero size if it is not a forward declaration.
1007       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1008
1009     // If we're a forward decl, say so.
1010     if (CTy->isForwardDecl())
1011       addFlag(Buffer, dwarf::DW_AT_declaration);
1012
1013     // Add source line info if available.
1014     if (!CTy->isForwardDecl())
1015       addSourceLine(Buffer, CTy);
1016
1017     // No harm in adding the runtime language to the declaration.
1018     unsigned RLang = CTy->getRuntimeLang();
1019     if (RLang)
1020       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1021               RLang);
1022   }
1023 }
1024
1025 void DwarfUnit::constructTemplateTypeParameterDIE(
1026     DIE &Buffer, const DITemplateTypeParameter *TP) {
1027   DIE &ParamDIE =
1028       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1029   // Add the type if it exists, it could be void and therefore no type.
1030   if (TP->getType())
1031     addType(ParamDIE, resolve(TP->getType()));
1032   if (!TP->getName().empty())
1033     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1034 }
1035
1036 void DwarfUnit::constructTemplateValueParameterDIE(
1037     DIE &Buffer, const DITemplateValueParameter *VP) {
1038   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1039
1040   // Add the type if there is one, template template and template parameter
1041   // packs will not have a type.
1042   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1043     addType(ParamDIE, resolve(VP->getType()));
1044   if (!VP->getName().empty())
1045     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1046   if (Metadata *Val = VP->getValue()) {
1047     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1048       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1049     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1050       // For declaration non-type template parameters (such as global values and
1051       // functions)
1052       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1053       addOpAddress(*Loc, Asm->getSymbol(GV));
1054       // Emit DW_OP_stack_value to use the address as the immediate value of the
1055       // parameter, rather than a pointer to it.
1056       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1057       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1058     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1059       assert(isa<MDString>(Val));
1060       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1061                 cast<MDString>(Val)->getString());
1062     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1063       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1064     }
1065   }
1066 }
1067
1068 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1069   // Construct the context before querying for the existence of the DIE in case
1070   // such construction creates the DIE.
1071   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1072
1073   if (DIE *NDie = getDIE(NS))
1074     return NDie;
1075   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1076
1077   StringRef Name = NS->getName();
1078   if (!Name.empty())
1079     addString(NDie, dwarf::DW_AT_name, NS->getName());
1080   else
1081     Name = "(anonymous namespace)";
1082   DD->addAccelNamespace(Name, NDie);
1083   addGlobalName(Name, NDie, NS->getScope());
1084   addSourceLine(NDie, NS);
1085   return &NDie;
1086 }
1087
1088 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1089   // Construct the context before querying for the existence of the DIE in case
1090   // such construction creates the DIE.
1091   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1092
1093   if (DIE *MDie = getDIE(M))
1094     return MDie;
1095   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1096
1097   if (!M->getName().empty()) {
1098     addString(MDie, dwarf::DW_AT_name, M->getName());
1099     addGlobalName(M->getName(), MDie, M->getScope());
1100   }
1101   if (!M->getConfigurationMacros().empty())
1102     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1103               M->getConfigurationMacros());
1104   if (!M->getIncludePath().empty())
1105     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1106   if (!M->getISysRoot().empty())
1107     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1108
1109   return &MDie;
1110 }
1111
1112 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1113   // Construct the context before querying for the existence of the DIE in case
1114   // such construction creates the DIE (as is the case for member function
1115   // declarations).
1116   DIE *ContextDIE =
1117       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1118
1119   if (DIE *SPDie = getDIE(SP))
1120     return SPDie;
1121
1122   if (auto *SPDecl = SP->getDeclaration()) {
1123     if (!Minimal) {
1124       // Add subprogram definitions to the CU die directly.
1125       ContextDIE = &getUnitDie();
1126       // Build the decl now to ensure it precedes the definition.
1127       getOrCreateSubprogramDIE(SPDecl);
1128     }
1129   }
1130
1131   // DW_TAG_inlined_subroutine may refer to this DIE.
1132   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1133
1134   // Stop here and fill this in later, depending on whether or not this
1135   // subprogram turns out to have inlined instances or not.
1136   if (SP->isDefinition())
1137     return &SPDie;
1138
1139   applySubprogramAttributes(SP, SPDie);
1140   return &SPDie;
1141 }
1142
1143 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1144                                                     DIE &SPDie) {
1145   DIE *DeclDie = nullptr;
1146   StringRef DeclLinkageName;
1147   if (auto *SPDecl = SP->getDeclaration()) {
1148     DeclDie = getDIE(SPDecl);
1149     assert(DeclDie && "This DIE should've already been constructed when the "
1150                       "definition DIE was created in "
1151                       "getOrCreateSubprogramDIE");
1152     DeclLinkageName = SPDecl->getLinkageName();
1153   }
1154
1155   // Add function template parameters.
1156   addTemplateParams(SPDie, SP->getTemplateParams());
1157
1158   // Add the linkage name if we have one and it isn't in the Decl.
1159   StringRef LinkageName = SP->getLinkageName();
1160   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1161           LinkageName == DeclLinkageName) &&
1162          "decl has a linkage name and it is different");
1163   if (DeclLinkageName.empty())
1164     addLinkageName(SPDie, LinkageName);
1165
1166   if (!DeclDie)
1167     return false;
1168
1169   // Refer to the function declaration where all the other attributes will be
1170   // found.
1171   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1172   return true;
1173 }
1174
1175 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1176                                           bool Minimal) {
1177   if (!Minimal)
1178     if (applySubprogramDefinitionAttributes(SP, SPDie))
1179       return;
1180
1181   // Constructors and operators for anonymous aggregates do not have names.
1182   if (!SP->getName().empty())
1183     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1184
1185   // Skip the rest of the attributes under -gmlt to save space.
1186   if (Minimal)
1187     return;
1188
1189   addSourceLine(SPDie, SP);
1190
1191   // Add the prototype if we have a prototype and we have a C like
1192   // language.
1193   uint16_t Language = getLanguage();
1194   if (SP->isPrototyped() &&
1195       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1196        Language == dwarf::DW_LANG_ObjC))
1197     addFlag(SPDie, dwarf::DW_AT_prototyped);
1198
1199   const DISubroutineType *SPTy = SP->getType();
1200   assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1201          "the type of a subprogram should be a subroutine");
1202
1203   auto Args = SPTy->getTypeArray();
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 }