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
  16 #include "DwarfAccelTable.h"
  17 #include "DwarfCompileUnit.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/IR/Constants.h"
  21 #include "llvm/IR/DIBuilder.h"
  22 #include "llvm/IR/DataLayout.h"
  23 #include "llvm/IR/GlobalVariable.h"
  24 #include "llvm/IR/Instructions.h"
  25 #include "llvm/IR/Mangler.h"
  26 #include "llvm/MC/MCAsmInfo.h"
  27 #include "llvm/MC/MCContext.h"
  28 #include "llvm/MC/MCSection.h"
  29 #include "llvm/MC/MCStreamer.h"
  30 #include "llvm/Support/CommandLine.h"
  31 #include "llvm/Target/TargetFrameLowering.h"
  32 #include "llvm/Target/TargetLoweringObjectFile.h"
  33 #include "llvm/Target/TargetMachine.h"
  34 #include "llvm/Target/TargetRegisterInfo.h"
  35 #include "llvm/Target/TargetSubtargetInfo.h"
  36
  37 using namespace llvm;
  38
  39 #define DEBUG_TYPE "dwarfdebug"
  40
  41 static cl::opt<bool>
  42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  43                        cl::desc("Generate DWARF4 type units."),
  44                        cl::init(false));
  45
  46 /// Unit - Unit constructor.
  47 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
  48                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
  49     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
  50       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  51   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  52          UnitTag == dwarf::DW_TAG_type_unit);
  53   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  54 }
  55
  56 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
  57                              DwarfDebug *DW, DwarfFile *DWU,
  58                              MCDwarfDwoLineTable *SplitLineTable)
  59     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
  60       CU(CU), SplitLineTable(SplitLineTable) {
  61   if (SplitLineTable)
  62     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  63 }
  64
  65 /// ~Unit - Destructor for compile unit.
  66 DwarfUnit::~DwarfUnit() {
  67   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  68     DIEBlocks[j]->~DIEBlock();
  69   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  70     DIELocs[j]->~DIELoc();
  71 }
  72
  73 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  74 /// information entry.
  75 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
  76   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  77   return Value;
  78 }
  79
  80 /// getDefaultLowerBound - Return the default lower bound for an array. If the
  81 /// DWARF version doesn't handle the language, return -1.
  82 int64_t DwarfUnit::getDefaultLowerBound() const {
  83   switch (getLanguage()) {
  84   default:
  85     break;
  86
  87   case dwarf::DW_LANG_C89:
  88   case dwarf::DW_LANG_C99:
  89   case dwarf::DW_LANG_C:
  90   case dwarf::DW_LANG_C_plus_plus:
  91   case dwarf::DW_LANG_ObjC:
  92   case dwarf::DW_LANG_ObjC_plus_plus:
  93     return 0;
  94
  95   case dwarf::DW_LANG_Fortran77:
  96   case dwarf::DW_LANG_Fortran90:
  97   case dwarf::DW_LANG_Fortran95:
  98     return 1;
  99
 100   // The languages below have valid values only if the DWARF version >= 4.
 101   case dwarf::DW_LANG_Java:
 102   case dwarf::DW_LANG_Python:
 103   case dwarf::DW_LANG_UPC:
 104   case dwarf::DW_LANG_D:
 105     if (dwarf::DWARF_VERSION >= 4)
 106       return 0;
 107     break;
 108
 109   case dwarf::DW_LANG_Ada83:
 110   case dwarf::DW_LANG_Ada95:
 111   case dwarf::DW_LANG_Cobol74:
 112   case dwarf::DW_LANG_Cobol85:
 113   case dwarf::DW_LANG_Modula2:
 114   case dwarf::DW_LANG_Pascal83:
 115   case dwarf::DW_LANG_PLI:
 116     if (dwarf::DWARF_VERSION >= 4)
 117       return 1;
 118     break;
 119   }
 120
 121   return -1;
 122 }
 123
 124 /// Check whether the DIE for this MDNode can be shared across CUs.
 125 static bool isShareableAcrossCUs(DIDescriptor D) {
 126   // When the MDNode can be part of the type system, the DIE can be shared
 127   // across CUs.
 128   // Combining type units and cross-CU DIE sharing is lower value (since
 129   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 130   // level already) but may be implementable for some value in projects
 131   // building multiple independent libraries with LTO and then linking those
 132   // together.
 133   return (D.isType() ||
 134           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
 135          !GenerateDwarfTypeUnits;
 136 }
 137
 138 /// getDIE - Returns the debug information entry map slot for the
 139 /// specified debug variable. We delegate the request to DwarfDebug
 140 /// when the DIE for this MDNode can be shared across CUs. The mappings
 141 /// will be kept in DwarfDebug for shareable DIEs.
 142 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
 143   if (isShareableAcrossCUs(D))
 144     return DU->getDIE(D);
 145   return MDNodeToDieMap.lookup(D);
 146 }
 147
 148 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
 149 /// when the DIE for this MDNode can be shared across CUs. The mappings
 150 /// will be kept in DwarfDebug for shareable DIEs.
 151 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
 152   if (isShareableAcrossCUs(Desc)) {
 153     DU->insertDIE(Desc, D);
 154     return;
 155   }
 156   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 157 }
 158
 159 /// addFlag - Add a flag that is true.
 160 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 161   if (DD->getDwarfVersion() >= 4)
 162     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
 163   else
 164     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
 165 }
 166
 167 /// addUInt - Add an unsigned integer attribute data and value.
 168 ///
 169 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
 170                         Optional<dwarf::Form> Form, uint64_t Integer) {
 171   if (!Form)
 172     Form = DIEInteger::BestForm(false, Integer);
 173   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
 174                         DIEInteger(Integer);
 175   Die.addValue(Attribute, *Form, Value);
 176 }
 177
 178 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
 179   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 180 }
 181
 182 /// addSInt - Add an signed integer attribute data and value.
 183 ///
 184 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
 185                         Optional<dwarf::Form> Form, int64_t Integer) {
 186   if (!Form)
 187     Form = DIEInteger::BestForm(true, Integer);
 188   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 189   Die.addValue(Attribute, *Form, Value);
 190 }
 191
 192 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 193                         int64_t Integer) {
 194   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 195 }
 196
 197 /// addString - Add a string attribute data and value. We always emit a
 198 /// reference to the string pool instead of immediate strings so that DIEs have
 199 /// more predictable sizes. In the case of split dwarf we emit an index
 200 /// into another table which gets us the static offset into the string
 201 /// table.
 202 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 203                           StringRef String) {
 204   if (!isDwoUnit())
 205     return addLocalString(Die, Attribute, String);
 206
 207   addIndexedString(Die, Attribute, String);
 208 }
 209
 210 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
 211                                  StringRef String) {
 212   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
 213   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
 214   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 215   Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
 216 }
 217
 218 /// addLocalString - Add a string attribute data and value. This is guaranteed
 219 /// to be in the local string pool instead of indirected.
 220 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
 221                                StringRef String) {
 222   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
 223   DIEValue *Value;
 224   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 225     Value = new (DIEValueAllocator) DIELabel(Symb);
 226   else
 227     Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
 228   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 229   Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
 230 }
 231
 232 /// addLabel - Add a Dwarf label attribute data and value.
 233 ///
 234 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
 235                          const MCSymbol *Label) {
 236   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 237   Die.addValue(Attribute, Form, Value);
 238 }
 239
 240 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 241   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 242 }
 243
 244 /// addSectionOffset - Add an offset into a section attribute data and value.
 245 ///
 246 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 247                                  uint64_t Integer) {
 248   if (DD->getDwarfVersion() >= 4)
 249     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 250   else
 251     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 252 }
 253
 254 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
 255   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
 256                         : getCU().getOrCreateSourceID(FileName, DirName);
 257 }
 258
 259 /// addOpAddress - Add a dwarf op address data and value using the
 260 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
 261 ///
 262 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 263   if (!DD->useSplitDwarf()) {
 264     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 265     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 266   } else {
 267     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 268     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 269             DD->getAddressPool().getIndex(Sym));
 270   }
 271 }
 272
 273 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 274                               const MCSymbol *Hi, const MCSymbol *Lo) {
 275   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 276   Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
 277 }
 278
 279 /// addDIEEntry - Add a DIE attribute data and value.
 280 ///
 281 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 282   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
 283 }
 284
 285 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
 286   // Flag the type unit reference as a declaration so that if it contains
 287   // members (implicit special members, static data member definitions, member
 288   // declarations for definitions in this CU, etc) consumers don't get confused
 289   // and think this is a full definition.
 290   addFlag(Die, dwarf::DW_AT_declaration);
 291
 292   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
 293                new (DIEValueAllocator) DIETypeSignature(Type));
 294 }
 295
 296 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 297                             DIEEntry *Entry) {
 298   const DIE *DieCU = Die.getUnitOrNull();
 299   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
 300   if (!DieCU)
 301     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 302     DieCU = &getUnitDie();
 303   if (!EntryCU)
 304     EntryCU = &getUnitDie();
 305   Die.addValue(Attribute,
 306                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 307                Entry);
 308 }
 309
 310 /// Create a DIE with the given Tag, add the DIE to its parent, and
 311 /// call insertDIE if MD is not null.
 312 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
 313   assert(Tag != dwarf::DW_TAG_auto_variable &&
 314          Tag != dwarf::DW_TAG_arg_variable);
 315   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
 316   DIE &Die = *Parent.getChildren().back();
 317   if (N)
 318     insertDIE(N, &Die);
 319   return Die;
 320 }
 321
 322 /// addBlock - Add block data.
 323 ///
 324 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 325   Loc->ComputeSize(Asm);
 326   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 327   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
 328 }
 329
 330 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 331                          DIEBlock *Block) {
 332   Block->ComputeSize(Asm);
 333   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 334   Die.addValue(Attribute, Block->BestForm(), Block);
 335 }
 336
 337 /// addSourceLine - Add location information to specified debug information
 338 /// entry.
 339 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
 340                               StringRef Directory) {
 341   if (Line == 0)
 342     return;
 343
 344   unsigned FileID = getOrCreateSourceID(File, Directory);
 345   assert(FileID && "Invalid file id");
 346   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 347   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 348 }
 349
 350 /// addSourceLine - Add location information to specified debug information
 351 /// entry.
 352 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
 353   assert(V.isVariable());
 354
 355   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
 356                 V.getContext().getDirectory());
 357 }
 358
 359 /// addSourceLine - Add location information to specified debug information
 360 /// entry.
 361 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
 362   assert(G.isGlobalVariable());
 363
 364   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
 365 }
 366
 367 /// addSourceLine - Add location information to specified debug information
 368 /// entry.
 369 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
 370   assert(SP.isSubprogram());
 371
 372   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
 373 }
 374
 375 /// addSourceLine - Add location information to specified debug information
 376 /// entry.
 377 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
 378   assert(Ty.isType());
 379
 380   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
 381 }
 382
 383 /// addSourceLine - Add location information to specified debug information
 384 /// entry.
 385 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
 386   assert(Ty.isObjCProperty());
 387
 388   DIFile File = Ty.getFile();
 389   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
 390                 File.getDirectory());
 391 }
 392
 393 /// addSourceLine - Add location information to specified debug information
 394 /// entry.
 395 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
 396   assert(NS.Verify());
 397
 398   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
 399 }
 400
 401 /// addRegisterOp - Add register operand.
 402 // FIXME: Ideally, this would share the implementation with
 403 // AsmPrinter::EmitDwarfRegOpPiece.
 404 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
 405                                    unsigned SizeInBits, unsigned OffsetInBits) {
 406   const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
 407   int DWReg = RI->getDwarfRegNum(Reg, false);
 408   bool isSubRegister = DWReg < 0;
 409
 410   unsigned Idx = 0;
 411
 412   // Go up the super-register chain until we hit a valid dwarf register number.
 413   for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
 414     DWReg = RI->getDwarfRegNum(*SR, false);
 415     if (DWReg >= 0)
 416       Idx = RI->getSubRegIndex(*SR, Reg);
 417   }
 418
 419   if (DWReg < 0)
 420     return false;
 421
 422   // Emit register.
 423   if (DWReg < 32)
 424     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
 425   else {
 426     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 427     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
 428   }
 429
 430   // Emit mask.
 431   bool isPiece = SizeInBits > 0;
 432   if (isSubRegister || isPiece) {
 433     const unsigned SizeOfByte = 8;
 434     unsigned RegSizeInBits = RI->getSubRegIdxSize(Idx);
 435     unsigned RegOffsetInBits = RI->getSubRegIdxOffset(Idx);
 436     unsigned PieceSizeInBits = std::max(SizeInBits, RegSizeInBits);
 437     unsigned PieceOffsetInBits = OffsetInBits ? OffsetInBits : RegOffsetInBits;
 438     assert(RegSizeInBits >= SizeInBits && "register smaller than value");
 439
 440     if (RegOffsetInBits != PieceOffsetInBits) {
 441       // Manually shift the value into place, since the DW_OP_piece
 442       // describes the part of the variable, not the position of the
 443       // subregister.
 444       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 445       addUInt(TheDie, dwarf::DW_FORM_data1, RegOffsetInBits);
 446       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_shr);
 447     }
 448
 449     if (PieceOffsetInBits > 0 || PieceSizeInBits % SizeOfByte) {
 450       assert(PieceSizeInBits > 0 && "piece has zero size");
 451       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
 452       addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits);
 453       addUInt(TheDie, dwarf::DW_FORM_data1, PieceOffsetInBits);
 454      } else {
 455       assert(PieceSizeInBits > 0 && "piece has zero size");
 456       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
 457       addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits/SizeOfByte);
 458     }
 459   }
 460   return true;
 461 }
 462
 463 /// addRegisterOffset - Add register offset.
 464 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
 465                                   int64_t Offset) {
 466   const TargetRegisterInfo *TRI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
 467   int DWReg = TRI->getDwarfRegNum(Reg, false);
 468   if (DWReg < 0)
 469     return false;
 470
 471   if (Reg == TRI->getFrameRegister(*Asm->MF))
 472     // If variable offset is based in frame register then use fbreg.
 473     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
 474   else if (DWReg < 32)
 475     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
 476   else {
 477     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 478     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
 479   }
 480   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
 481   return true;
 482 }
 483
 484 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 485    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 486    gives the variable VarName either the struct, or a pointer to the struct, as
 487    its type.  This is necessary for various behind-the-scenes things the
 488    compiler needs to do with by-reference variables in Blocks.
 489
 490    However, as far as the original *programmer* is concerned, the variable
 491    should still have type 'SomeType', as originally declared.
 492
 493    The function getBlockByrefType dives into the __Block_byref_x_VarName
 494    struct to find the original type of the variable, which is then assigned to
 495    the variable's Debug Information Entry as its real type.  So far, so good.
 496    However now the debugger will expect the variable VarName to have the type
 497    SomeType.  So we need the location attribute for the variable to be an
 498    expression that explains to the debugger how to navigate through the
 499    pointers and struct to find the actual variable of type SomeType.
 500
 501    The following function does just that.  We start by getting
 502    the "normal" location for the variable. This will be the location
 503    of either the struct __Block_byref_x_VarName or the pointer to the
 504    struct __Block_byref_x_VarName.
 505
 506    The struct will look something like:
 507
 508    struct __Block_byref_x_VarName {
 509      ... <various fields>
 510      struct __Block_byref_x_VarName *forwarding;
 511      ... <various other fields>
 512      SomeType VarName;
 513      ... <maybe more fields>
 514    };
 515
 516    If we are given the struct directly (as our starting point) we
 517    need to tell the debugger to:
 518
 519    1).  Add the offset of the forwarding field.
 520
 521    2).  Follow that pointer to get the real __Block_byref_x_VarName
 522    struct to use (the real one may have been copied onto the heap).
 523
 524    3).  Add the offset for the field VarName, to find the actual variable.
 525
 526    If we started with a pointer to the struct, then we need to
 527    dereference that pointer first, before the other steps.
 528    Translating this into DWARF ops, we will need to append the following
 529    to the current location description for the variable:
 530
 531    DW_OP_deref                    -- optional, if we start with a pointer
 532    DW_OP_plus_uconst <forward_fld_offset>
 533    DW_OP_deref
 534    DW_OP_plus_uconst <varName_fld_offset>
 535
 536    That is what this function does.  */
 537
 538 /// addBlockByrefAddress - Start with the address based on the location
 539 /// provided, and generate the DWARF information necessary to find the
 540 /// actual Block variable (navigating the Block struct) based on the
 541 /// starting location.  Add the DWARF information to the die.  For
 542 /// more information, read large comment just above here.
 543 ///
 544 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
 545                                      dwarf::Attribute Attribute,
 546                                      const MachineLocation &Location) {
 547   DIType Ty = DV.getType();
 548   DIType TmpTy = Ty;
 549   uint16_t Tag = Ty.getTag();
 550   bool isPointer = false;
 551
 552   StringRef varName = DV.getName();
 553
 554   if (Tag == dwarf::DW_TAG_pointer_type) {
 555     DIDerivedType DTy(Ty);
 556     TmpTy = resolve(DTy.getTypeDerivedFrom());
 557     isPointer = true;
 558   }
 559
 560   DICompositeType blockStruct(TmpTy);
 561
 562   // Find the __forwarding field and the variable field in the __Block_byref
 563   // struct.
 564   DIArray Fields = blockStruct.getElements();
 565   DIDerivedType varField;
 566   DIDerivedType forwardingField;
 567
 568   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 569     DIDerivedType DT(Fields.getElement(i));
 570     StringRef fieldName = DT.getName();
 571     if (fieldName == "__forwarding")
 572       forwardingField = DT;
 573     else if (fieldName == varName)
 574       varField = DT;
 575   }
 576
 577   // Get the offsets for the forwarding field and the variable field.
 578   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
 579   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
 580
 581   // Decode the original location, and use that as the start of the byref
 582   // variable's location.
 583   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
 584
 585   bool validReg;
 586   if (Location.isReg())
 587     validReg = addRegisterOpPiece(*Loc, Location.getReg());
 588   else
 589     validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 590
 591   if (!validReg)
 592     return;
 593
 594   // If we started with a pointer to the __Block_byref... struct, then
 595   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 596   if (isPointer)
 597     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 598
 599   // Next add the offset for the '__forwarding' field:
 600   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 601   // adding the offset if it's 0.
 602   if (forwardingFieldOffset > 0) {
 603     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 604     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
 605   }
 606
 607   // Now dereference the __forwarding field to get to the real __Block_byref
 608   // struct:  DW_OP_deref.
 609   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 610
 611   // Now that we've got the real __Block_byref... struct, add the offset
 612   // for the variable's field to get to the location of the actual variable:
 613   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 614   if (varFieldOffset > 0) {
 615     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 616     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
 617   }
 618
 619   // Now attach the location information to the DIE.
 620   addBlock(Die, Attribute, Loc);
 621 }
 622
 623 /// Return true if type encoding is unsigned.
 624 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
 625   DIDerivedType DTy(Ty);
 626   if (DTy.isDerivedType()) {
 627     dwarf::Tag T = (dwarf::Tag)Ty.getTag();
 628     // Encode pointer constants as unsigned bytes. This is used at least for
 629     // null pointer constant emission.
 630     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
 631     // here, but accept them for now due to a bug in SROA producing bogus
 632     // dbg.values.
 633     if (T == dwarf::DW_TAG_pointer_type ||
 634         T == dwarf::DW_TAG_ptr_to_member_type ||
 635         T == dwarf::DW_TAG_reference_type ||
 636         T == dwarf::DW_TAG_rvalue_reference_type)
 637       return true;
 638     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 639            T == dwarf::DW_TAG_volatile_type ||
 640            T == dwarf::DW_TAG_restrict_type ||
 641            T == dwarf::DW_TAG_enumeration_type);
 642     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
 643       return isUnsignedDIType(DD, DD->resolve(Deriv));
 644     // FIXME: Enums without a fixed underlying type have unknown signedness
 645     // here, leading to incorrectly emitted constants.
 646     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
 647     return false;
 648   }
 649
 650   DIBasicType BTy(Ty);
 651   assert(BTy.isBasicType());
 652   unsigned Encoding = BTy.getEncoding();
 653   assert((Encoding == dwarf::DW_ATE_unsigned ||
 654           Encoding == dwarf::DW_ATE_unsigned_char ||
 655           Encoding == dwarf::DW_ATE_signed ||
 656           Encoding == dwarf::DW_ATE_signed_char ||
 657           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 658           (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
 659            Ty.getName() == "decltype(nullptr)")) &&
 660          "Unsupported encoding");
 661   return (Encoding == dwarf::DW_ATE_unsigned ||
 662           Encoding == dwarf::DW_ATE_unsigned_char ||
 663           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 664           Ty.getTag() == dwarf::DW_TAG_unspecified_type);
 665 }
 666
 667 /// If this type is derived from a base type then return base type size.
 668 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
 669   unsigned Tag = Ty.getTag();
 670
 671   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 672       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 673       Tag != dwarf::DW_TAG_restrict_type)
 674     return Ty.getSizeInBits();
 675
 676   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
 677
 678   // If this type is not derived from any type or the type is a declaration then
 679   // take conservative approach.
 680   if (!BaseType.isValid() || BaseType.isForwardDecl())
 681     return Ty.getSizeInBits();
 682
 683   // If this is a derived type, go ahead and get the base type, unless it's a
 684   // reference then it's just the size of the field. Pointer types have no need
 685   // of this since they're a different type of qualification on the type.
 686   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
 687       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
 688     return Ty.getSizeInBits();
 689
 690   if (BaseType.isDerivedType())
 691     return getBaseTypeSize(DD, DIDerivedType(BaseType));
 692
 693   return BaseType.getSizeInBits();
 694 }
 695
 696 /// addConstantFPValue - Add constant value entry in variable DIE.
 697 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 698   assert(MO.isFPImm() && "Invalid machine operand!");
 699   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 700   APFloat FPImm = MO.getFPImm()->getValueAPF();
 701
 702   // Get the raw data form of the floating point.
 703   const APInt FltVal = FPImm.bitcastToAPInt();
 704   const char *FltPtr = (const char *)FltVal.getRawData();
 705
 706   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 707   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 708   int Incr = (LittleEndian ? 1 : -1);
 709   int Start = (LittleEndian ? 0 : NumBytes - 1);
 710   int Stop = (LittleEndian ? NumBytes : -1);
 711
 712   // Output the constant to DWARF one byte at a time.
 713   for (; Start != Stop; Start += Incr)
 714     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 715
 716   addBlock(Die, dwarf::DW_AT_const_value, Block);
 717 }
 718
 719 /// addConstantFPValue - Add constant value entry in variable DIE.
 720 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 721   // Pass this down to addConstantValue as an unsigned bag of bits.
 722   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 723 }
 724
 725 /// addConstantValue - Add constant value entry in variable DIE.
 726 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
 727   addConstantValue(Die, CI->getValue(), Ty);
 728 }
 729
 730 /// addConstantValue - Add constant value entry in variable DIE.
 731 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 732                                  DIType Ty) {
 733   assert(MO.isImm() && "Invalid machine operand!");
 734
 735   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 736 }
 737
 738 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 739   // FIXME: This is a bit conservative/simple - it emits negative values always
 740   // sign extended to 64 bits rather than minimizing the number of bytes.
 741   addUInt(Die, dwarf::DW_AT_const_value,
 742           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 743 }
 744
 745 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
 746   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 747 }
 748
 749 // addConstantValue - Add constant value entry in variable DIE.
 750 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 751   unsigned CIBitWidth = Val.getBitWidth();
 752   if (CIBitWidth <= 64) {
 753     addConstantValue(Die, Unsigned,
 754                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 755     return;
 756   }
 757
 758   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 759
 760   // Get the raw data form of the large APInt.
 761   const uint64_t *Ptr64 = Val.getRawData();
 762
 763   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 764   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 765
 766   // Output the constant to DWARF one byte at a time.
 767   for (int i = 0; i < NumBytes; i++) {
 768     uint8_t c;
 769     if (LittleEndian)
 770       c = Ptr64[i / 8] >> (8 * (i & 7));
 771     else
 772       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 773     addUInt(*Block, dwarf::DW_FORM_data1, c);
 774   }
 775
 776   addBlock(Die, dwarf::DW_AT_const_value, Block);
 777 }
 778
 779 /// addTemplateParams - Add template parameters into buffer.
 780 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 781   // Add template parameters.
 782   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 783     DIDescriptor Element = TParams.getElement(i);
 784     if (Element.isTemplateTypeParameter())
 785       constructTemplateTypeParameterDIE(Buffer,
 786                                         DITemplateTypeParameter(Element));
 787     else if (Element.isTemplateValueParameter())
 788       constructTemplateValueParameterDIE(Buffer,
 789                                          DITemplateValueParameter(Element));
 790   }
 791 }
 792
 793 /// getOrCreateContextDIE - Get context owner's DIE.
 794 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 795   if (!Context || Context.isFile())
 796     return &getUnitDie();
 797   if (Context.isType())
 798     return getOrCreateTypeDIE(DIType(Context));
 799   if (Context.isNameSpace())
 800     return getOrCreateNameSpace(DINameSpace(Context));
 801   if (Context.isSubprogram())
 802     return getOrCreateSubprogramDIE(DISubprogram(Context));
 803   return getDIE(Context);
 804 }
 805
 806 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
 807   DIScope Context = resolve(Ty.getContext());
 808   DIE *ContextDIE = getOrCreateContextDIE(Context);
 809
 810   if (DIE *TyDIE = getDIE(Ty))
 811     return TyDIE;
 812
 813   // Create new type.
 814   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 815
 816   constructTypeDIE(TyDIE, Ty);
 817
 818   updateAcceleratorTables(Context, Ty, TyDIE);
 819   return &TyDIE;
 820 }
 821
 822 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 823 /// given DIType.
 824 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 825   if (!TyNode)
 826     return nullptr;
 827
 828   DIType Ty(TyNode);
 829   assert(Ty.isType());
 830   assert(Ty == resolve(Ty.getRef()) &&
 831          "type was not uniqued, possible ODR violation.");
 832
 833   // DW_TAG_restrict_type is not supported in DWARF2
 834   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 835     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
 836
 837   // Construct the context before querying for the existence of the DIE in case
 838   // such construction creates the DIE.
 839   DIScope Context = resolve(Ty.getContext());
 840   DIE *ContextDIE = getOrCreateContextDIE(Context);
 841   assert(ContextDIE);
 842
 843   if (DIE *TyDIE = getDIE(Ty))
 844     return TyDIE;
 845
 846   // Create new type.
 847   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 848
 849   updateAcceleratorTables(Context, Ty, TyDIE);
 850
 851   if (Ty.isBasicType())
 852     constructTypeDIE(TyDIE, DIBasicType(Ty));
 853   else if (Ty.isCompositeType()) {
 854     DICompositeType CTy(Ty);
 855     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
 856       if (MDString *TypeId = CTy.getIdentifier()) {
 857         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 858         // Skip updating the accelerator tables since this is not the full type.
 859         return &TyDIE;
 860       }
 861     constructTypeDIE(TyDIE, CTy);
 862   } else {
 863     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 864     constructTypeDIE(TyDIE, DIDerivedType(Ty));
 865   }
 866
 867   return &TyDIE;
 868 }
 869
 870 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
 871                                         const DIE &TyDIE) {
 872   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 873     bool IsImplementation = 0;
 874     if (Ty.isCompositeType()) {
 875       DICompositeType CT(Ty);
 876       // A runtime language of 0 actually means C/C++ and that any
 877       // non-negative value is some version of Objective-C/C++.
 878       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
 879     }
 880     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 881     DD->addAccelType(Ty.getName(), TyDIE, Flags);
 882
 883     if (!Context || Context.isCompileUnit() || Context.isFile() ||
 884         Context.isNameSpace())
 885       addGlobalType(Ty, TyDIE, Context);
 886   }
 887 }
 888
 889 /// addType - Add a new type attribute to the specified entity.
 890 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 891   assert(Ty && "Trying to add a type that doesn't exist?");
 892
 893   // Check for pre-existence.
 894   DIEEntry *Entry = getDIEEntry(Ty);
 895   // If it exists then use the existing value.
 896   if (Entry) {
 897     addDIEEntry(Entity, Attribute, Entry);
 898     return;
 899   }
 900
 901   // Construct type.
 902   DIE *Buffer = getOrCreateTypeDIE(Ty);
 903
 904   // Set up proxy.
 905   Entry = createDIEEntry(*Buffer);
 906   insertDIEEntry(Ty, Entry);
 907   addDIEEntry(Entity, Attribute, Entry);
 908 }
 909
 910 /// getParentContextString - Walks the metadata parent chain in a language
 911 /// specific manner (using the compile unit language) and returns
 912 /// it as a string. This is done at the metadata level because DIEs may
 913 /// not currently have been added to the parent context and walking the
 914 /// DIEs looking for names is more expensive than walking the metadata.
 915 std::string DwarfUnit::getParentContextString(DIScope Context) const {
 916   if (!Context)
 917     return "";
 918
 919   // FIXME: Decide whether to implement this for non-C++ languages.
 920   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 921     return "";
 922
 923   std::string CS;
 924   SmallVector<DIScope, 1> Parents;
 925   while (!Context.isCompileUnit()) {
 926     Parents.push_back(Context);
 927     if (Context.getContext())
 928       Context = resolve(Context.getContext());
 929     else
 930       // Structure, etc types will have a NULL context if they're at the top
 931       // level.
 932       break;
 933   }
 934
 935   // Reverse iterate over our list to go from the outermost construct to the
 936   // innermost.
 937   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
 938                                                   E = Parents.rend();
 939        I != E; ++I) {
 940     DIScope Ctx = *I;
 941     StringRef Name = Ctx.getName();
 942     if (Name.empty() && Ctx.isNameSpace())
 943       Name = "(anonymous namespace)";
 944     if (!Name.empty()) {
 945       CS += Name;
 946       CS += "::";
 947     }
 948   }
 949   return CS;
 950 }
 951
 952 /// constructTypeDIE - Construct basic type die from DIBasicType.
 953 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 954   // Get core information.
 955   StringRef Name = BTy.getName();
 956   // Add name if not anonymous or intermediate type.
 957   if (!Name.empty())
 958     addString(Buffer, dwarf::DW_AT_name, Name);
 959
 960   // An unspecified type only has a name attribute.
 961   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
 962     return;
 963
 964   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 965           BTy.getEncoding());
 966
 967   uint64_t Size = BTy.getSizeInBits() >> 3;
 968   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 969 }
 970
 971 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 972 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 973   // Get core information.
 974   StringRef Name = DTy.getName();
 975   uint64_t Size = DTy.getSizeInBits() >> 3;
 976   uint16_t Tag = Buffer.getTag();
 977
 978   // Map to main type, void will not have a type.
 979   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
 980   if (FromTy)
 981     addType(Buffer, FromTy);
 982
 983   // Add name if not anonymous or intermediate type.
 984   if (!Name.empty())
 985     addString(Buffer, dwarf::DW_AT_name, Name);
 986
 987   // Add size if non-zero (derived types might be zero-sized.)
 988   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 989     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 990
 991   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 992     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 993                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
 994   // Add source line info if available and TyDesc is not a forward declaration.
 995   if (!DTy.isForwardDecl())
 996     addSourceLine(Buffer, DTy);
 997 }
 998
 999 /// constructSubprogramArguments - Construct function argument DIEs.
