lib/CodeGen/AsmPrinter/DwarfUnit.cpp

   1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for constructing a dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "DwarfUnit.h"
  15 #include "DwarfAccelTable.h"
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfDebug.h"
  18 #include "DwarfExpression.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DIBuilder.h"
  23 #include "llvm/IR/DataLayout.h"
  24 #include "llvm/IR/GlobalVariable.h"
  25 #include "llvm/IR/Instructions.h"
  26 #include "llvm/IR/Mangler.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/MC/MCContext.h"
  29 #include "llvm/MC/MCSection.h"
  30 #include "llvm/MC/MCStreamer.h"
  31 #include "llvm/Support/CommandLine.h"
  32 #include "llvm/Target/TargetFrameLowering.h"
  33 #include "llvm/Target/TargetLoweringObjectFile.h"
  34 #include "llvm/Target/TargetMachine.h"
  35 #include "llvm/Target/TargetRegisterInfo.h"
  36 #include "llvm/Target/TargetSubtargetInfo.h"
  37
  38 using namespace llvm;
  39
  40 #define DEBUG_TYPE "dwarfdebug"
  41
  42 static cl::opt<bool>
  43 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  44                        cl::desc("Generate DWARF4 type units."),
  45                        cl::init(false));
  46
  47 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
  48                                        DIELoc &DIE)
  49     : DwarfExpression(*AP.MF->getSubtarget().getRegisterInfo(),
  50                       AP.getDwarfDebug()->getDwarfVersion()),
  51       AP(AP), DU(DU), DIE(DIE) {}
  52
  53 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
  54   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
  55 }
  56 void DIEDwarfExpression::EmitSigned(int64_t Value) {
  57   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
  58 }
  59 void DIEDwarfExpression::EmitUnsigned(uint64_t Value) {
  60   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
  61 }
  62 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
  63   return MachineReg == TRI.getFrameRegister(*AP.MF);
  64 }
  65
  66 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag,
  67                      const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
  68                      DwarfFile *DWU)
  69     : UniqueID(UID), CUNode(Node),
  70       UnitDie(*DIE::get(DIEValueAllocator, UnitTag)), DebugInfoOffset(0),
  71       Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  72   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  73          UnitTag == dwarf::DW_TAG_type_unit);
  74 }
  75
  76 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
  77                              DwarfDebug *DW, DwarfFile *DWU,
  78                              MCDwarfDwoLineTable *SplitLineTable)
  79     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
  80       CU(CU), SplitLineTable(SplitLineTable) {
  81   if (SplitLineTable)
  82     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  83 }
  84
  85 DwarfUnit::~DwarfUnit() {
  86   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  87     DIEBlocks[j]->~DIEBlock();
  88   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  89     DIELocs[j]->~DIELoc();
  90 }
  91
  92 int64_t DwarfUnit::getDefaultLowerBound() const {
  93   switch (getLanguage()) {
  94   default:
  95     break;
  96
  97   case dwarf::DW_LANG_C89:
  98   case dwarf::DW_LANG_C99:
  99   case dwarf::DW_LANG_C:
 100   case dwarf::DW_LANG_C_plus_plus:
 101   case dwarf::DW_LANG_ObjC:
 102   case dwarf::DW_LANG_ObjC_plus_plus:
 103     return 0;
 104
 105   case dwarf::DW_LANG_Fortran77:
 106   case dwarf::DW_LANG_Fortran90:
 107   case dwarf::DW_LANG_Fortran95:
 108     return 1;
 109
 110   // The languages below have valid values only if the DWARF version >= 4.
 111   case dwarf::DW_LANG_Java:
 112   case dwarf::DW_LANG_Python:
 113   case dwarf::DW_LANG_UPC:
 114   case dwarf::DW_LANG_D:
 115     if (dwarf::DWARF_VERSION >= 4)
 116       return 0;
 117     break;
 118
 119   case dwarf::DW_LANG_Ada83:
 120   case dwarf::DW_LANG_Ada95:
 121   case dwarf::DW_LANG_Cobol74:
 122   case dwarf::DW_LANG_Cobol85:
 123   case dwarf::DW_LANG_Modula2:
 124   case dwarf::DW_LANG_Pascal83:
 125   case dwarf::DW_LANG_PLI:
 126     if (dwarf::DWARF_VERSION >= 4)
 127       return 1;
 128     break;
 129
 130   // The languages below have valid values only if the DWARF version >= 5.
 131   case dwarf::DW_LANG_OpenCL:
 132   case dwarf::DW_LANG_Go:
 133   case dwarf::DW_LANG_Haskell:
 134   case dwarf::DW_LANG_C_plus_plus_03:
 135   case dwarf::DW_LANG_C_plus_plus_11:
 136   case dwarf::DW_LANG_OCaml:
 137   case dwarf::DW_LANG_Rust:
 138   case dwarf::DW_LANG_C11:
 139   case dwarf::DW_LANG_Swift:
 140   case dwarf::DW_LANG_Dylan:
 141   case dwarf::DW_LANG_C_plus_plus_14:
 142     if (dwarf::DWARF_VERSION >= 5)
 143       return 0;
 144     break;
 145
 146   case dwarf::DW_LANG_Modula3:
 147   case dwarf::DW_LANG_Julia:
 148   case dwarf::DW_LANG_Fortran03:
 149   case dwarf::DW_LANG_Fortran08:
 150     if (dwarf::DWARF_VERSION >= 5)
 151       return 1;
 152     break;
 153   }
 154
 155   return -1;
 156 }
 157
 158 /// Check whether the DIE for this MDNode can be shared across CUs.
 159 static bool isShareableAcrossCUs(const DINode *D) {
 160   // When the MDNode can be part of the type system, the DIE can be shared
 161   // across CUs.
 162   // Combining type units and cross-CU DIE sharing is lower value (since
 163   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 164   // level already) but may be implementable for some value in projects
 165   // building multiple independent libraries with LTO and then linking those
 166   // together.
 167   return (isa<DIType>(D) ||
 168           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
 169          !GenerateDwarfTypeUnits;
 170 }
 171
 172 DIE *DwarfUnit::getDIE(const DINode *D) const {
 173   if (isShareableAcrossCUs(D))
 174     return DU->getDIE(D);
 175   return MDNodeToDieMap.lookup(D);
 176 }
 177
 178 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
 179   if (isShareableAcrossCUs(Desc)) {
 180     DU->insertDIE(Desc, D);
 181     return;
 182   }
 183   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 184 }
 185
 186 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 187   if (DD->getDwarfVersion() >= 4)
 188     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
 189                  DIEInteger(1));
 190   else
 191     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
 192                  DIEInteger(1));
 193 }
 194
 195 void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
 196                         Optional<dwarf::Form> Form, uint64_t Integer) {
 197   if (!Form)
 198     Form = DIEInteger::BestForm(false, Integer);
 199   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 200 }
 201
 202 void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
 203                         uint64_t Integer) {
 204   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 205 }
 206
 207 void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
 208                         Optional<dwarf::Form> Form, int64_t Integer) {
 209   if (!Form)
 210     Form = DIEInteger::BestForm(true, Integer);
 211   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 212 }
 213
 214 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 215                         int64_t Integer) {
 216   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 217 }
 218
 219 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 220                           StringRef String) {
 221   Die.addValue(DIEValueAllocator, Attribute,
 222                isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
 223                DIEString(DU->getStringPool().getEntry(*Asm, String)));
 224 }
 225
 226 DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
 227                                                  dwarf::Attribute Attribute,
 228                                                  dwarf::Form Form,
 229                                                  const MCSymbol *Label) {
 230   return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
 231 }
 232
 233 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 234   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 235 }
 236
 237 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 238                                  uint64_t Integer) {
 239   if (DD->getDwarfVersion() >= 4)
 240     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 241   else
 242     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 243 }
 244
 245 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
 246   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
 247                         : getCU().getOrCreateSourceID(FileName, DirName);
 248 }
 249
 250 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 251   if (!DD->useSplitDwarf()) {
 252     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 253     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 254   } else {
 255     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 256     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 257             DD->getAddressPool().getIndex(Sym));
 258   }
 259 }
 260
 261 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 262                               const MCSymbol *Hi, const MCSymbol *Lo) {
 263   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
 264                new (DIEValueAllocator) DIEDelta(Hi, Lo));
 265 }
 266
 267 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 268   addDIEEntry(Die, Attribute, DIEEntry(Entry));
 269 }
 270
 271 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
 272   // Flag the type unit reference as a declaration so that if it contains
 273   // members (implicit special members, static data member definitions, member
 274   // declarations for definitions in this CU, etc) consumers don't get confused
 275   // and think this is a full definition.
 276   addFlag(Die, dwarf::DW_AT_declaration);
 277
 278   Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
 279                dwarf::DW_FORM_ref_sig8, DIETypeSignature(Type));
 280 }
 281
 282 void DwarfUnit::addDIETypeSignature(DIE &Die, dwarf::Attribute Attribute,
 283                                     StringRef Identifier) {
 284   uint64_t Signature = DD->makeTypeSignature(Identifier);
 285   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_ref_sig8,
 286                DIEInteger(Signature));
 287 }
 288
 289 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 290                             DIEEntry Entry) {
 291   const DIE *DieCU = Die.getUnitOrNull();
 292   const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
 293   if (!DieCU)
 294     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 295     DieCU = &getUnitDie();
 296   if (!EntryCU)
 297     EntryCU = &getUnitDie();
 298   Die.addValue(DIEValueAllocator, Attribute,
 299                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 300                Entry);
 301 }
 302
 303 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
 304   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
 305   if (N)
 306     insertDIE(N, &Die);
 307   return Die;
 308 }
 309
 310 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 311   Loc->ComputeSize(Asm);
 312   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 313   Die.addValue(DIEValueAllocator, Attribute,
 314                Loc->BestForm(DD->getDwarfVersion()), Loc);
 315 }
 316
 317 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 318                          DIEBlock *Block) {
 319   Block->ComputeSize(Asm);
 320   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 321   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
 322 }
 323
 324 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
 325                               StringRef Directory) {
 326   if (Line == 0)
 327     return;
 328
 329   unsigned FileID = getOrCreateSourceID(File, Directory);
 330   assert(FileID && "Invalid file id");
 331   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 332   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 333 }
 334
 335 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
 336   assert(V);
 337
 338   addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
 339                 V->getScope()->getDirectory());
 340 }
 341
 342 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
 343   assert(G);
 344
 345   addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
 346 }
 347
 348 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
 349   assert(SP);
 350
 351   addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
 352 }
 353
 354 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
 355   assert(Ty);
 356
 357   addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
 358 }
 359
 360 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
 361   assert(Ty);
 362
 363   addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
 364 }
 365
 366 void DwarfUnit::addSourceLine(DIE &Die, const DINamespace *NS) {
 367   addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
 368 }
 369
 370 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
 371                                    unsigned SizeInBits, unsigned OffsetInBits) {
 372   DIEDwarfExpression Expr(*Asm, *this, TheDie);
 373   Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
 374   return true;
 375 }
 376
 377 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
 378                                   int64_t Offset) {
 379   DIEDwarfExpression Expr(*Asm, *this, TheDie);
 380   return Expr.AddMachineRegIndirect(Reg, Offset);
 381 }
 382
 383 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 384    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 385    gives the variable VarName either the struct, or a pointer to the struct, as
 386    its type.  This is necessary for various behind-the-scenes things the
 387    compiler needs to do with by-reference variables in Blocks.
 388
 389    However, as far as the original *programmer* is concerned, the variable
 390    should still have type 'SomeType', as originally declared.
 391
 392    The function getBlockByrefType dives into the __Block_byref_x_VarName
 393    struct to find the original type of the variable, which is then assigned to
 394    the variable's Debug Information Entry as its real type.  So far, so good.
 395    However now the debugger will expect the variable VarName to have the type
 396    SomeType.  So we need the location attribute for the variable to be an
 397    expression that explains to the debugger how to navigate through the
 398    pointers and struct to find the actual variable of type SomeType.
 399
 400    The following function does just that.  We start by getting
 401    the "normal" location for the variable. This will be the location
 402    of either the struct __Block_byref_x_VarName or the pointer to the
 403    struct __Block_byref_x_VarName.
 404
 405    The struct will look something like:
 406
 407    struct __Block_byref_x_VarName {
 408      ... <various fields>
 409      struct __Block_byref_x_VarName *forwarding;
 410      ... <various other fields>
 411      SomeType VarName;
 412      ... <maybe more fields>
 413    };
 414
 415    If we are given the struct directly (as our starting point) we
 416    need to tell the debugger to:
 417
 418    1).  Add the offset of the forwarding field.
 419
 420    2).  Follow that pointer to get the real __Block_byref_x_VarName
 421    struct to use (the real one may have been copied onto the heap).
 422
 423    3).  Add the offset for the field VarName, to find the actual variable.
 424
 425    If we started with a pointer to the struct, then we need to
 426    dereference that pointer first, before the other steps.
 427    Translating this into DWARF ops, we will need to append the following
 428    to the current location description for the variable:
 429
 430    DW_OP_deref                    -- optional, if we start with a pointer
 431    DW_OP_plus_uconst <forward_fld_offset>
 432    DW_OP_deref
 433    DW_OP_plus_uconst <varName_fld_offset>
 434
 435    That is what this function does.  */
 436
 437 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
 438                                      dwarf::Attribute Attribute,
 439                                      const MachineLocation &Location) {
 440   const DIType *Ty = DV.getType();
 441   const DIType *TmpTy = Ty;
 442   uint16_t Tag = Ty->getTag();
 443   bool isPointer = false;
 444
 445   StringRef varName = DV.getName();
 446
 447   if (Tag == dwarf::DW_TAG_pointer_type) {
 448     auto *DTy = cast<DIDerivedType>(Ty);
 449     TmpTy = resolve(DTy->getBaseType());
 450     isPointer = true;
 451   }
 452
 453   // Find the __forwarding field and the variable field in the __Block_byref
 454   // struct.
 455   DINodeArray Fields = cast<DICompositeType>(TmpTy)->getElements();
 456   const DIDerivedType *varField = nullptr;
 457   const DIDerivedType *forwardingField = nullptr;
 458
 459   for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
 460     auto *DT = cast<DIDerivedType>(Fields[i]);
 461     StringRef fieldName = DT->getName();
 462     if (fieldName == "__forwarding")
 463       forwardingField = DT;
 464     else if (fieldName == varName)
 465       varField = DT;
 466   }
 467
 468   // Get the offsets for the forwarding field and the variable field.
 469   unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
 470   unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
 471
 472   // Decode the original location, and use that as the start of the byref
 473   // variable's location.
 474   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
 475
 476   bool validReg;
 477   if (Location.isReg())
 478     validReg = addRegisterOpPiece(*Loc, Location.getReg());
 479   else
 480     validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 481
 482   if (!validReg)
 483     return;
 484
 485   // If we started with a pointer to the __Block_byref... struct, then
 486   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 487   if (isPointer)
 488     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 489
 490   // Next add the offset for the '__forwarding' field:
 491   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 492   // adding the offset if it's 0.
 493   if (forwardingFieldOffset > 0) {
 494     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 495     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
 496   }
 497
 498   // Now dereference the __forwarding field to get to the real __Block_byref
 499   // struct:  DW_OP_deref.
 500   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 501
 502   // Now that we've got the real __Block_byref... struct, add the offset
 503   // for the variable's field to get to the location of the actual variable:
 504   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 505   if (varFieldOffset > 0) {
 506     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 507     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
 508   }
 509
 510   // Now attach the location information to the DIE.
 511   addBlock(Die, Attribute, Loc);
 512 }
 513
 514 /// Return true if type encoding is unsigned.
 515 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
 516   if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 517     // FIXME: Enums without a fixed underlying type have unknown signedness
 518     // here, leading to incorrectly emitted constants.
 519     if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
 520       return false;
 521
 522     // (Pieces of) aggregate types that get hacked apart by SROA may be
 523     // represented by a constant. Encode them as unsigned bytes.
 524     return true;
 525   }
 526
 527   if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
 528     dwarf::Tag T = (dwarf::Tag)Ty->getTag();
 529     // Encode pointer constants as unsigned bytes. This is used at least for
 530     // null pointer constant emission.
 531     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
 532     // here, but accept them for now due to a bug in SROA producing bogus
 533     // dbg.values.
 534     if (T == dwarf::DW_TAG_pointer_type ||
 535         T == dwarf::DW_TAG_ptr_to_member_type ||
 536         T == dwarf::DW_TAG_reference_type ||
 537         T == dwarf::DW_TAG_rvalue_reference_type)
 538       return true;
 539     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 540            T == dwarf::DW_TAG_volatile_type ||
 541            T == dwarf::DW_TAG_restrict_type);
 542     DITypeRef Deriv = DTy->getBaseType();
 543     assert(Deriv && "Expected valid base type");
 544     return isUnsignedDIType(DD, DD->resolve(Deriv));
 545   }
 546
 547   auto *BTy = cast<DIBasicType>(Ty);
 548   unsigned Encoding = BTy->getEncoding();
 549   assert((Encoding == dwarf::DW_ATE_unsigned ||
 550           Encoding == dwarf::DW_ATE_unsigned_char ||
 551           Encoding == dwarf::DW_ATE_signed ||
 552           Encoding == dwarf::DW_ATE_signed_char ||
 553           Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
 554           Encoding == dwarf::DW_ATE_boolean ||
 555           (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
 556            Ty->getName() == "decltype(nullptr)")) &&
 557          "Unsupported encoding");
 558   return Encoding == dwarf::DW_ATE_unsigned ||
 559          Encoding == dwarf::DW_ATE_unsigned_char ||
 560          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 561          Ty->getTag() == dwarf::DW_TAG_unspecified_type;
 562 }
 563
 564 /// If this type is derived from a base type then return base type size.
 565 static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
 566   unsigned Tag = Ty->getTag();
 567
 568   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 569       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 570       Tag != dwarf::DW_TAG_restrict_type)
 571     return Ty->getSizeInBits();
 572
 573   auto *BaseType = DD->resolve(Ty->getBaseType());
 574
 575   assert(BaseType && "Unexpected invalid base type");
 576
 577   // If this is a derived type, go ahead and get the base type, unless it's a
 578   // reference then it's just the size of the field. Pointer types have no need
 579   // of this since they're a different type of qualification on the type.
 580   if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
 581       BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
 582     return Ty->getSizeInBits();
 583
 584   if (auto *DT = dyn_cast<DIDerivedType>(BaseType))
 585     return getBaseTypeSize(DD, DT);
 586
 587   return BaseType->getSizeInBits();
 588 }
 589
 590 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 591   assert(MO.isFPImm() && "Invalid machine operand!");
 592   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 593   APFloat FPImm = MO.getFPImm()->getValueAPF();
 594
 595   // Get the raw data form of the floating point.
 596   const APInt FltVal = FPImm.bitcastToAPInt();
 597   const char *FltPtr = (const char *)FltVal.getRawData();
 598
 599   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 600   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 601   int Incr = (LittleEndian ? 1 : -1);
 602   int Start = (LittleEndian ? 0 : NumBytes - 1);
 603   int Stop = (LittleEndian ? NumBytes : -1);
 604
 605   // Output the constant to DWARF one byte at a time.
 606   for (; Start != Stop; Start += Incr)
 607     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 608
 609   addBlock(Die, dwarf::DW_AT_const_value, Block);
 610 }
 611
 612 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 613   // Pass this down to addConstantValue as an unsigned bag of bits.
 614   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 615 }
 616
 617 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 618                                  const DIType *Ty) {
 619   addConstantValue(Die, CI->getValue(), Ty);
 620 }
 621
 622 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 623                                  const DIType *Ty) {
 624   assert(MO.isImm() && "Invalid machine operand!");
 625
 626   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 627 }
 628
 629 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 630   // FIXME: This is a bit conservative/simple - it emits negative values always
 631   // sign extended to 64 bits rather than minimizing the number of bytes.
 632   addUInt(Die, dwarf::DW_AT_const_value,
 633           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 634 }
 635
 636 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
 637   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 638 }
 639
 640 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 641   unsigned CIBitWidth = Val.getBitWidth();
 642   if (CIBitWidth <= 64) {
 643     addConstantValue(Die, Unsigned,
 644                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 645     return;
 646   }
 647
 648   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 649
 650   // Get the raw data form of the large APInt.
 651   const uint64_t *Ptr64 = Val.getRawData();
 652
 653   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 654   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 655
 656   // Output the constant to DWARF one byte at a time.
 657   for (int i = 0; i < NumBytes; i++) {
 658     uint8_t c;
 659     if (LittleEndian)
 660       c = Ptr64[i / 8] >> (8 * (i & 7));
 661     else
 662       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 663     addUInt(*Block, dwarf::DW_FORM_data1, c);
 664   }
 665
 666   addBlock(Die, dwarf::DW_AT_const_value, Block);
 667 }
 668
 669 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
 670   if (!LinkageName.empty() && DD->useLinkageNames())
 671     addString(Die,
 672               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
 673                                          : dwarf::DW_AT_MIPS_linkage_name,
 674               GlobalValue::getRealLinkageName(LinkageName));
 675 }
 676
 677 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
 678   // Add template parameters.
 679   for (const auto *Element : TParams) {
 680     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
 681       constructTemplateTypeParameterDIE(Buffer, TTP);
 682     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
 683       constructTemplateValueParameterDIE(Buffer, TVP);
 684   }
 685 }
 686
 687 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
 688   if (!Context || isa<DIFile>(Context))
 689     return &getUnitDie();
 690   if (auto *T = dyn_cast<DIType>(Context))
 691     return getOrCreateTypeDIE(T);
 692   if (auto *NS = dyn_cast<DINamespace>(Context))
 693     return getOrCreateNameSpace(NS);
 694   if (auto *SP = dyn_cast<DISubprogram>(Context))
 695     return getOrCreateSubprogramDIE(SP);
 696   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   DITypeRefArray Args;
