contrib/llvm/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.getDwarfDebug()->getDwarfVersion()), AP(AP), DU(DU),
  50       DIE(DIE) {}
  51
  52 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
  53   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
  54 }
  55 void DIEDwarfExpression::EmitSigned(int64_t Value) {
  56   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
  57 }
  58 void DIEDwarfExpression::EmitUnsigned(uint64_t Value) {
  59   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
  60 }
  61 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
  62                                          unsigned MachineReg) {
  63   return MachineReg == TRI.getFrameRegister(*AP.MF);
  64 }
  65
  66 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
  67                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
  68     : CUNode(Node), UnitDie(*DIE::get(DIEValueAllocator, UnitTag)), Asm(A),
  69       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  70   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  71          UnitTag == dwarf::DW_TAG_type_unit);
  72 }
  73
  74 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
  75                              DwarfDebug *DW, DwarfFile *DWU,
  76                              MCDwarfDwoLineTable *SplitLineTable)
  77     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
  78       SplitLineTable(SplitLineTable) {
  79   if (SplitLineTable)
  80     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  81 }
  82
  83 DwarfUnit::~DwarfUnit() {
  84   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  85     DIEBlocks[j]->~DIEBlock();
  86   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  87     DIELocs[j]->~DIELoc();
  88 }
  89
  90 int64_t DwarfUnit::getDefaultLowerBound() const {
  91   switch (getLanguage()) {
  92   default:
  93     break;
  94
  95   case dwarf::DW_LANG_C89:
  96   case dwarf::DW_LANG_C99:
  97   case dwarf::DW_LANG_C:
  98   case dwarf::DW_LANG_C_plus_plus:
  99   case dwarf::DW_LANG_ObjC:
 100   case dwarf::DW_LANG_ObjC_plus_plus:
 101     return 0;
 102
 103   case dwarf::DW_LANG_Fortran77:
 104   case dwarf::DW_LANG_Fortran90:
 105   case dwarf::DW_LANG_Fortran95:
 106     return 1;
 107
 108   // The languages below have valid values only if the DWARF version >= 4.
 109   case dwarf::DW_LANG_Java:
 110   case dwarf::DW_LANG_Python:
 111   case dwarf::DW_LANG_UPC:
 112   case dwarf::DW_LANG_D:
 113     if (dwarf::DWARF_VERSION >= 4)
 114       return 0;
 115     break;
 116
 117   case dwarf::DW_LANG_Ada83:
 118   case dwarf::DW_LANG_Ada95:
 119   case dwarf::DW_LANG_Cobol74:
 120   case dwarf::DW_LANG_Cobol85:
 121   case dwarf::DW_LANG_Modula2:
 122   case dwarf::DW_LANG_Pascal83:
 123   case dwarf::DW_LANG_PLI:
 124     if (dwarf::DWARF_VERSION >= 4)
 125       return 1;
 126     break;
 127
 128   // The languages below have valid values only if the DWARF version >= 5.
 129   case dwarf::DW_LANG_OpenCL:
 130   case dwarf::DW_LANG_Go:
 131   case dwarf::DW_LANG_Haskell:
 132   case dwarf::DW_LANG_C_plus_plus_03:
 133   case dwarf::DW_LANG_C_plus_plus_11:
 134   case dwarf::DW_LANG_OCaml:
 135   case dwarf::DW_LANG_Rust:
 136   case dwarf::DW_LANG_C11:
 137   case dwarf::DW_LANG_Swift:
 138   case dwarf::DW_LANG_Dylan:
 139   case dwarf::DW_LANG_C_plus_plus_14:
 140     if (dwarf::DWARF_VERSION >= 5)
 141       return 0;
 142     break;
 143
 144   case dwarf::DW_LANG_Modula3:
 145   case dwarf::DW_LANG_Julia:
 146   case dwarf::DW_LANG_Fortran03:
 147   case dwarf::DW_LANG_Fortran08:
 148     if (dwarf::DWARF_VERSION >= 5)
 149       return 1;
 150     break;
 151   }
 152
 153   return -1;
 154 }
 155
 156 /// Check whether the DIE for this MDNode can be shared across CUs.
 157 static bool isShareableAcrossCUs(const DINode *D) {
 158   // When the MDNode can be part of the type system, the DIE can be shared
 159   // across CUs.
 160   // Combining type units and cross-CU DIE sharing is lower value (since
 161   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 162   // level already) but may be implementable for some value in projects
 163   // building multiple independent libraries with LTO and then linking those
 164   // together.
 165   return (isa<DIType>(D) ||
 166           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
 167          !GenerateDwarfTypeUnits;
 168 }
 169
 170 DIE *DwarfUnit::getDIE(const DINode *D) const {
 171   if (isShareableAcrossCUs(D))
 172     return DU->getDIE(D);
 173   return MDNodeToDieMap.lookup(D);
 174 }
 175
 176 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
 177   if (isShareableAcrossCUs(Desc)) {
 178     DU->insertDIE(Desc, D);
 179     return;
 180   }
 181   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 182 }
 183
 184 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 185   if (DD->getDwarfVersion() >= 4)
 186     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
 187                  DIEInteger(1));
 188   else
 189     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
 190                  DIEInteger(1));
 191 }
 192
 193 void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
 194                         Optional<dwarf::Form> Form, uint64_t Integer) {
 195   if (!Form)
 196     Form = DIEInteger::BestForm(false, Integer);
 197   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 198 }
 199
 200 void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
 201                         uint64_t Integer) {
 202   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 203 }
 204
 205 void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
 206                         Optional<dwarf::Form> Form, int64_t Integer) {
 207   if (!Form)
 208     Form = DIEInteger::BestForm(true, Integer);
 209   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 210 }
 211
 212 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 213                         int64_t Integer) {
 214   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 215 }
 216
 217 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 218                           StringRef String) {
 219   Die.addValue(DIEValueAllocator, Attribute,
 220                isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
 221                DIEString(DU->getStringPool().getEntry(*Asm, String)));
 222 }
 223
 224 DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
 225                                                  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, uint64_t Signature) {
 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, DIEInteger(Signature));
 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   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
 303   if (N)
 304     insertDIE(N, &Die);
 305   return Die;
 306 }
 307
 308 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 309   Loc->ComputeSize(Asm);
 310   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 311   Die.addValue(DIEValueAllocator, Attribute,
 312                Loc->BestForm(DD->getDwarfVersion()), Loc);
 313 }
 314
 315 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 316                          DIEBlock *Block) {
 317   Block->ComputeSize(Asm);
 318   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 319   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
 320 }
 321
 322 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
 323                               StringRef Directory) {
 324   if (Line == 0)
 325     return;
 326
 327   unsigned FileID = getOrCreateSourceID(File, Directory);
 328   assert(FileID && "Invalid file id");
 329   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 330   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 331 }
 332
 333 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
 334   assert(V);
 335
 336   addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
 337                 V->getScope()->getDirectory());
 338 }
 339
 340 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
 341   assert(G);
 342
 343   addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
 344 }
 345
 346 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
 347   assert(SP);
 348
 349   addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
 350 }
 351
 352 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
 353   assert(Ty);
 354
 355   addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
 356 }
 357
 358 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
 359   assert(Ty);
 360
 361   addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
 362 }
 363
 364 void DwarfUnit::addSourceLine(DIE &Die, const DINamespace *NS) {
 365   addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
 366 }
 367
 368 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
 369                                    unsigned SizeInBits, unsigned OffsetInBits) {
 370   DIEDwarfExpression Expr(*Asm, *this, TheDie);
 371   Expr.AddMachineRegPiece(*Asm->MF->getSubtarget().getRegisterInfo(), Reg,
 372                           SizeInBits, OffsetInBits);
 373   return true;
 374 }
 375
 376 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
 377                                   int64_t Offset) {
 378   DIEDwarfExpression Expr(*Asm, *this, TheDie);
 379   return Expr.AddMachineRegIndirect(*Asm->MF->getSubtarget().getRegisterInfo(),
 380                                     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 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 565   assert(MO.isFPImm() && "Invalid machine operand!");
 566   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 567   APFloat FPImm = MO.getFPImm()->getValueAPF();
 568
 569   // Get the raw data form of the floating point.
 570   const APInt FltVal = FPImm.bitcastToAPInt();
 571   const char *FltPtr = (const char *)FltVal.getRawData();
 572
 573   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 574   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 575   int Incr = (LittleEndian ? 1 : -1);
 576   int Start = (LittleEndian ? 0 : NumBytes - 1);
 577   int Stop = (LittleEndian ? NumBytes : -1);
 578
 579   // Output the constant to DWARF one byte at a time.
 580   for (; Start != Stop; Start += Incr)
 581     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 582
 583   addBlock(Die, dwarf::DW_AT_const_value, Block);
 584 }
 585
 586 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 587   // Pass this down to addConstantValue as an unsigned bag of bits.
 588   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 589 }
 590
 591 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 592                                  const DIType *Ty) {
 593   addConstantValue(Die, CI->getValue(), Ty);
 594 }
 595
 596 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 597                                  const DIType *Ty) {
 598   assert(MO.isImm() && "Invalid machine operand!");
 599
 600   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 601 }
 602
 603 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 604   // FIXME: This is a bit conservative/simple - it emits negative values always
 605   // sign extended to 64 bits rather than minimizing the number of bytes.
 606   addUInt(Die, dwarf::DW_AT_const_value,
 607           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 608 }
 609
 610 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
 611   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 612 }
 613
 614 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 615   unsigned CIBitWidth = Val.getBitWidth();
 616   if (CIBitWidth <= 64) {
 617     addConstantValue(Die, Unsigned,
 618                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 619     return;
 620   }
 621
 622   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 623
 624   // Get the raw data form of the large APInt.
 625   const uint64_t *Ptr64 = Val.getRawData();
 626
 627   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 628   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 629
 630   // Output the constant to DWARF one byte at a time.
 631   for (int i = 0; i < NumBytes; i++) {
 632     uint8_t c;
 633     if (LittleEndian)
 634       c = Ptr64[i / 8] >> (8 * (i & 7));
 635     else
 636       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 637     addUInt(*Block, dwarf::DW_FORM_data1, c);
 638   }
 639
 640   addBlock(Die, dwarf::DW_AT_const_value, Block);
 641 }
 642
 643 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
 644   if (!LinkageName.empty())
 645     addString(Die,
 646               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
 647                                          : dwarf::DW_AT_MIPS_linkage_name,
 648               GlobalValue::getRealLinkageName(LinkageName));
 649 }
 650
 651 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
 652   // Add template parameters.
 653   for (const auto *Element : TParams) {
 654     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
 655       constructTemplateTypeParameterDIE(Buffer, TTP);
 656     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
 657       constructTemplateValueParameterDIE(Buffer, TVP);
 658   }
 659 }
 660
 661 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
 662   if (!Context || isa<DIFile>(Context))
 663     return &getUnitDie();
 664   if (auto *T = dyn_cast<DIType>(Context))
 665     return getOrCreateTypeDIE(T);
 666   if (auto *NS = dyn_cast<DINamespace>(Context))
 667     return getOrCreateNameSpace(NS);
 668   if (auto *SP = dyn_cast<DISubprogram>(Context))
 669     return getOrCreateSubprogramDIE(SP);
 670   if (auto *M = dyn_cast<DIModule>(Context))
 671     return getOrCreateModule(M);
 672   return getDIE(Context);
 673 }
 674
 675 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
 676   auto *Context = resolve(Ty->getScope());
 677   DIE *ContextDIE = getOrCreateContextDIE(Context);
 678
 679   if (DIE *TyDIE = getDIE(Ty))
 680     return TyDIE;
 681
 682   // Create new type.
 683   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 684
 685   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
 686
 687   if (!Ty->isExternalTypeRef())
 688     updateAcceleratorTables(Context, Ty, TyDIE);
 689   return &TyDIE;
 690 }
 691
 692 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 693   if (!TyNode)
 694     return nullptr;
 695
 696   auto *Ty = cast<DIType>(TyNode);
 697
 698   // DW_TAG_restrict_type is not supported in DWARF2
 699   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 700     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
 701
 702   // Construct the context before querying for the existence of the DIE in case
 703   // such construction creates the DIE.
 704   auto *Context = resolve(Ty->getScope());
 705   DIE *ContextDIE = getOrCreateContextDIE(Context);
 706   assert(ContextDIE);
 707
 708   if (DIE *TyDIE = getDIE(Ty))
 709     return TyDIE;
 710
 711   // Create new type.
 712   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 713
 714   updateAcceleratorTables(Context, Ty, TyDIE);
 715
 716   if (auto *BT = dyn_cast<DIBasicType>(Ty))
 717     constructTypeDIE(TyDIE, BT);
 718   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
 719     constructTypeDIE(TyDIE, STy);
 720   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 721     if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
 722       if (MDString *TypeId = CTy->getRawIdentifier()) {
 723         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 724         // Skip updating the accelerator tables since this is not the full type.
 725         return &TyDIE;
 726       }
 727     constructTypeDIE(TyDIE, CTy);
 728   } else {
 729     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
 730   }
 731
 732   return &TyDIE;
 733 }
 734
 735 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
 736                                         const DIType *Ty, const DIE &TyDIE) {
 737   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
 738     bool IsImplementation = 0;
 739     if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
 740       // A runtime language of 0 actually means C/C++ and that any
 741       // non-negative value is some version of Objective-C/C++.
 742       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
 743     }
 744     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 745     DD->addAccelType(Ty->getName(), TyDIE, Flags);
 746
 747     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
 748         isa<DINamespace>(Context))
 749       addGlobalType(Ty, TyDIE, Context);
 750   }
 751 }
 752
 753 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
 754                         dwarf::Attribute Attribute) {
 755   assert(Ty && "Trying to add a type that doesn't exist?");
 756   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
 757 }
 758
 759 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
 760   if (!Context)
 761     return "";
 762
 763   // FIXME: Decide whether to implement this for non-C++ languages.
 764   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 765     return "";
 766
 767   std::string CS;
 768   SmallVector<const DIScope *, 1> Parents;
 769   while (!isa<DICompileUnit>(Context)) {
 770     Parents.push_back(Context);
 771     if (Context->getScope())
 772       Context = resolve(Context->getScope());
 773     else
 774       // Structure, etc types will have a NULL context if they're at the top
 775       // level.
 776       break;
 777   }
 778
 779   // Reverse iterate over our list to go from the outermost construct to the
 780   // innermost.
 781   for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
 782     StringRef Name = Ctx->getName();
 783     if (Name.empty() && isa<DINamespace>(Ctx))
 784       Name = "(anonymous namespace)";
 785     if (!Name.empty()) {
 786       CS += Name;
 787       CS += "::";
 788     }
 789   }
 790   return CS;
 791 }
 792
 793 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
 794   // Get core information.
 795   StringRef Name = BTy->getName();
 796   // Add name if not anonymous or intermediate type.
 797   if (!Name.empty())
 798     addString(Buffer, dwarf::DW_AT_name, Name);
 799
 800   // An unspecified type only has a name attribute.
 801   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
 802     return;
 803
 804   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 805           BTy->getEncoding());
 806
 807   uint64_t Size = BTy->getSizeInBits() >> 3;
 808   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 809 }
 810
 811 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
 812   // Get core information.
 813   StringRef Name = DTy->getName();
 814   uint64_t Size = DTy->getSizeInBits() >> 3;
 815   uint16_t Tag = Buffer.getTag();
 816
 817   // Map to main type, void will not have a type.
 818   const DIType *FromTy = resolve(DTy->getBaseType());
 819   if (FromTy)
 820     addType(Buffer, FromTy);
 821
 822   // Add name if not anonymous or intermediate type.
 823   if (!Name.empty())
 824     addString(Buffer, dwarf::DW_AT_name, Name);
 825
 826   // Add size if non-zero (derived types might be zero-sized.)
 827   if (Size && Tag != dwarf::DW_TAG_pointer_type
 828            && Tag != dwarf::DW_TAG_ptr_to_member_type
 829            && Tag != dwarf::DW_TAG_reference_type
 830            && Tag != dwarf::DW_TAG_rvalue_reference_type)
 831     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 832
 833   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 834     addDIEEntry(
 835         Buffer, dwarf::DW_AT_containing_type,
 836         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
 837   // Add source line info if available and TyDesc is not a forward declaration.
 838   if (!DTy->isForwardDecl())
 839     addSourceLine(Buffer, DTy);
 840 }
 841
 842 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
 843   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 844     const DIType *Ty = resolve(Args[i]);
 845     if (!Ty) {
 846       assert(i == N-1 && "Unspecified parameter must be the last argument");
 847       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 848     } else {
 849       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 850       addType(Arg, Ty);
 851       if (Ty->isArtificial())
 852         addFlag(Arg, dwarf::DW_AT_artificial);
 853     }
 854   }
 855 }
 856
 857 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 858   // Add return type.  A void return won't have a type.
 859   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
 860   if (Elements.size())
 861     if (auto RTy = resolve(Elements[0]))
 862       addType(Buffer, RTy);
 863
 864   bool isPrototyped = true;
 865   if (Elements.size() == 2 && !Elements[1])
 866     isPrototyped = false;
 867
 868   constructSubprogramArguments(Buffer, Elements);
 869
 870   // Add prototype flag if we're dealing with a C language and the function has
 871   // been prototyped.
 872   uint16_t Language = getLanguage();
 873   if (isPrototyped &&
 874       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
 875        Language == dwarf::DW_LANG_ObjC))
 876     addFlag(Buffer, dwarf::DW_AT_prototyped);
 877
 878   // Add a DW_AT_calling_convention if this has an explicit convention.
 879   if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
 880     addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
 881             CTy->getCC());
 882
 883   if (CTy->isLValueReference())
 884     addFlag(Buffer, dwarf::DW_AT_reference);
 885
 886   if (CTy->isRValueReference())
 887     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 888 }
 889
 890 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
 891   if (CTy->isExternalTypeRef()) {
 892     StringRef Identifier = CTy->getIdentifier();
 893     assert(!Identifier.empty() && "external type ref without identifier");
 894     addFlag(Buffer, dwarf::DW_AT_declaration);
 895     return addDIETypeSignature(Buffer, dwarf::DW_AT_signature, Identifier);
 896   }
 897
 898   // Add name if not anonymous or intermediate type.
 899   StringRef Name = CTy->getName();
 900
 901   uint64_t Size = CTy->getSizeInBits() >> 3;
 902   uint16_t Tag = Buffer.getTag();
 903
 904   switch (Tag) {
 905   case dwarf::DW_TAG_array_type:
 906     constructArrayTypeDIE(Buffer, CTy);
 907     break;
 908   case dwarf::DW_TAG_enumeration_type:
 909     constructEnumTypeDIE(Buffer, CTy);
 910     break;
 911   case dwarf::DW_TAG_structure_type:
 912   case dwarf::DW_TAG_union_type:
 913   case dwarf::DW_TAG_class_type: {
 914     // Add elements to structure type.
 915     DINodeArray Elements = CTy->getElements();
 916     for (const auto *Element : Elements) {
 917       if (!Element)
 918         continue;
 919       if (auto *SP = dyn_cast<DISubprogram>(Element))
 920         getOrCreateSubprogramDIE(SP);
 921       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
 922         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
 923           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
 924           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
 925         } else if (DDTy->isStaticMember()) {
 926           getOrCreateStaticMemberDIE(DDTy);
 927         } else {
 928           constructMemberDIE(Buffer, DDTy);
 929         }
 930       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
 931         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
 932         StringRef PropertyName = Property->getName();
 933         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 934         if (Property->getType())
 935           addType(ElemDie, resolve(Property->getType()));
 936         addSourceLine(ElemDie, Property);
 937         StringRef GetterName = Property->getGetterName();
 938         if (!GetterName.empty())
 939           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 940         StringRef SetterName = Property->getSetterName();
 941         if (!SetterName.empty())
 942           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 943         if (unsigned PropertyAttributes = Property->getAttributes())
 944           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
 945                   PropertyAttributes);
 946       }
 947     }
 948
 949     if (CTy->isAppleBlockExtension())
 950       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 951
 952     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
 953     // inside C++ composite types to point to the base class with the vtable.
 954     if (auto *ContainingType =
 955             dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
 956       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 957                   *getOrCreateTypeDIE(ContainingType));
 958
 959     if (CTy->isObjcClassComplete())
 960       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 961
 962     // Add template parameters to a class, structure or union types.
 963     // FIXME: The support isn't in the metadata for this yet.
 964     if (Tag == dwarf::DW_TAG_class_type ||
 965         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 966       addTemplateParams(Buffer, CTy->getTemplateParams());
 967
 968     break;
 969   }
 970   default:
 971     break;
 972   }
 973
 974   // Add name if not anonymous or intermediate type.
 975   if (!Name.empty())
 976     addString(Buffer, dwarf::DW_AT_name, Name);
 977
 978   if (Tag == dwarf::DW_TAG_enumeration_type ||
 979       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
 980       Tag == dwarf::DW_TAG_union_type) {
 981     // Add size if non-zero (derived types might be zero-sized.)
 982     // TODO: Do we care about size for enum forward declarations?
 983     if (Size)
 984       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 985     else if (!CTy->isForwardDecl())
 986       // Add zero size if it is not a forward declaration.
 987       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
 988
 989     // If we're a forward decl, say so.
 990     if (CTy->isForwardDecl())
 991       addFlag(Buffer, dwarf::DW_AT_declaration);
 992
 993     // Add source line info if available.
 994     if (!CTy->isForwardDecl())
 995       addSourceLine(Buffer, CTy);
 996
 997     // No harm in adding the runtime language to the declaration.
 998     unsigned RLang = CTy->getRuntimeLang();
 999     if (RLang)
1000       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1001               RLang);
1002   }
1003 }
1004
1005 void DwarfUnit::constructTemplateTypeParameterDIE(
1006     DIE &Buffer, const DITemplateTypeParameter *TP) {
1007   DIE &ParamDIE =
1008       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1009   // Add the type if it exists, it could be void and therefore no type.
1010   if (TP->getType())
1011     addType(ParamDIE, resolve(TP->getType()));
1012   if (!TP->getName().empty())
1013     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1014 }
1015
1016 void DwarfUnit::constructTemplateValueParameterDIE(
1017     DIE &Buffer, const DITemplateValueParameter *VP) {
1018   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1019
1020   // Add the type if there is one, template template and template parameter
1021   // packs will not have a type.
1022   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1023     addType(ParamDIE, resolve(VP->getType()));
1024   if (!VP->getName().empty())
1025     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1026   if (Metadata *Val = VP->getValue()) {
1027     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1028       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1029     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1030       // We cannot describe the location of dllimport'd entities: the
1031       // computation of their address requires loads from the IAT.
1032       if (!GV->hasDLLImportStorageClass()) {
1033         // For declaration non-type template parameters (such as global values
1034         // and functions)
1035         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1036         addOpAddress(*Loc, Asm->getSymbol(GV));
1037         // Emit DW_OP_stack_value to use the address as the immediate value of
1038         // the parameter, rather than a pointer to it.
1039         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1040         addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1041       }
1042     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1043       assert(isa<MDString>(Val));
1044       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1045                 cast<MDString>(Val)->getString());
1046     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1047       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1048     }
1049   }
1050 }
1051
1052 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1053   // Construct the context before querying for the existence of the DIE in case
1054   // such construction creates the DIE.
1055   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1056
1057   if (DIE *NDie = getDIE(NS))
1058     return NDie;
1059   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1060
1061   StringRef Name = NS->getName();
1062   if (!Name.empty())
1063     addString(NDie, dwarf::DW_AT_name, NS->getName());
1064   else
1065     Name = "(anonymous namespace)";
1066   DD->addAccelNamespace(Name, NDie);
1067   addGlobalName(Name, NDie, NS->getScope());
1068   addSourceLine(NDie, NS);
1069   return &NDie;
1070 }
1071
1072 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1073   // Construct the context before querying for the existence of the DIE in case
1074   // such construction creates the DIE.
1075   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1076
1077   if (DIE *MDie = getDIE(M))
1078     return MDie;
1079   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1080
1081   if (!M->getName().empty()) {
1082     addString(MDie, dwarf::DW_AT_name, M->getName());
1083     addGlobalName(M->getName(), MDie, M->getScope());
1084   }
1085   if (!M->getConfigurationMacros().empty())
1086     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1087               M->getConfigurationMacros());
1088   if (!M->getIncludePath().empty())
1089     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1090   if (!M->getISysRoot().empty())
1091     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1092
1093   return &MDie;
1094 }
1095
1096 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1097   // Construct the context before querying for the existence of the DIE in case
1098   // such construction creates the DIE (as is the case for member function
1099   // declarations).
1100   DIE *ContextDIE =
1101       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1102
1103   if (DIE *SPDie = getDIE(SP))
1104     return SPDie;
1105
1106   if (auto *SPDecl = SP->getDeclaration()) {
1107     if (!Minimal) {
1108       // Add subprogram definitions to the CU die directly.
1109       ContextDIE = &getUnitDie();
1110       // Build the decl now to ensure it precedes the definition.
1111       getOrCreateSubprogramDIE(SPDecl);
1112     }
1113   }
1114
1115   // DW_TAG_inlined_subroutine may refer to this DIE.
1116   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1117
1118   // Stop here and fill this in later, depending on whether or not this
1119   // subprogram turns out to have inlined instances or not.
1120   if (SP->isDefinition())
1121     return &SPDie;
1122
1123   applySubprogramAttributes(SP, SPDie);
1124   return &SPDie;
1125 }
1126
1127 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1128                                                     DIE &SPDie) {
1129   DIE *DeclDie = nullptr;
1130   StringRef DeclLinkageName;
1131   if (auto *SPDecl = SP->getDeclaration()) {
1132     DeclDie = getDIE(SPDecl);
1133     assert(DeclDie && "This DIE should've already been constructed when the "
1134                       "definition DIE was created in "
1135                       "getOrCreateSubprogramDIE");
1136     DeclLinkageName = SPDecl->getLinkageName();
1137     unsigned DeclID =
1138         getOrCreateSourceID(SPDecl->getFilename(), SPDecl->getDirectory());
1139     unsigned DefID = getOrCreateSourceID(SP->getFilename(), SP->getDirectory());
1140     if (DeclID != DefID)
1141       addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1142
1143     if (SP->getLine() != SPDecl->getLine())
1144       addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1145   }
1146
1147   // Add function template parameters.
1148   addTemplateParams(SPDie, SP->getTemplateParams());
1149
1150   // Add the linkage name if we have one and it isn't in the Decl.
1151   StringRef LinkageName = SP->getLinkageName();
1152   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1153           LinkageName == DeclLinkageName) &&
1154          "decl has a linkage name and it is different");
1155   if (DeclLinkageName.empty() &&
1156       // Always emit it for abstract subprograms.
1157       (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1158     addLinkageName(SPDie, LinkageName);
1159
1160   if (!DeclDie)
1161     return false;
1162
1163   // Refer to the function declaration where all the other attributes will be
1164   // found.
1165   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1166   return true;
1167 }
1168
1169 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1170                                           bool Minimal) {
1171   if (!Minimal)
1172     if (applySubprogramDefinitionAttributes(SP, SPDie))
1173       return;
1174
1175   // Constructors and operators for anonymous aggregates do not have names.
1176   if (!SP->getName().empty())
1177     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1178
1179   // Skip the rest of the attributes under -gmlt to save space.
1180   if (Minimal)
1181     return;
1182
1183   addSourceLine(SPDie, SP);
1184
1185   // Add the prototype if we have a prototype and we have a C like
1186   // language.
1187   uint16_t Language = getLanguage();
1188   if (SP->isPrototyped() &&
1189       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1190        Language == dwarf::DW_LANG_ObjC))
1191     addFlag(SPDie, dwarf::DW_AT_prototyped);
1192
1193   unsigned CC = 0;
1194   DITypeRefArray Args;
1195   if (const DISubroutineType *SPTy = SP->getType()) {
1196     Args = SPTy->getTypeArray();
1197     CC = SPTy->getCC();
1198   }
1199
1200   // Add a DW_AT_calling_convention if this has an explicit convention.
1201   if (CC && CC != dwarf::DW_CC_normal)
1202     addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1203
1204   // Add a return type. If this is a type like a C/C++ void type we don't add a
1205   // return type.
1206   if (Args.size())
1207     if (auto Ty = resolve(Args[0]))
1208       addType(SPDie, Ty);
1209
1210   unsigned VK = SP->getVirtuality();
1211   if (VK) {
1212     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1213     if (SP->getVirtualIndex() != -1u) {
1214       DIELoc *Block = getDIELoc();
1215       addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1216       addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1217       addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1218     }
1219     ContainingTypeMap.insert(
1220         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1221   }
1222
1223   if (!SP->isDefinition()) {
1224     addFlag(SPDie, dwarf::DW_AT_declaration);
1225
1226     // Add arguments. Do not add arguments for subprogram definition. They will
1227     // be handled while processing variables.
1228     constructSubprogramArguments(SPDie, Args);
1229   }
1230
1231   if (SP->isArtificial())
1232     addFlag(SPDie, dwarf::DW_AT_artificial);
1233
1234   if (!SP->isLocalToUnit())
1235     addFlag(SPDie, dwarf::DW_AT_external);
1236
1237   if (DD->useAppleExtensionAttributes()) {
1238     if (SP->isOptimized())
1239       addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1240
1241     if (unsigned isa = Asm->getISAEncoding())
1242       addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1243   }
1244
1245   if (SP->isLValueReference())
1246     addFlag(SPDie, dwarf::DW_AT_reference);
1247
1248   if (SP->isRValueReference())
1249     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1250
1251   if (SP->isProtected())
1252     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1253             dwarf::DW_ACCESS_protected);
1254   else if (SP->isPrivate())
1255     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1256             dwarf::DW_ACCESS_private);
1257   else if (SP->isPublic())
1258     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1259             dwarf::DW_ACCESS_public);
1260
1261   if (SP->isExplicit())
1262     addFlag(SPDie, dwarf::DW_AT_explicit);
1263 }
1264
1265 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1266                                      DIE *IndexTy) {
1267   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1268   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1269
1270   // The LowerBound value defines the lower bounds which is typically zero for
1271   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1272   // Count == -1 then the array is unbounded and we do not emit
1273   // DW_AT_lower_bound and DW_AT_count attributes.
1274   int64_t LowerBound = SR->getLowerBound();
1275   int64_t DefaultLowerBound = getDefaultLowerBound();
1276   int64_t Count = SR->getCount();
1277
1278   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1279     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1280
1281   if (Count != -1)
1282     // FIXME: An unbounded array should reference the expression that defines
1283     // the array.
1284     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1285 }
1286
1287 DIE *DwarfUnit::getIndexTyDie() {
1288   if (IndexTyDie)
1289     return IndexTyDie;
1290   // Construct an integer type to use for indexes.
1291   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1292   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1293   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1294   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1295           dwarf::DW_ATE_unsigned);
1296   return IndexTyDie;
1297 }
1298
1299 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1300   if (CTy->isVector())
1301     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1302
1303   // Emit the element type.
1304   addType(Buffer, resolve(CTy->getBaseType()));
1305
1306   // Get an anonymous type for index type.
1307   // FIXME: This type should be passed down from the front end
1308   // as different languages may have different sizes for indexes.
1309   DIE *IdxTy = getIndexTyDie();
1310
1311   // Add subranges to array type.
1312   DINodeArray Elements = CTy->getElements();
1313   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1314     // FIXME: Should this really be such a loose cast?
1315     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1316       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1317         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1318   }
1319 }
1320
1321 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1322   DINodeArray Elements = CTy->getElements();
1323
1324   // Add enumerators to enumeration type.
1325   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1326     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1327     if (Enum) {
1328       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1329       StringRef Name = Enum->getName();
1330       addString(Enumerator, dwarf::DW_AT_name, Name);
1331       int64_t Value = Enum->getValue();
1332       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1333               Value);
1334     }
1335   }
1336   const DIType *DTy = resolve(CTy->getBaseType());
1337   if (DTy) {
1338     addType(Buffer, DTy);
1339     addFlag(Buffer, dwarf::DW_AT_enum_class);
1340   }
1341 }
1342
1343 void DwarfUnit::constructContainingTypeDIEs() {
1344   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1345        CI != CE; ++CI) {
1346     DIE &SPDie = *CI->first;
1347     const DINode *D = CI->second;
1348     if (!D)
1349       continue;
1350     DIE *NDie = getDIE(D);
1351     if (!NDie)
1352       continue;
1353     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1354   }
1355 }
1356
1357 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1358   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1359   StringRef Name = DT->getName();
1360   if (!Name.empty())
1361     addString(MemberDie, dwarf::DW_AT_name, Name);
1362
1363   addType(MemberDie, resolve(DT->getBaseType()));
1364
1365   addSourceLine(MemberDie, DT);
1366
1367   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1368
1369     // For C++, virtual base classes are not at fixed offset. Use following
1370     // expression to extract appropriate offset from vtable.
1371     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1372
1373     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1374     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1375     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1376     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1377     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1378     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1379     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1380     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1381
1382     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1383   } else {
1384     uint64_t Size = DT->getSizeInBits();
1385     uint64_t FieldSize = DD->getBaseTypeSize(DT);
1386     uint64_t OffsetInBytes;
1387
1388     bool IsBitfield = FieldSize && Size != FieldSize;
1389     if (IsBitfield) {
1390       // Handle bitfield, assume bytes are 8 bits.
1391       if (DD->useDWARF2Bitfields())
1392         addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1393       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1394
1395       uint64_t Offset = DT->getOffsetInBits();
1396       uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
1397       uint64_t AlignMask = ~(Align - 1);
1398       // The bits from the start of the storage unit to the start of the field.
1399       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1400       // The byte offset of the field's aligned storage unit inside the struct.
1401       OffsetInBytes = (Offset - StartBitOffset) / 8;
1402
1403       if (DD->useDWARF2Bitfields()) {
1404         uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1405         uint64_t FieldOffset = (HiMark - FieldSize);
1406         Offset -= FieldOffset;
1407
1408         // Maybe we need to work from the other end.
1409         if (Asm->getDataLayout().isLittleEndian())
1410           Offset = FieldSize - (Offset + Size);
1411
1412         addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1413         OffsetInBytes = FieldOffset >> 3;
1414       } else {
1415         addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1416       }
1417     } else {
1418       // This is not a bitfield.
1419       OffsetInBytes = DT->getOffsetInBits() / 8;
1420     }
1421
1422     if (DD->getDwarfVersion() <= 2) {
1423       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1424       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1425       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1426       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1427     } else if (!IsBitfield || DD->useDWARF2Bitfields())
1428       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1429               OffsetInBytes);
1430   }
1431
1432   if (DT->isProtected())
1433     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1434             dwarf::DW_ACCESS_protected);
1435   else if (DT->isPrivate())
1436     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1437             dwarf::DW_ACCESS_private);
1438   // Otherwise C++ member and base classes are considered public.
1439   else if (DT->isPublic())
1440     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1441             dwarf::DW_ACCESS_public);
1442   if (DT->isVirtual())
1443     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1444             dwarf::DW_VIRTUALITY_virtual);
1445
1446   // Objective-C properties.
1447   if (DINode *PNode = DT->getObjCProperty())
1448     if (DIE *PDie = getDIE(PNode))
1449       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1450                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1451
1452   if (DT->isArtificial())
1453     addFlag(MemberDie, dwarf::DW_AT_artificial);
1454 }
1455
1456 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1457   if (!DT)
1458     return nullptr;
1459
1460   // Construct the context before querying for the existence of the DIE in case
1461   // such construction creates the DIE.
1462   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1463   assert(dwarf::isType(ContextDIE->getTag()) &&
1464          "Static member should belong to a type.");
1465
1466   if (DIE *StaticMemberDIE = getDIE(DT))
1467     return StaticMemberDIE;
1468
1469   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1470
1471   const DIType *Ty = resolve(DT->getBaseType());
1472
1473   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1474   addType(StaticMemberDIE, Ty);
1475   addSourceLine(StaticMemberDIE, DT);
1476   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1477   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1478
1479   // FIXME: We could omit private if the parent is a class_type, and
1480   // public if the parent is something else.
1481   if (DT->isProtected())
1482     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1483             dwarf::DW_ACCESS_protected);
1484   else if (DT->isPrivate())
1485     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1486             dwarf::DW_ACCESS_private);
1487   else if (DT->isPublic())
1488     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1489             dwarf::DW_ACCESS_public);
1490
1491   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1492     addConstantValue(StaticMemberDIE, CI, Ty);
1493   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1494     addConstantFPValue(StaticMemberDIE, CFP);
1495
1496   return &StaticMemberDIE;
1497 }
1498
1499 void DwarfUnit::emitHeader(bool UseOffsets) {
1500   // Emit size of content not including length itself
1501   Asm->OutStreamer->AddComment("Length of Unit");
1502   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1503
1504   Asm->OutStreamer->AddComment("DWARF version number");
1505   Asm->EmitInt16(DD->getDwarfVersion());
1506   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1507
1508   // We share one abbreviations table across all units so it's always at the
1509   // start of the section. Use a relocatable offset where needed to ensure
1510   // linking doesn't invalidate that offset.
1511   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1512   if (UseOffsets)
1513     Asm->EmitInt32(0);
1514   else
1515     Asm->emitDwarfSymbolReference(
1516         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
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 }