1000 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1001   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1002     DIType Ty = resolve(Args.getElement(i));
1003     if (!Ty) {
1004       assert(i == N-1 && "Unspecified parameter must be the last argument");
1005       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1006     } else {
1007       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1008       addType(Arg, Ty);
1009       if (Ty.isArtificial())
1010         addFlag(Arg, dwarf::DW_AT_artificial);
1011     }
1012   }
1013 }
1014
1015 /// constructTypeDIE - Construct type DIE from DICompositeType.
1016 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1017   // Add name if not anonymous or intermediate type.
1018   StringRef Name = CTy.getName();
1019
1020   uint64_t Size = CTy.getSizeInBits() >> 3;
1021   uint16_t Tag = Buffer.getTag();
1022
1023   switch (Tag) {
1024   case dwarf::DW_TAG_array_type:
1025     constructArrayTypeDIE(Buffer, CTy);
1026     break;
1027   case dwarf::DW_TAG_enumeration_type:
1028     constructEnumTypeDIE(Buffer, CTy);
1029     break;
1030   case dwarf::DW_TAG_subroutine_type: {
1031     // Add return type. A void return won't have a type.
1032     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1033     DIType RTy(resolve(Elements.getElement(0)));
1034     if (RTy)
1035       addType(Buffer, RTy);
1036
1037     bool isPrototyped = true;
1038     if (Elements.getNumElements() == 2 &&
1039         !Elements.getElement(1))
1040       isPrototyped = false;
1041
1042     constructSubprogramArguments(Buffer, Elements);
1043
1044     // Add prototype flag if we're dealing with a C language and the
1045     // function has been prototyped.
1046     uint16_t Language = getLanguage();
1047     if (isPrototyped &&
1048         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1049          Language == dwarf::DW_LANG_ObjC))
1050       addFlag(Buffer, dwarf::DW_AT_prototyped);
1051
1052     if (CTy.isLValueReference())
1053       addFlag(Buffer, dwarf::DW_AT_reference);
1054
1055     if (CTy.isRValueReference())
1056       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1057   } break;
1058   case dwarf::DW_TAG_structure_type:
1059   case dwarf::DW_TAG_union_type:
1060   case dwarf::DW_TAG_class_type: {
1061     // Add elements to structure type.
1062     DIArray Elements = CTy.getElements();
1063     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1064       DIDescriptor Element = Elements.getElement(i);
1065       if (Element.isSubprogram())
1066         getOrCreateSubprogramDIE(DISubprogram(Element));
1067       else if (Element.isDerivedType()) {
1068         DIDerivedType DDTy(Element);
1069         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1070           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1071           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1072                   dwarf::DW_AT_friend);
1073         } else if (DDTy.isStaticMember()) {
1074           getOrCreateStaticMemberDIE(DDTy);
1075         } else {
1076           constructMemberDIE(Buffer, DDTy);
1077         }
1078       } else if (Element.isObjCProperty()) {
1079         DIObjCProperty Property(Element);
1080         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1081         StringRef PropertyName = Property.getObjCPropertyName();
1082         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1083         if (Property.getType())
1084           addType(ElemDie, Property.getType());
1085         addSourceLine(ElemDie, Property);
1086         StringRef GetterName = Property.getObjCPropertyGetterName();
1087         if (!GetterName.empty())
1088           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1089         StringRef SetterName = Property.getObjCPropertySetterName();
1090         if (!SetterName.empty())
1091           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1092         unsigned PropertyAttributes = 0;
1093         if (Property.isReadOnlyObjCProperty())
1094           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1095         if (Property.isReadWriteObjCProperty())
1096           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1097         if (Property.isAssignObjCProperty())
1098           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1099         if (Property.isRetainObjCProperty())
1100           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1101         if (Property.isCopyObjCProperty())
1102           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1103         if (Property.isNonAtomicObjCProperty())
1104           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1105         if (PropertyAttributes)
1106           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1107                   PropertyAttributes);
1108
1109         DIEEntry *Entry = getDIEEntry(Element);
1110         if (!Entry) {
1111           Entry = createDIEEntry(ElemDie);
1112           insertDIEEntry(Element, Entry);
1113         }
1114       } else
1115         continue;
1116     }
1117
1118     if (CTy.isAppleBlockExtension())
1119       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1120
1121     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1122     // inside C++ composite types to point to the base class with the vtable.
1123     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1124     if (ContainingType)
1125       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1126                   *getOrCreateTypeDIE(ContainingType));
1127
1128     if (CTy.isObjcClassComplete())
1129       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1130
1131     // Add template parameters to a class, structure or union types.
1132     // FIXME: The support isn't in the metadata for this yet.
1133     if (Tag == dwarf::DW_TAG_class_type ||
1134         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1135       addTemplateParams(Buffer, CTy.getTemplateParams());
1136
1137     break;
1138   }
1139   default:
1140     break;
1141   }
1142
1143   // Add name if not anonymous or intermediate type.
1144   if (!Name.empty())
1145     addString(Buffer, dwarf::DW_AT_name, Name);
1146
1147   if (Tag == dwarf::DW_TAG_enumeration_type ||
1148       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1149       Tag == dwarf::DW_TAG_union_type) {
1150     // Add size if non-zero (derived types might be zero-sized.)
1151     // TODO: Do we care about size for enum forward declarations?
1152     if (Size)
1153       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1154     else if (!CTy.isForwardDecl())
1155       // Add zero size if it is not a forward declaration.
1156       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1157
1158     // If we're a forward decl, say so.
1159     if (CTy.isForwardDecl())
1160       addFlag(Buffer, dwarf::DW_AT_declaration);
1161
1162     // Add source line info if available.
1163     if (!CTy.isForwardDecl())
1164       addSourceLine(Buffer, CTy);
1165
1166     // No harm in adding the runtime language to the declaration.
1167     unsigned RLang = CTy.getRunTimeLang();
1168     if (RLang)
1169       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1170               RLang);
1171   }
1172 }
1173
1174 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1175 /// DITemplateTypeParameter.
1176 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1177                                                   DITemplateTypeParameter TP) {
1178   DIE &ParamDIE =
1179       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1180   // Add the type if it exists, it could be void and therefore no type.
1181   if (TP.getType())
1182     addType(ParamDIE, resolve(TP.getType()));
1183   if (!TP.getName().empty())
1184     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1185 }
1186
1187 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1188 /// DITemplateValueParameter.
1189 void
1190 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1191                                               DITemplateValueParameter VP) {
1192   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1193
1194   // Add the type if there is one, template template and template parameter
1195   // packs will not have a type.
1196   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1197     addType(ParamDIE, resolve(VP.getType()));
1198   if (!VP.getName().empty())
1199     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1200   if (Metadata *Val = VP.getValue()) {
1201     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1202       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1203     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1204       // For declaration non-type template parameters (such as global values and
1205       // functions)
1206       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1207       addOpAddress(*Loc, Asm->getSymbol(GV));
1208       // Emit DW_OP_stack_value to use the address as the immediate value of the
1209       // parameter, rather than a pointer to it.
1210       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1211       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1212     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1213       assert(isa<MDString>(Val));
1214       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1215                 cast<MDString>(Val)->getString());
1216     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1217       assert(isa<MDNode>(Val));
1218       DIArray A(cast<MDNode>(Val));
1219       addTemplateParams(ParamDIE, A);
1220     }
1221   }
1222 }
1223
1224 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1225 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1226   // Construct the context before querying for the existence of the DIE in case
1227   // such construction creates the DIE.
1228   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1229
1230   if (DIE *NDie = getDIE(NS))
1231     return NDie;
1232   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1233
1234   StringRef Name = NS.getName();
1235   if (!Name.empty())
1236     addString(NDie, dwarf::DW_AT_name, NS.getName());
1237   else
1238     Name = "(anonymous namespace)";
1239   DD->addAccelNamespace(Name, NDie);
1240   addGlobalName(Name, NDie, NS.getContext());
1241   addSourceLine(NDie, NS);
1242   return &NDie;
1243 }
1244
1245 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1246 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1247   // Construct the context before querying for the existence of the DIE in case
1248   // such construction creates the DIE (as is the case for member function
1249   // declarations).
1250   DIE *ContextDIE =
1251       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1252
1253   if (DIE *SPDie = getDIE(SP))
1254     return SPDie;
1255
1256   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1257     if (!Minimal) {
1258       // Add subprogram definitions to the CU die directly.
1259       ContextDIE = &getUnitDie();
1260       // Build the decl now to ensure it precedes the definition.
1261       getOrCreateSubprogramDIE(SPDecl);
1262     }
1263   }
1264
1265   // DW_TAG_inlined_subroutine may refer to this DIE.
1266   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1267
1268   // Stop here and fill this in later, depending on whether or not this
1269   // subprogram turns out to have inlined instances or not.
1270   if (SP.isDefinition())
1271     return &SPDie;
1272
1273   applySubprogramAttributes(SP, SPDie);
1274   return &SPDie;
1275 }
1276
1277 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1278                                                     DIE &SPDie) {
1279   DIE *DeclDie = nullptr;
1280   StringRef DeclLinkageName;
1281   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1282     DeclDie = getDIE(SPDecl);
1283     assert(DeclDie && "This DIE should've already been constructed when the "
1284                       "definition DIE was created in "
1285                       "getOrCreateSubprogramDIE");
1286     DeclLinkageName = SPDecl.getLinkageName();
1287   }
1288
1289   // Add function template parameters.
1290   addTemplateParams(SPDie, SP.getTemplateParams());
1291
1292   // Add the linkage name if we have one and it isn't in the Decl.
1293   StringRef LinkageName = SP.getLinkageName();
1294   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1295           LinkageName == DeclLinkageName) &&
1296          "decl has a linkage name and it is different");
1297   if (!LinkageName.empty() && DeclLinkageName.empty())
1298     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1299               GlobalValue::getRealLinkageName(LinkageName));
1300
1301   if (!DeclDie)
1302     return false;
1303
1304   // Refer to the function declaration where all the other attributes will be
1305   // found.
1306   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1307   return true;
1308 }
1309
1310 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1311                                           bool Minimal) {
1312   if (!Minimal)
1313     if (applySubprogramDefinitionAttributes(SP, SPDie))
1314       return;
1315
1316   // Constructors and operators for anonymous aggregates do not have names.
1317   if (!SP.getName().empty())
1318     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1319
1320   // Skip the rest of the attributes under -gmlt to save space.
1321   if (Minimal)
1322     return;
1323
1324   addSourceLine(SPDie, SP);
1325
1326   // Add the prototype if we have a prototype and we have a C like
1327   // language.
1328   uint16_t Language = getLanguage();
1329   if (SP.isPrototyped() &&
1330       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1331        Language == dwarf::DW_LANG_ObjC))
1332     addFlag(SPDie, dwarf::DW_AT_prototyped);
1333
1334   DISubroutineType SPTy = SP.getType();
1335   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1336          "the type of a subprogram should be a subroutine");
1337
1338   DITypeArray Args = SPTy.getTypeArray();
1339   // Add a return type. If this is a type like a C/C++ void type we don't add a
1340   // return type.
1341   if (resolve(Args.getElement(0)))
1342     addType(SPDie, DIType(resolve(Args.getElement(0))));
1343
1344   unsigned VK = SP.getVirtuality();
1345   if (VK) {
1346     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1347     DIELoc *Block = getDIELoc();
1348     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1349     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1350     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1351     ContainingTypeMap.insert(
1352         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1353   }
1354
1355   if (!SP.isDefinition()) {
1356     addFlag(SPDie, dwarf::DW_AT_declaration);
1357
1358     // Add arguments. Do not add arguments for subprogram definition. They will
1359     // be handled while processing variables.
1360     constructSubprogramArguments(SPDie, Args);
1361   }
1362
1363   if (SP.isArtificial())
1364     addFlag(SPDie, dwarf::DW_AT_artificial);
1365
1366   if (!SP.isLocalToUnit())
1367     addFlag(SPDie, dwarf::DW_AT_external);
1368
1369   if (SP.isOptimized())
1370     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1371
1372   if (unsigned isa = Asm->getISAEncoding()) {
1373     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1374   }
1375
1376   if (SP.isLValueReference())
1377     addFlag(SPDie, dwarf::DW_AT_reference);
1378
1379   if (SP.isRValueReference())
1380     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1381
1382   if (SP.isProtected())
1383     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1384             dwarf::DW_ACCESS_protected);
1385   else if (SP.isPrivate())
1386     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1387             dwarf::DW_ACCESS_private);
1388   else if (SP.isPublic())
1389     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1390             dwarf::DW_ACCESS_public);
1391
1392   if (SP.isExplicit())
1393     addFlag(SPDie, dwarf::DW_AT_explicit);
1394 }
1395
1396 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1397 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1398   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1399   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1400
1401   // The LowerBound value defines the lower bounds which is typically zero for
1402   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1403   // Count == -1 then the array is unbounded and we do not emit
1404   // DW_AT_lower_bound and DW_AT_count attributes.
1405   int64_t LowerBound = SR.getLo();
1406   int64_t DefaultLowerBound = getDefaultLowerBound();
1407   int64_t Count = SR.getCount();
1408
1409   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1410     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1411
1412   if (Count != -1)
1413     // FIXME: An unbounded array should reference the expression that defines
1414     // the array.
1415     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1416 }
1417
1418 DIE *DwarfUnit::getIndexTyDie() {
1419   if (IndexTyDie)
1420     return IndexTyDie;
1421   // Construct an integer type to use for indexes.
1422   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1423   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1424   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1425   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1426           dwarf::DW_ATE_unsigned);
1427   return IndexTyDie;
1428 }
1429
1430 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1431 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1432   if (CTy.isVector())
1433     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1434
1435   // Emit the element type.
1436   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1437
1438   // Get an anonymous type for index type.
1439   // FIXME: This type should be passed down from the front end
1440   // as different languages may have different sizes for indexes.
1441   DIE *IdxTy = getIndexTyDie();
1442
1443   // Add subranges to array type.
1444   DIArray Elements = CTy.getElements();
1445   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1446     DIDescriptor Element = Elements.getElement(i);
1447     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1448       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1449   }
1450 }
1451
1452 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1453 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1454   DIArray Elements = CTy.getElements();
1455
1456   // Add enumerators to enumeration type.
1457   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1458     DIEnumerator Enum(Elements.getElement(i));
1459     if (Enum.isEnumerator()) {
1460       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1461       StringRef Name = Enum.getName();
1462       addString(Enumerator, dwarf::DW_AT_name, Name);
1463       int64_t Value = Enum.getEnumValue();
1464       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1465               Value);
1466     }
1467   }
1468   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1469   if (DTy) {
1470     addType(Buffer, DTy);
1471     addFlag(Buffer, dwarf::DW_AT_enum_class);
1472   }
1473 }
1474
1475 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1476 /// vtables.
1477 void DwarfUnit::constructContainingTypeDIEs() {
1478   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1479                                                  CE = ContainingTypeMap.end();
1480        CI != CE; ++CI) {
1481     DIE &SPDie = *CI->first;
1482     DIDescriptor D(CI->second);
1483     if (!D)
1484       continue;
1485     DIE *NDie = getDIE(D);
1486     if (!NDie)
1487       continue;
1488     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1489   }
1490 }
1491
1492 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1493 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1494   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1495   StringRef Name = DT.getName();
1496   if (!Name.empty())
1497     addString(MemberDie, dwarf::DW_AT_name, Name);
1498
1499   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1500
1501   addSourceLine(MemberDie, DT);
1502
1503   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1504
1505     // For C++, virtual base classes are not at fixed offset. Use following
1506     // expression to extract appropriate offset from vtable.
1507     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1508
1509     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1510     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1511     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1512     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1513     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1514     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1515     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1516     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1517
1518     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1519   } else {
1520     uint64_t Size = DT.getSizeInBits();
1521     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1522     uint64_t OffsetInBytes;
1523
1524     if (Size != FieldSize) {
1525       // Handle bitfield, assume bytes are 8 bits.
1526       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1527       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1528
1529       uint64_t Offset = DT.getOffsetInBits();
1530       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1531       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1532       uint64_t FieldOffset = (HiMark - FieldSize);
1533       Offset -= FieldOffset;
1534
1535       // Maybe we need to work from the other end.
1536       if (Asm->getDataLayout().isLittleEndian())
1537         Offset = FieldSize - (Offset + Size);
1538       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1539
1540       // Here DW_AT_data_member_location points to the anonymous
1541       // field that includes this bit field.
1542       OffsetInBytes = FieldOffset >> 3;
1543     } else
1544       // This is not a bitfield.
1545       OffsetInBytes = DT.getOffsetInBits() >> 3;
1546
1547     if (DD->getDwarfVersion() <= 2) {
1548       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1549       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1550       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1551       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1552     } else
1553       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1554               OffsetInBytes);
1555   }
1556
1557   if (DT.isProtected())
1558     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1559             dwarf::DW_ACCESS_protected);
1560   else if (DT.isPrivate())
1561     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562             dwarf::DW_ACCESS_private);
1563   // Otherwise C++ member and base classes are considered public.
1564   else if (DT.isPublic())
1565     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1566             dwarf::DW_ACCESS_public);
1567   if (DT.isVirtual())
1568     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1569             dwarf::DW_VIRTUALITY_virtual);
1570
1571   // Objective-C properties.
1572   if (MDNode *PNode = DT.getObjCProperty())
1573     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1574       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1575                          PropertyDie);
1576
1577   if (DT.isArtificial())
1578     addFlag(MemberDie, dwarf::DW_AT_artificial);
1579 }
1580
1581 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1582 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1583   if (!DT.Verify())
1584     return nullptr;
1585
1586   // Construct the context before querying for the existence of the DIE in case
1587   // such construction creates the DIE.
1588   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1589   assert(dwarf::isType(ContextDIE->getTag()) &&
1590          "Static member should belong to a type.");
1591
1592   if (DIE *StaticMemberDIE = getDIE(DT))
1593     return StaticMemberDIE;
1594
1595   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1596
1597   DIType Ty = resolve(DT.getTypeDerivedFrom());
1598
1599   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1600   addType(StaticMemberDIE, Ty);
1601   addSourceLine(StaticMemberDIE, DT);
1602   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1603   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1604
1605   // FIXME: We could omit private if the parent is a class_type, and
1606   // public if the parent is something else.
1607   if (DT.isProtected())
1608     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1609             dwarf::DW_ACCESS_protected);
1610   else if (DT.isPrivate())
1611     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1612             dwarf::DW_ACCESS_private);
1613   else if (DT.isPublic())
1614     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1615             dwarf::DW_ACCESS_public);
1616
1617   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1618     addConstantValue(StaticMemberDIE, CI, Ty);
1619   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1620     addConstantFPValue(StaticMemberDIE, CFP);
1621
1622   return &StaticMemberDIE;
1623 }
1624
1625 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1626   // Emit size of content not including length itself
1627   Asm->OutStreamer.AddComment("Length of Unit");
1628   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1629
1630   Asm->OutStreamer.AddComment("DWARF version number");
1631   Asm->EmitInt16(DD->getDwarfVersion());
1632   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1633   // We share one abbreviations table across all units so it's always at the
1634   // start of the section. Use a relocatable offset where needed to ensure
1635   // linking doesn't invalidate that offset.
1636   if (ASectionSym)
1637     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1638   else
1639     // Use a constant value when no symbol is provided.
1640     Asm->EmitInt32(0);
1641   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1642   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1643 }
1644
1645 void DwarfUnit::initSection(const MCSection *Section) {
1646   assert(!this->Section);
1647   this->Section = Section;
1648 }
1649
1650 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1651   DwarfUnit::emitHeader(ASectionSym);
1652   Asm->OutStreamer.AddComment("Type Signature");
1653   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1654   Asm->OutStreamer.AddComment("Type DIE Offset");
1655   // In a skeleton type unit there is no type DIE so emit a zero offset.
1656   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1657                                 sizeof(Ty->getOffset()));
1658 }
1659
1660 bool DwarfTypeUnit::isDwoUnit() const {
1661   // Since there are no skeleton type units, all type units are dwo type units
1662   // when split DWARF is being used.
1663   return DD->useSplitDwarf();
1664 }