lib/CodeGen/AsmPrinter/DwarfUnit.cpp

   1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains support for constructing a dwarf compile unit.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "DwarfUnit.h"
  14 #include "AddressPool.h"
  15 #include "DwarfCompileUnit.h"
  16 #include "DwarfDebug.h"
  17 #include "DwarfExpression.h"
  18 #include "llvm/ADT/APFloat.h"
  19 #include "llvm/ADT/APInt.h"
  20 #include "llvm/ADT/None.h"
  21 #include "llvm/ADT/StringExtras.h"
  22 #include "llvm/ADT/iterator_range.h"
  23 #include "llvm/CodeGen/MachineFunction.h"
  24 #include "llvm/CodeGen/MachineOperand.h"
  25 #include "llvm/CodeGen/TargetRegisterInfo.h"
  26 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  27 #include "llvm/IR/Constants.h"
  28 #include "llvm/IR/DataLayout.h"
  29 #include "llvm/IR/GlobalValue.h"
  30 #include "llvm/IR/Metadata.h"
  31 #include "llvm/MC/MCAsmInfo.h"
  32 #include "llvm/MC/MCContext.h"
  33 #include "llvm/MC/MCDwarf.h"
  34 #include "llvm/MC/MCSection.h"
  35 #include "llvm/MC/MCStreamer.h"
  36 #include "llvm/MC/MachineLocation.h"
  37 #include "llvm/Support/Casting.h"
  38 #include "llvm/Support/CommandLine.h"
  39 #include "llvm/Target/TargetLoweringObjectFile.h"
  40 #include <cassert>
  41 #include <cstdint>
  42 #include <string>
  43 #include <utility>
  44
  45 using namespace llvm;
  46
  47 #define DEBUG_TYPE "dwarfdebug"
  48
  49 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP,
  50                                        DwarfCompileUnit &CU,
  51                                        DIELoc &DIE)
  52     : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP),
  53       DIE(DIE) {}
  54
  55 void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
  56   CU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
  57 }
  58
  59 void DIEDwarfExpression::emitSigned(int64_t Value) {
  60   CU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
  61 }
  62
  63 void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
  64   CU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
  65 }
  66
  67 void DIEDwarfExpression::emitData1(uint8_t Value) {
  68   CU.addUInt(DIE, dwarf::DW_FORM_data1, Value);
  69 }
  70
  71 void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
  72   CU.addBaseTypeRef(DIE, Idx);
  73 }
  74
  75 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
  76                                          unsigned MachineReg) {
  77   return MachineReg == TRI.getFrameRegister(*AP.MF);
  78 }
  79
  80 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
  81                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
  82     : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
  83       CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
  84 }
  85
  86 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
  87                              DwarfDebug *DW, DwarfFile *DWU,
  88                              MCDwarfDwoLineTable *SplitLineTable)
  89     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
  90       SplitLineTable(SplitLineTable) {
  91 }
  92
  93 DwarfUnit::~DwarfUnit() {
  94   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  95     DIEBlocks[j]->~DIEBlock();
  96   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  97     DIELocs[j]->~DIELoc();
  98 }
  99
 100 int64_t DwarfUnit::getDefaultLowerBound() const {
 101   switch (getLanguage()) {
 102   default:
 103     break;
 104
 105   // The languages below have valid values in all DWARF versions.
 106   case dwarf::DW_LANG_C:
 107   case dwarf::DW_LANG_C89:
 108   case dwarf::DW_LANG_C_plus_plus:
 109     return 0;
 110
 111   case dwarf::DW_LANG_Fortran77:
 112   case dwarf::DW_LANG_Fortran90:
 113     return 1;
 114
 115   // The languages below have valid values only if the DWARF version >= 3.
 116   case dwarf::DW_LANG_C99:
 117   case dwarf::DW_LANG_ObjC:
 118   case dwarf::DW_LANG_ObjC_plus_plus:
 119     if (DD->getDwarfVersion() >= 3)
 120       return 0;
 121     break;
 122
 123   case dwarf::DW_LANG_Fortran95:
 124     if (DD->getDwarfVersion() >= 3)
 125       return 1;
 126     break;
 127
 128   // Starting with DWARF v4, all defined languages have valid values.
 129   case dwarf::DW_LANG_D:
 130   case dwarf::DW_LANG_Java:
 131   case dwarf::DW_LANG_Python:
 132   case dwarf::DW_LANG_UPC:
 133     if (DD->getDwarfVersion() >= 4)
 134       return 0;
 135     break;
 136
 137   case dwarf::DW_LANG_Ada83:
 138   case dwarf::DW_LANG_Ada95:
 139   case dwarf::DW_LANG_Cobol74:
 140   case dwarf::DW_LANG_Cobol85:
 141   case dwarf::DW_LANG_Modula2:
 142   case dwarf::DW_LANG_Pascal83:
 143   case dwarf::DW_LANG_PLI:
 144     if (DD->getDwarfVersion() >= 4)
 145       return 1;
 146     break;
 147
 148   // The languages below are new in DWARF v5.
 149   case dwarf::DW_LANG_BLISS:
 150   case dwarf::DW_LANG_C11:
 151   case dwarf::DW_LANG_C_plus_plus_03:
 152   case dwarf::DW_LANG_C_plus_plus_11:
 153   case dwarf::DW_LANG_C_plus_plus_14:
 154   case dwarf::DW_LANG_Dylan:
 155   case dwarf::DW_LANG_Go:
 156   case dwarf::DW_LANG_Haskell:
 157   case dwarf::DW_LANG_OCaml:
 158   case dwarf::DW_LANG_OpenCL:
 159   case dwarf::DW_LANG_RenderScript:
 160   case dwarf::DW_LANG_Rust:
 161   case dwarf::DW_LANG_Swift:
 162     if (DD->getDwarfVersion() >= 5)
 163       return 0;
 164     break;
 165
 166   case dwarf::DW_LANG_Fortran03:
 167   case dwarf::DW_LANG_Fortran08:
 168   case dwarf::DW_LANG_Julia:
 169   case dwarf::DW_LANG_Modula3:
 170     if (DD->getDwarfVersion() >= 5)
 171       return 1;
 172     break;
 173   }
 174
 175   return -1;
 176 }
 177
 178 /// Check whether the DIE for this MDNode can be shared across CUs.
 179 bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const {
 180   // When the MDNode can be part of the type system, the DIE can be shared
 181   // across CUs.
 182   // Combining type units and cross-CU DIE sharing is lower value (since
 183   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 184   // level already) but may be implementable for some value in projects
 185   // building multiple independent libraries with LTO and then linking those
 186   // together.
 187   if (isDwoUnit() && !DD->shareAcrossDWOCUs())
 188     return false;
 189   return (isa<DIType>(D) ||
 190           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
 191          !DD->generateTypeUnits();
 192 }
 193
 194 DIE *DwarfUnit::getDIE(const DINode *D) const {
 195   if (isShareableAcrossCUs(D))
 196     return DU->getDIE(D);
 197   return MDNodeToDieMap.lookup(D);
 198 }
 199
 200 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
 201   if (isShareableAcrossCUs(Desc)) {
 202     DU->insertDIE(Desc, D);
 203     return;
 204   }
 205   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 206 }
 207
 208 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 209   if (DD->getDwarfVersion() >= 4)
 210     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
 211                  DIEInteger(1));
 212   else
 213     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
 214                  DIEInteger(1));
 215 }
 216
 217 void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
 218                         Optional<dwarf::Form> Form, uint64_t Integer) {
 219   if (!Form)
 220     Form = DIEInteger::BestForm(false, Integer);
 221   assert(Form != dwarf::DW_FORM_implicit_const &&
 222          "DW_FORM_implicit_const is used only for signed integers");
 223   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 224 }
 225
 226 void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
 227                         uint64_t Integer) {
 228   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 229 }
 230
 231 void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
 232                         Optional<dwarf::Form> Form, int64_t Integer) {
 233   if (!Form)
 234     Form = DIEInteger::BestForm(true, Integer);
 235   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
 236 }
 237
 238 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 239                         int64_t Integer) {
 240   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 241 }
 242
 243 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 244                           StringRef String) {
 245   if (CUNode->isDebugDirectivesOnly())
 246     return;
 247
 248   if (DD->useInlineStrings()) {
 249     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
 250                  new (DIEValueAllocator)
 251                      DIEInlineString(String, DIEValueAllocator));
 252     return;
 253   }
 254   dwarf::Form IxForm =
 255       isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
 256
 257   auto StringPoolEntry =
 258       useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index
 259           ? DU->getStringPool().getIndexedEntry(*Asm, String)
 260           : DU->getStringPool().getEntry(*Asm, String);
 261
 262   // For DWARF v5 and beyond, use the smallest strx? form possible.
 263   if (useSegmentedStringOffsetsTable()) {
 264     IxForm = dwarf::DW_FORM_strx1;
 265     unsigned Index = StringPoolEntry.getIndex();
 266     if (Index > 0xffffff)
 267       IxForm = dwarf::DW_FORM_strx4;
 268     else if (Index > 0xffff)
 269       IxForm = dwarf::DW_FORM_strx3;
 270     else if (Index > 0xff)
 271       IxForm = dwarf::DW_FORM_strx2;
 272   }
 273   Die.addValue(DIEValueAllocator, Attribute, IxForm,
 274                DIEString(StringPoolEntry));
 275 }
 276
 277 DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
 278                                                  dwarf::Attribute Attribute,
 279                                                  dwarf::Form Form,
 280                                                  const MCSymbol *Label) {
 281   return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
 282 }
 283
 284 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 285   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 286 }
 287
 288 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 289                                  uint64_t Integer) {
 290   if (DD->getDwarfVersion() >= 4)
 291     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 292   else
 293     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 294 }
 295
 296 Optional<MD5::MD5Result> DwarfUnit::getMD5AsBytes(const DIFile *File) const {
 297   assert(File);
 298   if (DD->getDwarfVersion() < 5)
 299     return None;
 300   Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
 301   if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
 302     return None;
 303
 304   // Convert the string checksum to an MD5Result for the streamer.
 305   // The verifier validates the checksum so we assume it's okay.
 306   // An MD5 checksum is 16 bytes.
 307   std::string ChecksumString = fromHex(Checksum->Value);
 308   MD5::MD5Result CKMem;
 309   std::copy(ChecksumString.begin(), ChecksumString.end(), CKMem.Bytes.data());
 310   return CKMem;
 311 }
 312
 313 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
 314   if (!SplitLineTable)
 315     return getCU().getOrCreateSourceID(File);
 316   if (!UsedLineTable) {
 317     UsedLineTable = true;
 318     // This is a split type unit that needs a line table.
 319     addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
 320   }
 321   return SplitLineTable->getFile(File->getDirectory(), File->getFilename(),
 322                                  getMD5AsBytes(File),
 323                                  Asm->OutContext.getDwarfVersion(),
 324                                  File->getSource());
 325 }
 326
 327 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 328   if (DD->getDwarfVersion() >= 5) {
 329     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
 330     addUInt(Die, dwarf::DW_FORM_addrx, DD->getAddressPool().getIndex(Sym));
 331     return;
 332   }
 333
 334   if (DD->useSplitDwarf()) {
 335     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 336     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 337             DD->getAddressPool().getIndex(Sym));
 338     return;
 339   }
 340
 341   addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 342   addLabel(Die, dwarf::DW_FORM_udata, Sym);
 343 }
 344
 345 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 346                               const MCSymbol *Hi, const MCSymbol *Lo) {
 347   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
 348                new (DIEValueAllocator) DIEDelta(Hi, Lo));
 349 }
 350
 351 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 352   addDIEEntry(Die, Attribute, DIEEntry(Entry));
 353 }
 354
 355 void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
 356   // Flag the type unit reference as a declaration so that if it contains
 357   // members (implicit special members, static data member definitions, member
 358   // declarations for definitions in this CU, etc) consumers don't get confused
 359   // and think this is a full definition.
 360   addFlag(Die, dwarf::DW_AT_declaration);
 361
 362   Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
 363                dwarf::DW_FORM_ref_sig8, DIEInteger(Signature));
 364 }
 365
 366 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 367                             DIEEntry Entry) {
 368   const DIEUnit *CU = Die.getUnit();
 369   const DIEUnit *EntryCU = Entry.getEntry().getUnit();
 370   if (!CU)
 371     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 372     CU = getUnitDie().getUnit();
 373   if (!EntryCU)
 374     EntryCU = getUnitDie().getUnit();
 375   Die.addValue(DIEValueAllocator, Attribute,
 376                EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 377                Entry);
 378 }
 379
 380 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
 381   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
 382   if (N)
 383     insertDIE(N, &Die);
 384   return Die;
 385 }
 386
 387 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 388   Loc->ComputeSize(Asm);
 389   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 390   Die.addValue(DIEValueAllocator, Attribute,
 391                Loc->BestForm(DD->getDwarfVersion()), Loc);
 392 }
 393
 394 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 395                          DIEBlock *Block) {
 396   Block->ComputeSize(Asm);
 397   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 398   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
 399 }
 400
 401 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
 402   if (Line == 0)
 403     return;
 404
 405   unsigned FileID = getOrCreateSourceID(File);
 406   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 407   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 408 }
 409
 410 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
 411   assert(V);
 412
 413   addSourceLine(Die, V->getLine(), V->getFile());
 414 }
 415
 416 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
 417   assert(G);
 418
 419   addSourceLine(Die, G->getLine(), G->getFile());
 420 }
 421
 422 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
 423   assert(SP);
 424
 425   addSourceLine(Die, SP->getLine(), SP->getFile());
 426 }
 427
 428 void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) {
 429   assert(L);
 430
 431   addSourceLine(Die, L->getLine(), L->getFile());
 432 }
 433
 434 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
 435   assert(Ty);
 436
 437   addSourceLine(Die, Ty->getLine(), Ty->getFile());
 438 }
 439
 440 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
 441   assert(Ty);
 442
 443   addSourceLine(Die, Ty->getLine(), Ty->getFile());
 444 }
 445
 446 /// Return true if type encoding is unsigned.
 447 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
 448   if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 449     // FIXME: Enums without a fixed underlying type have unknown signedness
 450     // here, leading to incorrectly emitted constants.
 451     if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
 452       return false;
 453
 454     // (Pieces of) aggregate types that get hacked apart by SROA may be
 455     // represented by a constant. Encode them as unsigned bytes.
 456     return true;
 457   }
 458
 459   if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
 460     dwarf::Tag T = (dwarf::Tag)Ty->getTag();
 461     // Encode pointer constants as unsigned bytes. This is used at least for
 462     // null pointer constant emission.
 463     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
 464     // here, but accept them for now due to a bug in SROA producing bogus
 465     // dbg.values.
 466     if (T == dwarf::DW_TAG_pointer_type ||
 467         T == dwarf::DW_TAG_ptr_to_member_type ||
 468         T == dwarf::DW_TAG_reference_type ||
 469         T == dwarf::DW_TAG_rvalue_reference_type)
 470       return true;
 471     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 472            T == dwarf::DW_TAG_volatile_type ||
 473            T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
 474     assert(DTy->getBaseType() && "Expected valid base type");
 475     return isUnsignedDIType(DD, DTy->getBaseType());
 476   }
 477
 478   auto *BTy = cast<DIBasicType>(Ty);
 479   unsigned Encoding = BTy->getEncoding();
 480   assert((Encoding == dwarf::DW_ATE_unsigned ||
 481           Encoding == dwarf::DW_ATE_unsigned_char ||
 482           Encoding == dwarf::DW_ATE_signed ||
 483           Encoding == dwarf::DW_ATE_signed_char ||
 484           Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
 485           Encoding == dwarf::DW_ATE_boolean ||
 486           (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
 487            Ty->getName() == "decltype(nullptr)")) &&
 488          "Unsupported encoding");
 489   return Encoding == dwarf::DW_ATE_unsigned ||
 490          Encoding == dwarf::DW_ATE_unsigned_char ||
 491          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 492          Ty->getTag() == dwarf::DW_TAG_unspecified_type;
 493 }
 494
 495 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 496   assert(MO.isFPImm() && "Invalid machine operand!");
 497   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 498   APFloat FPImm = MO.getFPImm()->getValueAPF();
 499
 500   // Get the raw data form of the floating point.
 501   const APInt FltVal = FPImm.bitcastToAPInt();
 502   const char *FltPtr = (const char *)FltVal.getRawData();
 503
 504   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 505   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 506   int Incr = (LittleEndian ? 1 : -1);
 507   int Start = (LittleEndian ? 0 : NumBytes - 1);
 508   int Stop = (LittleEndian ? NumBytes : -1);
 509
 510   // Output the constant to DWARF one byte at a time.
 511   for (; Start != Stop; Start += Incr)
 512     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 513
 514   addBlock(Die, dwarf::DW_AT_const_value, Block);
 515 }
 516
 517 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 518   // Pass this down to addConstantValue as an unsigned bag of bits.
 519   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 520 }
 521
 522 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 523                                  const DIType *Ty) {
 524   addConstantValue(Die, CI->getValue(), Ty);
 525 }
 526
 527 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 528                                  const DIType *Ty) {
 529   assert(MO.isImm() && "Invalid machine operand!");
 530
 531   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 532 }
 533
 534 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 535   // FIXME: This is a bit conservative/simple - it emits negative values always
 536   // sign extended to 64 bits rather than minimizing the number of bytes.
 537   addUInt(Die, dwarf::DW_AT_const_value,
 538           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 539 }
 540
 541 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
 542   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 543 }
 544
 545 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 546   unsigned CIBitWidth = Val.getBitWidth();
 547   if (CIBitWidth <= 64) {
 548     addConstantValue(Die, Unsigned,
 549                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 550     return;
 551   }
 552
 553   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 554
 555   // Get the raw data form of the large APInt.
 556   const uint64_t *Ptr64 = Val.getRawData();
 557
 558   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 559   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 560
 561   // Output the constant to DWARF one byte at a time.
 562   for (int i = 0; i < NumBytes; i++) {
 563     uint8_t c;
 564     if (LittleEndian)
 565       c = Ptr64[i / 8] >> (8 * (i & 7));
 566     else
 567       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 568     addUInt(*Block, dwarf::DW_FORM_data1, c);
 569   }
 570
 571   addBlock(Die, dwarf::DW_AT_const_value, Block);
 572 }
 573
 574 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
 575   if (!LinkageName.empty())
 576     addString(Die,
 577               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
 578                                          : dwarf::DW_AT_MIPS_linkage_name,
 579               GlobalValue::dropLLVMManglingEscape(LinkageName));
 580 }
 581
 582 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
 583   // Add template parameters.
 584   for (const auto *Element : TParams) {
 585     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
 586       constructTemplateTypeParameterDIE(Buffer, TTP);
 587     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
 588       constructTemplateValueParameterDIE(Buffer, TVP);
 589   }
 590 }
 591
 592 /// Add thrown types.
 593 void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
 594   for (const auto *Ty : ThrownTypes) {
 595     DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
 596     addType(TT, cast<DIType>(Ty));
 597   }
 598 }
 599
 600 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
 601   if (!Context || isa<DIFile>(Context))
 602     return &getUnitDie();
 603   if (auto *T = dyn_cast<DIType>(Context))
 604     return getOrCreateTypeDIE(T);
 605   if (auto *NS = dyn_cast<DINamespace>(Context))
 606     return getOrCreateNameSpace(NS);
 607   if (auto *SP = dyn_cast<DISubprogram>(Context))
 608     return getOrCreateSubprogramDIE(SP);
 609   if (auto *M = dyn_cast<DIModule>(Context))
 610     return getOrCreateModule(M);
 611   return getDIE(Context);
 612 }
 613
 614 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
 615   auto *Context = Ty->getScope();
 616   DIE *ContextDIE = getOrCreateContextDIE(Context);
 617
 618   if (DIE *TyDIE = getDIE(Ty))
 619     return TyDIE;
 620
 621   // Create new type.
 622   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 623
 624   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
 625
 626   updateAcceleratorTables(Context, Ty, TyDIE);
 627   return &TyDIE;
 628 }
 629
 630 DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
 631                               const DIType *Ty) {
 632   // Create new type.
 633   DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty);
 634
 635   updateAcceleratorTables(Context, Ty, TyDIE);
 636
 637   if (auto *BT = dyn_cast<DIBasicType>(Ty))
 638     constructTypeDIE(TyDIE, BT);
 639   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
 640     constructTypeDIE(TyDIE, STy);
 641   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 642     if (DD->generateTypeUnits() && !Ty->isForwardDecl()) {
 643       // Skip updating the accelerator tables since this is not the full type.
 644       if (MDString *TypeId = CTy->getRawIdentifier())
 645         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 646       else {
 647         auto X = DD->enterNonTypeUnitContext();
 648         finishNonUnitTypeDIE(TyDIE, CTy);
 649       }
 650       return &TyDIE;
 651     }
 652     constructTypeDIE(TyDIE, CTy);
 653   } else {
 654     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
 655   }
 656
 657   return &TyDIE;
 658 }
 659
 660 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 661   if (!TyNode)
 662     return nullptr;
 663
 664   auto *Ty = cast<DIType>(TyNode);
 665
 666   // DW_TAG_restrict_type is not supported in DWARF2
 667   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 668     return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
 669
 670   // DW_TAG_atomic_type is not supported in DWARF < 5
 671   if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
 672     return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
 673
 674   // Construct the context before querying for the existence of the DIE in case
 675   // such construction creates the DIE.
 676   auto *Context = Ty->getScope();
 677   DIE *ContextDIE = getOrCreateContextDIE(Context);
 678   assert(ContextDIE);
 679
 680   if (DIE *TyDIE = getDIE(Ty))
 681     return TyDIE;
 682
 683   return static_cast<DwarfUnit *>(ContextDIE->getUnit())
 684       ->createTypeDIE(Context, *ContextDIE, Ty);
 685 }
 686
 687 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
 688                                         const DIType *Ty, const DIE &TyDIE) {
 689   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
 690     bool IsImplementation = false;
 691     if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
 692       // A runtime language of 0 actually means C/C++ and that any
 693       // non-negative value is some version of Objective-C/C++.
 694       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
 695     }
 696     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 697     DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags);
 698
 699     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
 700         isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
 701       addGlobalType(Ty, TyDIE, Context);
 702   }
 703 }
 704
 705 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
 706                         dwarf::Attribute Attribute) {
 707   assert(Ty && "Trying to add a type that doesn't exist?");
 708   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
 709 }
 710
 711 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
 712   if (!Context)
 713     return "";
 714
 715   // FIXME: Decide whether to implement this for non-C++ languages.
 716   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 717     return "";
 718
 719   std::string CS;
 720   SmallVector<const DIScope *, 1> Parents;
 721   while (!isa<DICompileUnit>(Context)) {
 722     Parents.push_back(Context);
 723     if (const DIScope *S = Context->getScope())
 724       Context = S;
 725     else
 726       // Structure, etc types will have a NULL context if they're at the top
 727       // level.
 728       break;
 729   }
 730
 731   // Reverse iterate over our list to go from the outermost construct to the
 732   // innermost.
 733   for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
 734     StringRef Name = Ctx->getName();
 735     if (Name.empty() && isa<DINamespace>(Ctx))
 736       Name = "(anonymous namespace)";
 737     if (!Name.empty()) {
 738       CS += Name;
 739       CS += "::";
 740     }
 741   }
 742   return CS;
 743 }
 744
 745 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
 746   // Get core information.
 747   StringRef Name = BTy->getName();
 748   // Add name if not anonymous or intermediate type.
 749   if (!Name.empty())
 750     addString(Buffer, dwarf::DW_AT_name, Name);
 751
 752   // An unspecified type only has a name attribute.
 753   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
 754     return;
 755
 756   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 757           BTy->getEncoding());
 758
 759   uint64_t Size = BTy->getSizeInBits() >> 3;
 760   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 761
 762   if (BTy->isBigEndian())
 763     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big);
 764   else if (BTy->isLittleEndian())
 765     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
 766 }
 767
 768 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
 769   // Get core information.
 770   StringRef Name = DTy->getName();
 771   uint64_t Size = DTy->getSizeInBits() >> 3;
 772   uint16_t Tag = Buffer.getTag();
 773
 774   // Map to main type, void will not have a type.
 775   const DIType *FromTy = DTy->getBaseType();
 776   if (FromTy)
 777     addType(Buffer, FromTy);
 778
 779   // Add name if not anonymous or intermediate type.
 780   if (!Name.empty())
 781     addString(Buffer, dwarf::DW_AT_name, Name);
 782
 783   // Add size if non-zero (derived types might be zero-sized.)
 784   if (Size && Tag != dwarf::DW_TAG_pointer_type
 785            && Tag != dwarf::DW_TAG_ptr_to_member_type
 786            && Tag != dwarf::DW_TAG_reference_type
 787            && Tag != dwarf::DW_TAG_rvalue_reference_type)
 788     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 789
 790   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 791     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 792                 *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType()));
 793   // Add source line info if available and TyDesc is not a forward declaration.
 794   if (!DTy->isForwardDecl())
 795     addSourceLine(Buffer, DTy);
 796
 797   // If DWARF address space value is other than None, add it.  The IR
 798   // verifier checks that DWARF address space only exists for pointer
 799   // or reference types.
 800   if (DTy->getDWARFAddressSpace())
 801     addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
 802             DTy->getDWARFAddressSpace().getValue());
 803 }
 804
 805 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
 806   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 807     const DIType *Ty = Args[i];
 808     if (!Ty) {
 809       assert(i == N-1 && "Unspecified parameter must be the last argument");
 810       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 811     } else {
 812       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 813       addType(Arg, Ty);
 814       if (Ty->isArtificial())
 815         addFlag(Arg, dwarf::DW_AT_artificial);
 816     }
 817   }
 818 }
 819
 820 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 821   // Add return type.  A void return won't have a type.
 822   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
 823   if (Elements.size())
 824     if (auto RTy = Elements[0])
 825       addType(Buffer, RTy);
 826
 827   bool isPrototyped = true;
 828   if (Elements.size() == 2 && !Elements[1])
 829     isPrototyped = false;
 830
 831   constructSubprogramArguments(Buffer, Elements);
 832
 833   // Add prototype flag if we're dealing with a C language and the function has
 834   // been prototyped.
 835   uint16_t Language = getLanguage();
 836   if (isPrototyped &&
 837       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
 838        Language == dwarf::DW_LANG_ObjC))
 839     addFlag(Buffer, dwarf::DW_AT_prototyped);
 840
 841   // Add a DW_AT_calling_convention if this has an explicit convention.
 842   if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
 843     addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
 844             CTy->getCC());
 845
 846   if (CTy->isLValueReference())
 847     addFlag(Buffer, dwarf::DW_AT_reference);
 848
 849   if (CTy->isRValueReference())
 850     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 851 }
 852
 853 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
 854   // Add name if not anonymous or intermediate type.
 855   StringRef Name = CTy->getName();
 856
 857   uint64_t Size = CTy->getSizeInBits() >> 3;
 858   uint16_t Tag = Buffer.getTag();
 859
 860   switch (Tag) {
 861   case dwarf::DW_TAG_array_type:
 862     constructArrayTypeDIE(Buffer, CTy);
 863     break;
 864   case dwarf::DW_TAG_enumeration_type:
 865     constructEnumTypeDIE(Buffer, CTy);
 866     break;
 867   case dwarf::DW_TAG_variant_part:
 868   case dwarf::DW_TAG_structure_type:
 869   case dwarf::DW_TAG_union_type:
 870   case dwarf::DW_TAG_class_type: {
 871     // Emit the discriminator for a variant part.
 872     DIDerivedType *Discriminator = nullptr;
 873     if (Tag == dwarf::DW_TAG_variant_part) {
 874       Discriminator = CTy->getDiscriminator();
 875       if (Discriminator) {
 876         // DWARF says:
 877         //    If the variant part has a discriminant, the discriminant is
 878         //    represented by a separate debugging information entry which is
 879         //    a child of the variant part entry.
 880         DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
 881         addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
 882       }
 883     }
 884
 885     // Add elements to structure type.
 886     DINodeArray Elements = CTy->getElements();
 887     for (const auto *Element : Elements) {
 888       if (!Element)
 889         continue;
 890       if (auto *SP = dyn_cast<DISubprogram>(Element))
 891         getOrCreateSubprogramDIE(SP);
 892       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
 893         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
 894           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
 895           addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
 896         } else if (DDTy->isStaticMember()) {
 897           getOrCreateStaticMemberDIE(DDTy);
 898         } else if (Tag == dwarf::DW_TAG_variant_part) {
 899           // When emitting a variant part, wrap each member in
 900           // DW_TAG_variant.
 901           DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
 902           if (const ConstantInt *CI =
 903               dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
 904             if (isUnsignedDIType(DD, Discriminator->getBaseType()))
 905               addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
 906             else
 907               addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
 908           }
 909           constructMemberDIE(Variant, DDTy);
 910         } else {
 911           constructMemberDIE(Buffer, DDTy);
 912         }
 913       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
 914         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
 915         StringRef PropertyName = Property->getName();
 916         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 917         if (Property->getType())
 918           addType(ElemDie, Property->getType());
 919         addSourceLine(ElemDie, Property);
 920         StringRef GetterName = Property->getGetterName();
 921         if (!GetterName.empty())
 922           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 923         StringRef SetterName = Property->getSetterName();
 924         if (!SetterName.empty())
 925           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 926         if (unsigned PropertyAttributes = Property->getAttributes())
 927           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
 928                   PropertyAttributes);
 929       } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
 930         if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
 931           DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
 932           constructTypeDIE(VariantPart, Composite);
 933         }
 934       }
 935     }
 936
 937     if (CTy->isAppleBlockExtension())
 938       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 939
 940     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
 941     // inside C++ composite types to point to the base class with the vtable.
 942     // Rust uses DW_AT_containing_type to link a vtable to the type
 943     // for which it was created.
 944     if (auto *ContainingType = CTy->getVTableHolder())
 945       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 946                   *getOrCreateTypeDIE(ContainingType));
 947
 948     if (CTy->isObjcClassComplete())
 949       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 950
 951     // Add template parameters to a class, structure or union types.
 952     // FIXME: The support isn't in the metadata for this yet.
 953     if (Tag == dwarf::DW_TAG_class_type ||
 954         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 955       addTemplateParams(Buffer, CTy->getTemplateParams());
 956
 957     // Add the type's non-standard calling convention.
 958     uint8_t CC = 0;
 959     if (CTy->isTypePassByValue())
 960       CC = dwarf::DW_CC_pass_by_value;
 961     else if (CTy->isTypePassByReference())
 962       CC = dwarf::DW_CC_pass_by_reference;
 963     if (CC)
 964       addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
 965               CC);
 966     break;
 967   }
 968   default:
 969     break;
 970   }
 971
 972   // Add name if not anonymous or intermediate type.
 973   if (!Name.empty())
 974     addString(Buffer, dwarf::DW_AT_name, Name);
 975
 976   if (Tag == dwarf::DW_TAG_enumeration_type ||
 977       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
 978       Tag == dwarf::DW_TAG_union_type) {
 979     // Add size if non-zero (derived types might be zero-sized.)
 980     // TODO: Do we care about size for enum forward declarations?
 981     if (Size)
 982       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 983     else if (!CTy->isForwardDecl())
 984       // Add zero size if it is not a forward declaration.
 985       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
 986
 987     // If we're a forward decl, say so.
 988     if (CTy->isForwardDecl())
 989       addFlag(Buffer, dwarf::DW_AT_declaration);
 990
 991     // Add source line info if available.
 992     if (!CTy->isForwardDecl())
 993       addSourceLine(Buffer, CTy);
 994
 995     // No harm in adding the runtime language to the declaration.
 996     unsigned RLang = CTy->getRuntimeLang();
 997     if (RLang)
 998       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
 999               RLang);
