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