1199   if (const DISubroutineType *SPTy = SP->getType())
1200     Args = SPTy->getTypeArray();
1201
1202   // Add a return type. If this is a type like a C/C++ void type we don't add a
1203   // return type.
1204   if (Args.size())
1205     if (auto Ty = resolve(Args[0]))
1206       addType(SPDie, Ty);
1207
1208   unsigned VK = SP->getVirtuality();
1209   if (VK) {
1210     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1211     DIELoc *Block = getDIELoc();
1212     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1213     addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1214     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1215     ContainingTypeMap.insert(
1216         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1217   }
1218
1219   if (!SP->isDefinition()) {
1220     addFlag(SPDie, dwarf::DW_AT_declaration);
1221
1222     // Add arguments. Do not add arguments for subprogram definition. They will
1223     // be handled while processing variables.
1224     constructSubprogramArguments(SPDie, Args);
1225   }
1226
1227   if (SP->isArtificial())
1228     addFlag(SPDie, dwarf::DW_AT_artificial);
1229
1230   if (!SP->isLocalToUnit())
1231     addFlag(SPDie, dwarf::DW_AT_external);
1232
1233   if (SP->isOptimized())
1234     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1235
1236   if (unsigned isa = Asm->getISAEncoding())
1237     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1238
1239   if (SP->isLValueReference())
1240     addFlag(SPDie, dwarf::DW_AT_reference);
1241
1242   if (SP->isRValueReference())
1243     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1244
1245   if (SP->isProtected())
1246     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1247             dwarf::DW_ACCESS_protected);
1248   else if (SP->isPrivate())
1249     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1250             dwarf::DW_ACCESS_private);
1251   else if (SP->isPublic())
1252     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1253             dwarf::DW_ACCESS_public);
1254
1255   if (SP->isExplicit())
1256     addFlag(SPDie, dwarf::DW_AT_explicit);
1257 }
1258
1259 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1260                                      DIE *IndexTy) {
1261   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1262   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1263
1264   // The LowerBound value defines the lower bounds which is typically zero for
1265   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1266   // Count == -1 then the array is unbounded and we do not emit
1267   // DW_AT_lower_bound and DW_AT_count attributes.
1268   int64_t LowerBound = SR->getLowerBound();
1269   int64_t DefaultLowerBound = getDefaultLowerBound();
1270   int64_t Count = SR->getCount();
1271
1272   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1273     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1274
1275   if (Count != -1)
1276     // FIXME: An unbounded array should reference the expression that defines
1277     // the array.
1278     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1279 }
1280
1281 DIE *DwarfUnit::getIndexTyDie() {
1282   if (IndexTyDie)
1283     return IndexTyDie;
1284   // Construct an integer type to use for indexes.
1285   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1286   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1287   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1288   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1289           dwarf::DW_ATE_unsigned);
1290   return IndexTyDie;
1291 }
1292
1293 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1294   if (CTy->isVector())
1295     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1296
1297   // Emit the element type.
1298   addType(Buffer, resolve(CTy->getBaseType()));
1299
1300   // Get an anonymous type for index type.
1301   // FIXME: This type should be passed down from the front end
1302   // as different languages may have different sizes for indexes.
1303   DIE *IdxTy = getIndexTyDie();
1304
1305   // Add subranges to array type.
1306   DINodeArray Elements = CTy->getElements();
1307   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1308     // FIXME: Should this really be such a loose cast?
1309     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1310       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1311         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1312   }
1313 }
1314
1315 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1316   DINodeArray Elements = CTy->getElements();
1317
1318   // Add enumerators to enumeration type.
1319   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1320     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1321     if (Enum) {
1322       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1323       StringRef Name = Enum->getName();
1324       addString(Enumerator, dwarf::DW_AT_name, Name);
1325       int64_t Value = Enum->getValue();
1326       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1327               Value);
1328     }
1329   }
1330   const DIType *DTy = resolve(CTy->getBaseType());
1331   if (DTy) {
1332     addType(Buffer, DTy);
1333     addFlag(Buffer, dwarf::DW_AT_enum_class);
1334   }
1335 }
1336
1337 void DwarfUnit::constructContainingTypeDIEs() {
1338   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1339        CI != CE; ++CI) {
1340     DIE &SPDie = *CI->first;
1341     const DINode *D = CI->second;
1342     if (!D)
1343       continue;
1344     DIE *NDie = getDIE(D);
1345     if (!NDie)
1346       continue;
1347     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1348   }
1349 }
1350
1351 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1352   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1353   StringRef Name = DT->getName();
1354   if (!Name.empty())
1355     addString(MemberDie, dwarf::DW_AT_name, Name);
1356
1357   addType(MemberDie, resolve(DT->getBaseType()));
1358
1359   addSourceLine(MemberDie, DT);
1360
1361   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1362
1363     // For C++, virtual base classes are not at fixed offset. Use following
1364     // expression to extract appropriate offset from vtable.
1365     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1366
1367     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1368     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1369     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1370     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1371     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1372     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1373     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1374     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1375
1376     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1377   } else {
1378     uint64_t Size = DT->getSizeInBits();
1379     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1380     uint64_t OffsetInBytes;
1381
1382     if (FieldSize && Size != FieldSize) {
1383       // Handle bitfield, assume bytes are 8 bits.
1384       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1385       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1386       //
1387       // The DWARF 2 DW_AT_bit_offset is counting the bits between the most
1388       // significant bit of the aligned storage unit containing the bit field to
1389       // the most significan bit of the bit field.
1390       //
1391       // FIXME: DWARF 4 states that DW_AT_data_bit_offset (which
1392       // counts from the beginning, regardless of endianness) should
1393       // be used instead.
1394       //
1395       //
1396       // Struct      Align       Align       Align
1397       // v           v           v           v
1398       // +-----------+-----*-----+-----*-----+--
1399       // | ...             |b1|b2|b3|b4|
1400       // +-----------+-----*-----+-----*-----+--
1401       // |           |     |<-- Size ->|     |
1402       // |<---- Offset --->|           |<--->|
1403       // |           |     |              \_ DW_AT_bit_offset (little endian)
1404       // |           |<--->|
1405       // |<--------->|  \_ StartBitOffset = DW_AT_bit_offset (big endian)
1406       //     \                            = DW_AT_data_bit_offset (biendian)
1407       //      \_ OffsetInBytes
1408       uint64_t Offset = DT->getOffsetInBits();
1409       uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1410       uint64_t AlignMask = ~(Align - 1);
1411       // The bits from the start of the storage unit to the start of the field.
1412       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1413       // The endian-dependent DWARF 2 offset.
1414       uint64_t DwarfBitOffset = Asm->getDataLayout().isLittleEndian()
1415         ? OffsetToAlignment(Offset + Size, Align)
1416         : StartBitOffset;
1417
1418       // The byte offset of the field's aligned storage unit inside the struct.
1419       OffsetInBytes = (Offset - StartBitOffset) / 8;
1420       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, DwarfBitOffset);
1421     } else
1422       // This is not a bitfield.
1423       OffsetInBytes = DT->getOffsetInBits() / 8;
1424
1425     if (DD->getDwarfVersion() <= 2) {
1426       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1427       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1428       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1429       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1430     } else
1431       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1432               OffsetInBytes);
1433   }
1434
1435   if (DT->isProtected())
1436     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1437             dwarf::DW_ACCESS_protected);
1438   else if (DT->isPrivate())
1439     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1440             dwarf::DW_ACCESS_private);
1441   // Otherwise C++ member and base classes are considered public.
1442   else if (DT->isPublic())
1443     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1444             dwarf::DW_ACCESS_public);
1445   if (DT->isVirtual())
1446     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1447             dwarf::DW_VIRTUALITY_virtual);
1448
1449   // Objective-C properties.
1450   if (DINode *PNode = DT->getObjCProperty())
1451     if (DIE *PDie = getDIE(PNode))
1452       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1453                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1454
1455   if (DT->isArtificial())
1456     addFlag(MemberDie, dwarf::DW_AT_artificial);
1457 }
1458
1459 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1460   if (!DT)
1461     return nullptr;
1462
1463   // Construct the context before querying for the existence of the DIE in case
1464   // such construction creates the DIE.
1465   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1466   assert(dwarf::isType(ContextDIE->getTag()) &&
1467          "Static member should belong to a type.");
1468
1469   if (DIE *StaticMemberDIE = getDIE(DT))
1470     return StaticMemberDIE;
1471
1472   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1473
1474   const DIType *Ty = resolve(DT->getBaseType());
1475
1476   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1477   addType(StaticMemberDIE, Ty);
1478   addSourceLine(StaticMemberDIE, DT);
1479   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1480   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1481
1482   // FIXME: We could omit private if the parent is a class_type, and
1483   // public if the parent is something else.
1484   if (DT->isProtected())
1485     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1486             dwarf::DW_ACCESS_protected);
1487   else if (DT->isPrivate())
1488     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1489             dwarf::DW_ACCESS_private);
1490   else if (DT->isPublic())
1491     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1492             dwarf::DW_ACCESS_public);
1493
1494   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1495     addConstantValue(StaticMemberDIE, CI, Ty);
1496   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1497     addConstantFPValue(StaticMemberDIE, CFP);
1498
1499   return &StaticMemberDIE;
1500 }
1501
1502 void DwarfUnit::emitHeader(bool UseOffsets) {
1503   // Emit size of content not including length itself
1504   Asm->OutStreamer->AddComment("Length of Unit");
1505   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1506
1507   Asm->OutStreamer->AddComment("DWARF version number");
1508   Asm->EmitInt16(DD->getDwarfVersion());
1509   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1510
1511   // We share one abbreviations table across all units so it's always at the
1512   // start of the section. Use a relocatable offset where needed to ensure
1513   // linking doesn't invalidate that offset.
1514   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1515   Asm->emitDwarfSymbolReference(TLOF.getDwarfAbbrevSection()->getBeginSymbol(),
1516                                 UseOffsets);
1517
1518   Asm->OutStreamer->AddComment("Address Size (in bytes)");
1519   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1520 }
1521
1522 void DwarfUnit::initSection(MCSection *Section) {
1523   assert(!this->Section);
1524   this->Section = Section;
1525 }
1526
1527 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1528   DwarfUnit::emitHeader(UseOffsets);
1529   Asm->OutStreamer->AddComment("Type Signature");
1530   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1531   Asm->OutStreamer->AddComment("Type DIE Offset");
1532   // In a skeleton type unit there is no type DIE so emit a zero offset.
1533   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1534                                  sizeof(Ty->getOffset()));
1535 }
1536
1537 bool DwarfTypeUnit::isDwoUnit() const {
1538   // Since there are no skeleton type units, all type units are dwo type units
1539   // when split DWARF is being used.
1540   return DD->useSplitDwarf();
1541 }