1000
1001     // Add align info if available.
1002     if (uint32_t AlignInBytes = CTy->getAlignInBytes())
1003       addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1004               AlignInBytes);
1005   }
1006 }
1007
1008 void DwarfUnit::constructTemplateTypeParameterDIE(
1009     DIE &Buffer, const DITemplateTypeParameter *TP) {
1010   DIE &ParamDIE =
1011       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1012   // Add the type if it exists, it could be void and therefore no type.
1013   if (TP->getType())
1014     addType(ParamDIE, TP->getType());
1015   if (!TP->getName().empty())
1016     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1017 }
1018
1019 void DwarfUnit::constructTemplateValueParameterDIE(
1020     DIE &Buffer, const DITemplateValueParameter *VP) {
1021   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1022
1023   // Add the type if there is one, template template and template parameter
1024   // packs will not have a type.
1025   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1026     addType(ParamDIE, VP->getType());
1027   if (!VP->getName().empty())
1028     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1029   if (Metadata *Val = VP->getValue()) {
1030     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1031       addConstantValue(ParamDIE, CI, VP->getType());
1032     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1033       // We cannot describe the location of dllimport'd entities: the
1034       // computation of their address requires loads from the IAT.
1035       if (!GV->hasDLLImportStorageClass()) {
1036         // For declaration non-type template parameters (such as global values
1037         // and functions)
1038         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1039         addOpAddress(*Loc, Asm->getSymbol(GV));
1040         // Emit DW_OP_stack_value to use the address as the immediate value of
1041         // the parameter, rather than a pointer to it.
1042         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1043         addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1044       }
1045     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1046       assert(isa<MDString>(Val));
1047       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1048                 cast<MDString>(Val)->getString());
1049     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1050       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1051     }
1052   }
1053 }
1054
1055 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1056   // Construct the context before querying for the existence of the DIE in case
1057   // such construction creates the DIE.
1058   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1059
1060   if (DIE *NDie = getDIE(NS))
1061     return NDie;
1062   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1063
1064   StringRef Name = NS->getName();
1065   if (!Name.empty())
1066     addString(NDie, dwarf::DW_AT_name, NS->getName());
1067   else
1068     Name = "(anonymous namespace)";
1069   DD->addAccelNamespace(*CUNode, Name, NDie);
1070   addGlobalName(Name, NDie, NS->getScope());
1071   if (NS->getExportSymbols())
1072     addFlag(NDie, dwarf::DW_AT_export_symbols);
1073   return &NDie;
1074 }
1075
1076 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1077   // Construct the context before querying for the existence of the DIE in case
1078   // such construction creates the DIE.
1079   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1080
1081   if (DIE *MDie = getDIE(M))
1082     return MDie;
1083   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1084
1085   if (!M->getName().empty()) {
1086     addString(MDie, dwarf::DW_AT_name, M->getName());
1087     addGlobalName(M->getName(), MDie, M->getScope());
1088   }
1089   if (!M->getConfigurationMacros().empty())
1090     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1091               M->getConfigurationMacros());
1092   if (!M->getIncludePath().empty())
1093     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1094   if (!M->getISysRoot().empty())
1095     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
1096
1097   return &MDie;
1098 }
1099
1100 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1101   // Construct the context before querying for the existence of the DIE in case
1102   // such construction creates the DIE (as is the case for member function
1103   // declarations).
1104   DIE *ContextDIE =
1105       Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope());
1106
1107   if (DIE *SPDie = getDIE(SP))
1108     return SPDie;
1109
1110   if (auto *SPDecl = SP->getDeclaration()) {
1111     if (!Minimal) {
1112       // Add subprogram definitions to the CU die directly.
1113       ContextDIE = &getUnitDie();
1114       // Build the decl now to ensure it precedes the definition.
1115       getOrCreateSubprogramDIE(SPDecl);
1116     }
1117   }
1118
1119   // DW_TAG_inlined_subroutine may refer to this DIE.
1120   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1121
1122   // Stop here and fill this in later, depending on whether or not this
1123   // subprogram turns out to have inlined instances or not.
1124   if (SP->isDefinition())
1125     return &SPDie;
1126
1127   static_cast<DwarfUnit *>(SPDie.getUnit())
1128       ->applySubprogramAttributes(SP, SPDie);
1129   return &SPDie;
1130 }
1131
1132 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1133                                                     DIE &SPDie) {
1134   DIE *DeclDie = nullptr;
1135   StringRef DeclLinkageName;
1136   if (auto *SPDecl = SP->getDeclaration()) {
1137     DeclDie = getDIE(SPDecl);
1138     assert(DeclDie && "This DIE should've already been constructed when the "
1139                       "definition DIE was created in "
1140                       "getOrCreateSubprogramDIE");
1141     // Look at the Decl's linkage name only if we emitted it.
1142     if (DD->useAllLinkageNames())
1143       DeclLinkageName = SPDecl->getLinkageName();
1144     unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1145     unsigned DefID = getOrCreateSourceID(SP->getFile());
1146     if (DeclID != DefID)
1147       addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1148
1149     if (SP->getLine() != SPDecl->getLine())
1150       addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1151   }
1152
1153   // Add function template parameters.
1154   addTemplateParams(SPDie, SP->getTemplateParams());
1155
1156   // Add the linkage name if we have one and it isn't in the Decl.
1157   StringRef LinkageName = SP->getLinkageName();
1158   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1159           LinkageName == DeclLinkageName) &&
1160          "decl has a linkage name and it is different");
1161   if (DeclLinkageName.empty() &&
1162       // Always emit it for abstract subprograms.
1163       (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1164     addLinkageName(SPDie, LinkageName);
1165
1166   if (!DeclDie)
1167     return false;
1168
1169   // Refer to the function declaration where all the other attributes will be
1170   // found.
1171   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1172   return true;
1173 }
1174
1175 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1176                                           bool SkipSPAttributes) {
1177   // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1178   // and its source location.
1179   bool SkipSPSourceLocation = SkipSPAttributes &&
1180                               !CUNode->getDebugInfoForProfiling();
1181   if (!SkipSPSourceLocation)
1182     if (applySubprogramDefinitionAttributes(SP, SPDie))
1183       return;
1184
1185   // Constructors and operators for anonymous aggregates do not have names.
1186   if (!SP->getName().empty())
1187     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1188
1189   if (!SkipSPSourceLocation)
1190     addSourceLine(SPDie, SP);
1191
1192   // Skip the rest of the attributes under -gmlt to save space.
1193   if (SkipSPAttributes)
1194     return;
1195
1196   // Add the prototype if we have a prototype and we have a C like
1197   // language.
1198   uint16_t Language = getLanguage();
1199   if (SP->isPrototyped() &&
1200       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1201        Language == dwarf::DW_LANG_ObjC))
1202     addFlag(SPDie, dwarf::DW_AT_prototyped);
1203
1204   unsigned CC = 0;
1205   DITypeRefArray Args;
1206   if (const DISubroutineType *SPTy = SP->getType()) {
1207     Args = SPTy->getTypeArray();
1208     CC = SPTy->getCC();
1209   }
1210
1211   // Add a DW_AT_calling_convention if this has an explicit convention.
1212   if (CC && CC != dwarf::DW_CC_normal)
1213     addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1214
1215   // Add a return type. If this is a type like a C/C++ void type we don't add a
1216   // return type.
1217   if (Args.size())
1218     if (auto Ty = Args[0])
1219       addType(SPDie, Ty);
1220
1221   unsigned VK = SP->getVirtuality();
1222   if (VK) {
1223     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1224     if (SP->getVirtualIndex() != -1u) {
1225       DIELoc *Block = getDIELoc();
1226       addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1227       addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1228       addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1229     }
1230     ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType()));
1231   }
1232
1233   if (!SP->isDefinition()) {
1234     addFlag(SPDie, dwarf::DW_AT_declaration);
1235
1236     // Add arguments. Do not add arguments for subprogram definition. They will
1237     // be handled while processing variables.
1238     constructSubprogramArguments(SPDie, Args);
1239   }
1240
1241   addThrownTypes(SPDie, SP->getThrownTypes());
1242
1243   if (SP->isArtificial())
1244     addFlag(SPDie, dwarf::DW_AT_artificial);
1245
1246   if (!SP->isLocalToUnit())
1247     addFlag(SPDie, dwarf::DW_AT_external);
1248
1249   if (DD->useAppleExtensionAttributes()) {
1250     if (SP->isOptimized())
1251       addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1252
1253     if (unsigned isa = Asm->getISAEncoding())
1254       addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1255   }
1256
1257   if (SP->isLValueReference())
1258     addFlag(SPDie, dwarf::DW_AT_reference);
1259
1260   if (SP->isRValueReference())
1261     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1262
1263   if (SP->isNoReturn())
1264     addFlag(SPDie, dwarf::DW_AT_noreturn);
1265
1266   if (SP->isProtected())
1267     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1268             dwarf::DW_ACCESS_protected);
1269   else if (SP->isPrivate())
1270     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1271             dwarf::DW_ACCESS_private);
1272   else if (SP->isPublic())
1273     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1274             dwarf::DW_ACCESS_public);
1275
1276   if (SP->isExplicit())
1277     addFlag(SPDie, dwarf::DW_AT_explicit);
1278
1279   if (SP->isMainSubprogram())
1280     addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1281   if (SP->isPure())
1282     addFlag(SPDie, dwarf::DW_AT_pure);
1283   if (SP->isElemental())
1284     addFlag(SPDie, dwarf::DW_AT_elemental);
1285   if (SP->isRecursive())
1286     addFlag(SPDie, dwarf::DW_AT_recursive);
1287 }
1288
1289 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1290                                      DIE *IndexTy) {
1291   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1292   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1293
1294   // The LowerBound value defines the lower bounds which is typically zero for
1295   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1296   // Count == -1 then the array is unbounded and we do not emit
1297   // DW_AT_lower_bound and DW_AT_count attributes.
1298   int64_t LowerBound = SR->getLowerBound();
1299   int64_t DefaultLowerBound = getDefaultLowerBound();
1300   int64_t Count = -1;
1301   if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
1302     Count = CI->getSExtValue();
1303
1304   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1305     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1306
1307   if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
1308     if (auto *CountVarDIE = getDIE(CV))
1309       addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE);
1310   } else if (Count != -1)
1311     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1312 }
1313
1314 DIE *DwarfUnit::getIndexTyDie() {
1315   if (IndexTyDie)
1316     return IndexTyDie;
1317   // Construct an integer type to use for indexes.
1318   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1319   StringRef Name = "__ARRAY_SIZE_TYPE__";
1320   addString(*IndexTyDie, dwarf::DW_AT_name, Name);
1321   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1322   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1323           dwarf::DW_ATE_unsigned);
1324   DD->addAccelType(*CUNode, Name, *IndexTyDie, /*Flags*/ 0);
1325   return IndexTyDie;
1326 }
1327
1328 /// Returns true if the vector's size differs from the sum of sizes of elements
1329 /// the user specified.  This can occur if the vector has been rounded up to
1330 /// fit memory alignment constraints.
1331 static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1332   assert(CTy && CTy->isVector() && "Composite type is not a vector");
1333   const uint64_t ActualSize = CTy->getSizeInBits();
1334
1335   // Obtain the size of each element in the vector.
1336   DIType *BaseTy = CTy->getBaseType();
1337   assert(BaseTy && "Unknown vector element type.");
1338   const uint64_t ElementSize = BaseTy->getSizeInBits();
1339
1340   // Locate the number of elements in the vector.
1341   const DINodeArray Elements = CTy->getElements();
1342   assert(Elements.size() == 1 &&
1343          Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1344          "Invalid vector element array, expected one element of type subrange");
1345   const auto Subrange = cast<DISubrange>(Elements[0]);
1346   const auto CI = Subrange->getCount().get<ConstantInt *>();
1347   const int32_t NumVecElements = CI->getSExtValue();
1348
1349   // Ensure we found the element count and that the actual size is wide
1350   // enough to contain the requested size.
1351   assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
1352   return ActualSize != (NumVecElements * ElementSize);
1353 }
1354
1355 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1356   if (CTy->isVector()) {
1357     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1358     if (hasVectorBeenPadded(CTy))
1359       addUInt(Buffer, dwarf::DW_AT_byte_size, None,
1360               CTy->getSizeInBits() / CHAR_BIT);
1361   }
1362
1363   // Emit the element type.
1364   addType(Buffer, CTy->getBaseType());
1365
1366   // Get an anonymous type for index type.
1367   // FIXME: This type should be passed down from the front end
1368   // as different languages may have different sizes for indexes.
1369   DIE *IdxTy = getIndexTyDie();
1370
1371   // Add subranges to array type.
1372   DINodeArray Elements = CTy->getElements();
1373   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1374     // FIXME: Should this really be such a loose cast?
1375     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1376       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1377         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1378   }
1379 }
1380
1381 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1382   const DIType *DTy = CTy->getBaseType();
1383   bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
1384   if (DTy) {
1385     if (DD->getDwarfVersion() >= 3)
1386       addType(Buffer, DTy);
1387     if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
1388       addFlag(Buffer, dwarf::DW_AT_enum_class);
1389   }
1390
1391   DINodeArray Elements = CTy->getElements();
1392
1393   // Add enumerators to enumeration type.
1394   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1395     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1396     if (Enum) {
1397       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1398       StringRef Name = Enum->getName();
1399       addString(Enumerator, dwarf::DW_AT_name, Name);
1400       auto Value = static_cast<uint64_t>(Enum->getValue());
1401       addConstantValue(Enumerator, IsUnsigned, Value);
1402     }
1403   }
1404 }
1405
1406 void DwarfUnit::constructContainingTypeDIEs() {
1407   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1408        CI != CE; ++CI) {
1409     DIE &SPDie = *CI->first;
1410     const DINode *D = CI->second;
1411     if (!D)
1412       continue;
1413     DIE *NDie = getDIE(D);
1414     if (!NDie)
1415       continue;
1416     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1417   }
1418 }
1419
1420 DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1421   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1422   StringRef Name = DT->getName();
1423   if (!Name.empty())
1424     addString(MemberDie, dwarf::DW_AT_name, Name);
1425
1426   if (DIType *Resolved = DT->getBaseType())
1427     addType(MemberDie, Resolved);
1428
1429   addSourceLine(MemberDie, DT);
1430
1431   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1432
1433     // For C++, virtual base classes are not at fixed offset. Use following
1434     // expression to extract appropriate offset from vtable.
1435     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1436
1437     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1438     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1439     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1440     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1441     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1442     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1443     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1444     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1445
1446     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1447   } else {
1448     uint64_t Size = DT->getSizeInBits();
1449     uint64_t FieldSize = DD->getBaseTypeSize(DT);
1450     uint32_t AlignInBytes = DT->getAlignInBytes();
1451     uint64_t OffsetInBytes;
1452
1453     bool IsBitfield = FieldSize && Size != FieldSize;
1454     if (IsBitfield) {
1455       // Handle bitfield, assume bytes are 8 bits.
1456       if (DD->useDWARF2Bitfields())
1457         addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1458       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1459
1460       uint64_t Offset = DT->getOffsetInBits();
1461       // We can't use DT->getAlignInBits() here: AlignInBits for member type
1462       // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1463       // which can't be done with bitfields. Thus we use FieldSize here.
1464       uint32_t AlignInBits = FieldSize;
1465       uint32_t AlignMask = ~(AlignInBits - 1);
1466       // The bits from the start of the storage unit to the start of the field.
1467       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1468       // The byte offset of the field's aligned storage unit inside the struct.
1469       OffsetInBytes = (Offset - StartBitOffset) / 8;
1470
1471       if (DD->useDWARF2Bitfields()) {
1472         uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1473         uint64_t FieldOffset = (HiMark - FieldSize);
1474         Offset -= FieldOffset;
1475
1476         // Maybe we need to work from the other end.
1477         if (Asm->getDataLayout().isLittleEndian())
1478           Offset = FieldSize - (Offset + Size);
1479
1480         addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1481         OffsetInBytes = FieldOffset >> 3;
1482       } else {
1483         addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1484       }
1485     } else {
1486       // This is not a bitfield.
1487       OffsetInBytes = DT->getOffsetInBits() / 8;
1488       if (AlignInBytes)
1489         addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1490                 AlignInBytes);
1491     }
1492
1493     if (DD->getDwarfVersion() <= 2) {
1494       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1495       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1496       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1497       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1498     } else if (!IsBitfield || DD->useDWARF2Bitfields())
1499       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1500               OffsetInBytes);
1501   }
1502
1503   if (DT->isProtected())
1504     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1505             dwarf::DW_ACCESS_protected);
1506   else if (DT->isPrivate())
1507     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1508             dwarf::DW_ACCESS_private);
1509   // Otherwise C++ member and base classes are considered public.
1510   else if (DT->isPublic())
1511     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1512             dwarf::DW_ACCESS_public);
1513   if (DT->isVirtual())
1514     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1515             dwarf::DW_VIRTUALITY_virtual);
1516
1517   // Objective-C properties.
1518   if (DINode *PNode = DT->getObjCProperty())
1519     if (DIE *PDie = getDIE(PNode))
1520       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
1521                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1522
1523   if (DT->isArtificial())
1524     addFlag(MemberDie, dwarf::DW_AT_artificial);
1525
1526   return MemberDie;
1527 }
1528
1529 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1530   if (!DT)
1531     return nullptr;
1532
1533   // Construct the context before querying for the existence of the DIE in case
1534   // such construction creates the DIE.
1535   DIE *ContextDIE = getOrCreateContextDIE(DT->getScope());
1536   assert(dwarf::isType(ContextDIE->getTag()) &&
1537          "Static member should belong to a type.");
1538
1539   if (DIE *StaticMemberDIE = getDIE(DT))
1540     return StaticMemberDIE;
1541
1542   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1543
1544   const DIType *Ty = DT->getBaseType();
1545
1546   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1547   addType(StaticMemberDIE, Ty);
1548   addSourceLine(StaticMemberDIE, DT);
1549   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1550   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1551
1552   // FIXME: We could omit private if the parent is a class_type, and
1553   // public if the parent is something else.
1554   if (DT->isProtected())
1555     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1556             dwarf::DW_ACCESS_protected);
1557   else if (DT->isPrivate())
1558     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1559             dwarf::DW_ACCESS_private);
1560   else if (DT->isPublic())
1561     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562             dwarf::DW_ACCESS_public);
1563
1564   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1565     addConstantValue(StaticMemberDIE, CI, Ty);
1566   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1567     addConstantFPValue(StaticMemberDIE, CFP);
1568
1569   if (uint32_t AlignInBytes = DT->getAlignInBytes())
1570     addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1571             AlignInBytes);
1572
1573   return &StaticMemberDIE;
1574 }
1575
1576 void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
1577   // Emit size of content not including length itself
1578   Asm->OutStreamer->AddComment("Length of Unit");
1579   if (!DD->useSectionsAsReferences()) {
1580     StringRef Prefix = isDwoUnit() ? "debug_info_dwo_" : "debug_info_";
1581     MCSymbol *BeginLabel = Asm->createTempSymbol(Prefix + "start");
1582     EndLabel = Asm->createTempSymbol(Prefix + "end");
1583     Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1584     Asm->OutStreamer->EmitLabel(BeginLabel);
1585   } else
1586     Asm->emitInt32(getHeaderSize() + getUnitDie().getSize());
1587
1588   Asm->OutStreamer->AddComment("DWARF version number");
1589   unsigned Version = DD->getDwarfVersion();
1590   Asm->emitInt16(Version);
1591
1592   // DWARF v5 reorders the address size and adds a unit type.
1593   if (Version >= 5) {
1594     Asm->OutStreamer->AddComment("DWARF Unit Type");
1595     Asm->emitInt8(UT);
1596     Asm->OutStreamer->AddComment("Address Size (in bytes)");
1597     Asm->emitInt8(Asm->MAI->getCodePointerSize());
1598   }
1599
1600   // We share one abbreviations table across all units so it's always at the
1601   // start of the section. Use a relocatable offset where needed to ensure
1602   // linking doesn't invalidate that offset.
1603   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1604   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1605   if (UseOffsets)
1606     Asm->emitInt32(0);
1607   else
1608     Asm->emitDwarfSymbolReference(
1609         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1610
1611   if (Version <= 4) {
1612     Asm->OutStreamer->AddComment("Address Size (in bytes)");
1613     Asm->emitInt8(Asm->MAI->getCodePointerSize());
1614   }
1615 }
1616
1617 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1618   DwarfUnit::emitCommonHeader(UseOffsets,
1619                               DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1620                                                   : dwarf::DW_UT_type);
1621   Asm->OutStreamer->AddComment("Type Signature");
1622   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1623   Asm->OutStreamer->AddComment("Type DIE Offset");
1624   // In a skeleton type unit there is no type DIE so emit a zero offset.
1625   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1626                                  sizeof(Ty->getOffset()));
1627 }
1628
1629 DIE::value_iterator
1630 DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
1631                            const MCSymbol *Hi, const MCSymbol *Lo) {
1632   return Die.addValue(DIEValueAllocator, Attribute,
1633                       DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1634                                                  : dwarf::DW_FORM_data4,
1635                       new (DIEValueAllocator) DIEDelta(Hi, Lo));
1636 }
1637
1638 DIE::value_iterator
1639 DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
1640                            const MCSymbol *Label, const MCSymbol *Sec) {
1641   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1642     return addLabel(Die, Attribute,
1643                     DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1644                                                : dwarf::DW_FORM_data4,
1645                     Label);
1646   return addSectionDelta(Die, Attribute, Label, Sec);
1647 }
1648
1649 bool DwarfTypeUnit::isDwoUnit() const {
1650   // Since there are no skeleton type units, all type units are dwo type units
1651   // when split DWARF is being used.
1652   return DD->useSplitDwarf();
1653 }
1654
1655 void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
1656                                   const DIScope *Context) {
1657   getCU().addGlobalNameForTypeUnit(Name, Context);
1658 }
1659
1660 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1661                                   const DIScope *Context) {
1662   getCU().addGlobalTypeUnitType(Ty, Context);
1663 }
1664
1665 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1666   if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1667     return nullptr;
1668   if (isDwoUnit())
1669     return nullptr;
1670   return getSection()->getBeginSymbol();
1671 }
1672
1673 void DwarfUnit::addStringOffsetsStart() {
1674   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1675   addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1676                   DU->getStringOffsetsStartSym(),
1677                   TLOF.getDwarfStrOffSection()->getBeginSymbol());
1678 }
1679
1680 void DwarfUnit::addRnglistsBase() {
1681   assert(DD->getDwarfVersion() >= 5 &&
1682          "DW_AT_rnglists_base requires DWARF version 5 or later");
1683   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1684   addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
1685                   DU->getRnglistsTableBaseSym(),
1686                   TLOF.getDwarfRnglistsSection()->getBeginSymbol());
1687 }
1688
1689 void DwarfUnit::addLoclistsBase() {
1690   assert(DD->getDwarfVersion() >= 5 &&
1691          "DW_AT_loclists_base requires DWARF version 5 or later");
1692   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1693   addSectionLabel(getUnitDie(), dwarf::DW_AT_loclists_base,
1694                   DU->getLoclistsTableBaseSym(),
1695                   TLOF.getDwarfLoclistsSection()->getBeginSymbol());
1696 }
1697
1698 void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1699   addFlag(D, dwarf::DW_AT_declaration);
1700   StringRef Name = CTy->getName();
1701   if (!Name.empty())
1702     addString(D, dwarf::DW_AT_name, Name);
1703   getCU().createTypeDIE(CTy);
1704 }