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_array_type ||
 634         T == dwarf::DW_TAG_class_type ||
 635         T == dwarf::DW_TAG_pointer_type ||
 636         T == dwarf::DW_TAG_ptr_to_member_type ||
 637         T == dwarf::DW_TAG_reference_type ||
 638         T == dwarf::DW_TAG_rvalue_reference_type ||
 639         T == dwarf::DW_TAG_structure_type)
 640       return true;
 641     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 642            T == dwarf::DW_TAG_volatile_type ||
 643            T == dwarf::DW_TAG_restrict_type ||
 644            T == dwarf::DW_TAG_enumeration_type);
 645     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
 646       return isUnsignedDIType(DD, DD->resolve(Deriv));
 647     // FIXME: Enums without a fixed underlying type have unknown signedness
 648     // here, leading to incorrectly emitted constants.
 649     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
 650     return false;
 651   }
 652
 653   DIBasicType BTy(Ty);
 654   assert(BTy.isBasicType());
 655   unsigned Encoding = BTy.getEncoding();
 656   assert((Encoding == dwarf::DW_ATE_unsigned ||
 657           Encoding == dwarf::DW_ATE_unsigned_char ||
 658           Encoding == dwarf::DW_ATE_signed ||
 659           Encoding == dwarf::DW_ATE_signed_char ||
 660           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 661           (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
 662            Ty.getName() == "decltype(nullptr)")) &&
 663          "Unsupported encoding");
 664   return (Encoding == dwarf::DW_ATE_unsigned ||
 665           Encoding == dwarf::DW_ATE_unsigned_char ||
 666           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 667           Ty.getTag() == dwarf::DW_TAG_unspecified_type);
 668 }
 669
 670 /// If this type is derived from a base type then return base type size.
 671 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
 672   unsigned Tag = Ty.getTag();
 673
 674   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 675       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 676       Tag != dwarf::DW_TAG_restrict_type)
 677     return Ty.getSizeInBits();
 678
 679   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
 680
 681   // If this type is not derived from any type or the type is a declaration then
 682   // take conservative approach.
 683   if (!BaseType.isValid() || BaseType.isForwardDecl())
 684     return Ty.getSizeInBits();
 685
 686   // If this is a derived type, go ahead and get the base type, unless it's a
 687   // reference then it's just the size of the field. Pointer types have no need
 688   // of this since they're a different type of qualification on the type.
 689   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
 690       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
 691     return Ty.getSizeInBits();
 692
 693   if (BaseType.isDerivedType())
 694     return getBaseTypeSize(DD, DIDerivedType(BaseType));
 695
 696   return BaseType.getSizeInBits();
 697 }
 698
 699 /// addConstantFPValue - Add constant value entry in variable DIE.
 700 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 701   assert(MO.isFPImm() && "Invalid machine operand!");
 702   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 703   APFloat FPImm = MO.getFPImm()->getValueAPF();
 704
 705   // Get the raw data form of the floating point.
 706   const APInt FltVal = FPImm.bitcastToAPInt();
 707   const char *FltPtr = (const char *)FltVal.getRawData();
 708
 709   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 710   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 711   int Incr = (LittleEndian ? 1 : -1);
 712   int Start = (LittleEndian ? 0 : NumBytes - 1);
 713   int Stop = (LittleEndian ? NumBytes : -1);
 714
 715   // Output the constant to DWARF one byte at a time.
 716   for (; Start != Stop; Start += Incr)
 717     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 718
 719   addBlock(Die, dwarf::DW_AT_const_value, Block);
 720 }
 721
 722 /// addConstantFPValue - Add constant value entry in variable DIE.
 723 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 724   // Pass this down to addConstantValue as an unsigned bag of bits.
 725   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 726 }
 727
 728 /// addConstantValue - Add constant value entry in variable DIE.
 729 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
 730   addConstantValue(Die, CI->getValue(), Ty);
 731 }
 732
 733 /// addConstantValue - Add constant value entry in variable DIE.
 734 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 735                                  DIType Ty) {
 736   assert(MO.isImm() && "Invalid machine operand!");
 737
 738   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 739 }
 740
 741 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 742   // FIXME: This is a bit conservative/simple - it emits negative values always
 743   // sign extended to 64 bits rather than minimizing the number of bytes.
 744   addUInt(Die, dwarf::DW_AT_const_value,
 745           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 746 }
 747
 748 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
 749   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 750 }
 751
 752 // addConstantValue - Add constant value entry in variable DIE.
 753 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 754   unsigned CIBitWidth = Val.getBitWidth();
 755   if (CIBitWidth <= 64) {
 756     addConstantValue(Die, Unsigned,
 757                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 758     return;
 759   }
 760
 761   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 762
 763   // Get the raw data form of the large APInt.
 764   const uint64_t *Ptr64 = Val.getRawData();
 765
 766   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 767   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 768
 769   // Output the constant to DWARF one byte at a time.
 770   for (int i = 0; i < NumBytes; i++) {
 771     uint8_t c;
 772     if (LittleEndian)
 773       c = Ptr64[i / 8] >> (8 * (i & 7));
 774     else
 775       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 776     addUInt(*Block, dwarf::DW_FORM_data1, c);
 777   }
 778
 779   addBlock(Die, dwarf::DW_AT_const_value, Block);
 780 }
 781
 782 /// addTemplateParams - Add template parameters into buffer.
 783 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 784   // Add template parameters.
 785   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 786     DIDescriptor Element = TParams.getElement(i);
 787     if (Element.isTemplateTypeParameter())
 788       constructTemplateTypeParameterDIE(Buffer,
 789                                         DITemplateTypeParameter(Element));
 790     else if (Element.isTemplateValueParameter())
 791       constructTemplateValueParameterDIE(Buffer,
 792                                          DITemplateValueParameter(Element));
 793   }
 794 }
 795
 796 /// getOrCreateContextDIE - Get context owner's DIE.
 797 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 798   if (!Context || Context.isFile())
 799     return &getUnitDie();
 800   if (Context.isType())
 801     return getOrCreateTypeDIE(DIType(Context));
 802   if (Context.isNameSpace())
 803     return getOrCreateNameSpace(DINameSpace(Context));
 804   if (Context.isSubprogram())
 805     return getOrCreateSubprogramDIE(DISubprogram(Context));
 806   return getDIE(Context);
 807 }
 808
 809 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
 810   DIScope Context = resolve(Ty.getContext());
 811   DIE *ContextDIE = getOrCreateContextDIE(Context);
 812
 813   if (DIE *TyDIE = getDIE(Ty))
 814     return TyDIE;
 815
 816   // Create new type.
 817   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 818
 819   constructTypeDIE(TyDIE, Ty);
 820
 821   updateAcceleratorTables(Context, Ty, TyDIE);
 822   return &TyDIE;
 823 }
 824
 825 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 826 /// given DIType.
 827 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 828   if (!TyNode)
 829     return nullptr;
 830
 831   DIType Ty(TyNode);
 832   assert(Ty.isType());
 833   assert(Ty == resolve(Ty.getRef()) &&
 834          "type was not uniqued, possible ODR violation.");
 835
 836   // DW_TAG_restrict_type is not supported in DWARF2
 837   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 838     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
 839
 840   // Construct the context before querying for the existence of the DIE in case
 841   // such construction creates the DIE.
 842   DIScope Context = resolve(Ty.getContext());
 843   DIE *ContextDIE = getOrCreateContextDIE(Context);
 844   assert(ContextDIE);
 845
 846   if (DIE *TyDIE = getDIE(Ty))
 847     return TyDIE;
 848
 849   // Create new type.
 850   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 851
 852   updateAcceleratorTables(Context, Ty, TyDIE);
 853
 854   if (Ty.isBasicType())
 855     constructTypeDIE(TyDIE, DIBasicType(Ty));
 856   else if (Ty.isCompositeType()) {
 857     DICompositeType CTy(Ty);
 858     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
 859       if (MDString *TypeId = CTy.getIdentifier()) {
 860         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 861         // Skip updating the accelerator tables since this is not the full type.
 862         return &TyDIE;
 863       }
 864     constructTypeDIE(TyDIE, CTy);
 865   } else {
 866     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 867     constructTypeDIE(TyDIE, DIDerivedType(Ty));
 868   }
 869
 870   return &TyDIE;
 871 }
 872
 873 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
 874                                         const DIE &TyDIE) {
 875   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 876     bool IsImplementation = 0;
 877     if (Ty.isCompositeType()) {
 878       DICompositeType CT(Ty);
 879       // A runtime language of 0 actually means C/C++ and that any
 880       // non-negative value is some version of Objective-C/C++.
 881       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
 882     }
 883     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 884     DD->addAccelType(Ty.getName(), TyDIE, Flags);
 885
 886     if (!Context || Context.isCompileUnit() || Context.isFile() ||
 887         Context.isNameSpace())
 888       addGlobalType(Ty, TyDIE, Context);
 889   }
 890 }
 891
 892 /// addType - Add a new type attribute to the specified entity.
 893 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 894   assert(Ty && "Trying to add a type that doesn't exist?");
 895
 896   // Check for pre-existence.
 897   DIEEntry *Entry = getDIEEntry(Ty);
 898   // If it exists then use the existing value.
 899   if (Entry) {
 900     addDIEEntry(Entity, Attribute, Entry);
 901     return;
 902   }
 903
 904   // Construct type.
 905   DIE *Buffer = getOrCreateTypeDIE(Ty);
 906
 907   // Set up proxy.
 908   Entry = createDIEEntry(*Buffer);
 909   insertDIEEntry(Ty, Entry);
 910   addDIEEntry(Entity, Attribute, Entry);
 911 }
 912
 913 /// getParentContextString - Walks the metadata parent chain in a language
 914 /// specific manner (using the compile unit language) and returns
 915 /// it as a string. This is done at the metadata level because DIEs may
 916 /// not currently have been added to the parent context and walking the
 917 /// DIEs looking for names is more expensive than walking the metadata.
 918 std::string DwarfUnit::getParentContextString(DIScope Context) const {
 919   if (!Context)
 920     return "";
 921
 922   // FIXME: Decide whether to implement this for non-C++ languages.
 923   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 924     return "";
 925
 926   std::string CS;
 927   SmallVector<DIScope, 1> Parents;
 928   while (!Context.isCompileUnit()) {
 929     Parents.push_back(Context);
 930     if (Context.getContext())
 931       Context = resolve(Context.getContext());
 932     else
 933       // Structure, etc types will have a NULL context if they're at the top
 934       // level.
 935       break;
 936   }
 937
 938   // Reverse iterate over our list to go from the outermost construct to the
 939   // innermost.
 940   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
 941                                                   E = Parents.rend();
 942        I != E; ++I) {
 943     DIScope Ctx = *I;
 944     StringRef Name = Ctx.getName();
 945     if (Name.empty() && Ctx.isNameSpace())
 946       Name = "(anonymous namespace)";
 947     if (!Name.empty()) {
 948       CS += Name;
 949       CS += "::";
 950     }
 951   }
 952   return CS;
 953 }
 954
 955 /// constructTypeDIE - Construct basic type die from DIBasicType.
 956 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 957   // Get core information.
 958   StringRef Name = BTy.getName();
 959   // Add name if not anonymous or intermediate type.
 960   if (!Name.empty())
 961     addString(Buffer, dwarf::DW_AT_name, Name);
 962
 963   // An unspecified type only has a name attribute.
 964   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
 965     return;
 966
 967   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 968           BTy.getEncoding());
 969
 970   uint64_t Size = BTy.getSizeInBits() >> 3;
 971   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 972 }
 973
 974 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 975 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 976   // Get core information.
 977   StringRef Name = DTy.getName();
 978   uint64_t Size = DTy.getSizeInBits() >> 3;
 979   uint16_t Tag = Buffer.getTag();
 980
 981   // Map to main type, void will not have a type.
 982   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
 983   if (FromTy)
 984     addType(Buffer, FromTy);
 985
 986   // Add name if not anonymous or intermediate type.
 987   if (!Name.empty())
 988     addString(Buffer, dwarf::DW_AT_name, Name);
 989
 990   // Add size if non-zero (derived types might be zero-sized.)
 991   if (Size && Tag != dwarf::DW_TAG_pointer_type
 992            && Tag != dwarf::DW_TAG_ptr_to_member_type)
 993     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 994
 995   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 996     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 997                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
 998   // Add source line info if available and TyDesc is not a forward declaration.
 999   if (!DTy.isForwardDecl())
1000     addSourceLine(Buffer, DTy);
1001 }
1002
1003 /// constructSubprogramArguments - Construct function argument DIEs.
1004 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1005   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1006     DIType Ty = resolve(Args.getElement(i));
1007     if (!Ty) {
1008       assert(i == N-1 && "Unspecified parameter must be the last argument");
1009       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1010     } else {
1011       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1012       addType(Arg, Ty);
1013       if (Ty.isArtificial())
1014         addFlag(Arg, dwarf::DW_AT_artificial);
1015     }
1016   }
1017 }
1018
1019 /// constructTypeDIE - Construct type DIE from DICompositeType.
1020 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1021   // Add name if not anonymous or intermediate type.
1022   StringRef Name = CTy.getName();
1023
1024   uint64_t Size = CTy.getSizeInBits() >> 3;
1025   uint16_t Tag = Buffer.getTag();
1026
1027   switch (Tag) {
1028   case dwarf::DW_TAG_array_type:
1029     constructArrayTypeDIE(Buffer, CTy);
1030     break;
1031   case dwarf::DW_TAG_enumeration_type:
1032     constructEnumTypeDIE(Buffer, CTy);
1033     break;
1034   case dwarf::DW_TAG_subroutine_type: {
1035     // Add return type. A void return won't have a type.
1036     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1037     DIType RTy(resolve(Elements.getElement(0)));
1038     if (RTy)
1039       addType(Buffer, RTy);
1040
1041     bool isPrototyped = true;
1042     if (Elements.getNumElements() == 2 &&
1043         !Elements.getElement(1))
1044       isPrototyped = false;
1045
1046     constructSubprogramArguments(Buffer, Elements);
1047
1048     // Add prototype flag if we're dealing with a C language and the
1049     // function has been prototyped.
1050     uint16_t Language = getLanguage();
1051     if (isPrototyped &&
1052         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1053          Language == dwarf::DW_LANG_ObjC))
1054       addFlag(Buffer, dwarf::DW_AT_prototyped);
1055
1056     if (CTy.isLValueReference())
1057       addFlag(Buffer, dwarf::DW_AT_reference);
1058
1059     if (CTy.isRValueReference())
1060       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1061   } break;
1062   case dwarf::DW_TAG_structure_type:
1063   case dwarf::DW_TAG_union_type:
1064   case dwarf::DW_TAG_class_type: {
1065     // Add elements to structure type.
1066     DIArray Elements = CTy.getElements();
1067     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1068       DIDescriptor Element = Elements.getElement(i);
1069       if (Element.isSubprogram())
1070         getOrCreateSubprogramDIE(DISubprogram(Element));
1071       else if (Element.isDerivedType()) {
1072         DIDerivedType DDTy(Element);
1073         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1074           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1075           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1076                   dwarf::DW_AT_friend);
1077         } else if (DDTy.isStaticMember()) {
1078           getOrCreateStaticMemberDIE(DDTy);
1079         } else {
1080           constructMemberDIE(Buffer, DDTy);
1081         }
1082       } else if (Element.isObjCProperty()) {
1083         DIObjCProperty Property(Element);
1084         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1085         StringRef PropertyName = Property.getObjCPropertyName();
1086         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1087         if (Property.getType())
1088           addType(ElemDie, Property.getType());
1089         addSourceLine(ElemDie, Property);
1090         StringRef GetterName = Property.getObjCPropertyGetterName();
1091         if (!GetterName.empty())
1092           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1093         StringRef SetterName = Property.getObjCPropertySetterName();
1094         if (!SetterName.empty())
1095           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1096         unsigned PropertyAttributes = 0;
1097         if (Property.isReadOnlyObjCProperty())
1098           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1099         if (Property.isReadWriteObjCProperty())
1100           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1101         if (Property.isAssignObjCProperty())
1102           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1103         if (Property.isRetainObjCProperty())
1104           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1105         if (Property.isCopyObjCProperty())
1106           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1107         if (Property.isNonAtomicObjCProperty())
1108           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1109         if (PropertyAttributes)
1110           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1111                   PropertyAttributes);
1112
1113         DIEEntry *Entry = getDIEEntry(Element);
1114         if (!Entry) {
1115           Entry = createDIEEntry(ElemDie);
1116           insertDIEEntry(Element, Entry);
1117         }
1118       } else
1119         continue;
1120     }
1121
1122     if (CTy.isAppleBlockExtension())
1123       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1124
1125     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1126     // inside C++ composite types to point to the base class with the vtable.
1127     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1128     if (ContainingType)
1129       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1130                   *getOrCreateTypeDIE(ContainingType));
1131
1132     if (CTy.isObjcClassComplete())
1133       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1134
1135     // Add template parameters to a class, structure or union types.
1136     // FIXME: The support isn't in the metadata for this yet.
1137     if (Tag == dwarf::DW_TAG_class_type ||
1138         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1139       addTemplateParams(Buffer, CTy.getTemplateParams());
1140
1141     break;
1142   }
1143   default:
1144     break;
1145   }
1146
1147   // Add name if not anonymous or intermediate type.
1148   if (!Name.empty())
1149     addString(Buffer, dwarf::DW_AT_name, Name);
1150
1151   if (Tag == dwarf::DW_TAG_enumeration_type ||
1152       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1153       Tag == dwarf::DW_TAG_union_type) {
1154     // Add size if non-zero (derived types might be zero-sized.)
1155     // TODO: Do we care about size for enum forward declarations?
1156     if (Size)
1157       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1158     else if (!CTy.isForwardDecl())
1159       // Add zero size if it is not a forward declaration.
1160       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1161
1162     // If we're a forward decl, say so.
1163     if (CTy.isForwardDecl())
1164       addFlag(Buffer, dwarf::DW_AT_declaration);
1165
1166     // Add source line info if available.
1167     if (!CTy.isForwardDecl())
1168       addSourceLine(Buffer, CTy);
1169
1170     // No harm in adding the runtime language to the declaration.
1171     unsigned RLang = CTy.getRunTimeLang();
1172     if (RLang)
1173       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1174               RLang);
1175   }
1176 }
1177
1178 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1179 /// DITemplateTypeParameter.
1180 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1181                                                   DITemplateTypeParameter TP) {
1182   DIE &ParamDIE =
1183       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1184   // Add the type if it exists, it could be void and therefore no type.
1185   if (TP.getType())
1186     addType(ParamDIE, resolve(TP.getType()));
1187   if (!TP.getName().empty())
1188     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1189 }
1190
1191 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1192 /// DITemplateValueParameter.
1193 void
1194 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1195                                               DITemplateValueParameter VP) {
1196   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1197
1198   // Add the type if there is one, template template and template parameter
1199   // packs will not have a type.
1200   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1201     addType(ParamDIE, resolve(VP.getType()));
1202   if (!VP.getName().empty())
1203     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1204   if (Metadata *Val = VP.getValue()) {
1205     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1206       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1207     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1208       // For declaration non-type template parameters (such as global values and
1209       // functions)
1210       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1211       addOpAddress(*Loc, Asm->getSymbol(GV));
1212       // Emit DW_OP_stack_value to use the address as the immediate value of the
1213       // parameter, rather than a pointer to it.
1214       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1215       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1216     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1217       assert(isa<MDString>(Val));
1218       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1219                 cast<MDString>(Val)->getString());
1220     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1221       assert(isa<MDNode>(Val));
1222       DIArray A(cast<MDNode>(Val));
1223       addTemplateParams(ParamDIE, A);
1224     }
1225   }
1226 }
1227
1228 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1229 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1230   // Construct the context before querying for the existence of the DIE in case
1231   // such construction creates the DIE.
1232   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1233
1234   if (DIE *NDie = getDIE(NS))
1235     return NDie;
1236   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1237
1238   StringRef Name = NS.getName();
1239   if (!Name.empty())
1240     addString(NDie, dwarf::DW_AT_name, NS.getName());
1241   else
1242     Name = "(anonymous namespace)";
1243   DD->addAccelNamespace(Name, NDie);
1244   addGlobalName(Name, NDie, NS.getContext());
1245   addSourceLine(NDie, NS);
1246   return &NDie;
1247 }
1248
1249 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1250 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1251   // Construct the context before querying for the existence of the DIE in case
1252   // such construction creates the DIE (as is the case for member function
1253   // declarations).
1254   DIE *ContextDIE =
1255       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1256
1257   if (DIE *SPDie = getDIE(SP))
1258     return SPDie;
1259
1260   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1261     if (!Minimal) {
1262       // Add subprogram definitions to the CU die directly.
1263       ContextDIE = &getUnitDie();
1264       // Build the decl now to ensure it precedes the definition.
1265       getOrCreateSubprogramDIE(SPDecl);
1266     }
1267   }
1268
1269   // DW_TAG_inlined_subroutine may refer to this DIE.
1270   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1271
1272   // Stop here and fill this in later, depending on whether or not this
1273   // subprogram turns out to have inlined instances or not.
1274   if (SP.isDefinition())
1275     return &SPDie;
1276
1277   applySubprogramAttributes(SP, SPDie);
1278   return &SPDie;
1279 }
1280
1281 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1282                                                     DIE &SPDie) {
1283   DIE *DeclDie = nullptr;
1284   StringRef DeclLinkageName;
1285   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1286     DeclDie = getDIE(SPDecl);
1287     assert(DeclDie && "This DIE should've already been constructed when the "
1288                       "definition DIE was created in "
1289                       "getOrCreateSubprogramDIE");
1290     DeclLinkageName = SPDecl.getLinkageName();
1291   }
1292
1293   // Add function template parameters.
1294   addTemplateParams(SPDie, SP.getTemplateParams());
1295
1296   // Add the linkage name if we have one and it isn't in the Decl.
1297   StringRef LinkageName = SP.getLinkageName();
1298   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1299           LinkageName == DeclLinkageName) &&
1300          "decl has a linkage name and it is different");
1301   if (!LinkageName.empty() && DeclLinkageName.empty())
1302     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1303               GlobalValue::getRealLinkageName(LinkageName));
1304
1305   if (!DeclDie)
1306     return false;
1307
1308   // Refer to the function declaration where all the other attributes will be
1309   // found.
1310   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1311   return true;
1312 }
1313
1314 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1315                                           bool Minimal) {
1316   if (!Minimal)
1317     if (applySubprogramDefinitionAttributes(SP, SPDie))
1318       return;
1319
1320   // Constructors and operators for anonymous aggregates do not have names.
1321   if (!SP.getName().empty())
1322     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1323
1324   // Skip the rest of the attributes under -gmlt to save space.
1325   if (Minimal)
1326     return;
1327
1328   addSourceLine(SPDie, SP);
1329
1330   // Add the prototype if we have a prototype and we have a C like
1331   // language.
1332   uint16_t Language = getLanguage();
1333   if (SP.isPrototyped() &&
1334       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1335        Language == dwarf::DW_LANG_ObjC))
1336     addFlag(SPDie, dwarf::DW_AT_prototyped);
1337
1338   DISubroutineType SPTy = SP.getType();
1339   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1340          "the type of a subprogram should be a subroutine");
1341
1342   DITypeArray Args = SPTy.getTypeArray();
1343   // Add a return type. If this is a type like a C/C++ void type we don't add a
1344   // return type.
1345   if (resolve(Args.getElement(0)))
1346     addType(SPDie, DIType(resolve(Args.getElement(0))));
1347
1348   unsigned VK = SP.getVirtuality();
1349   if (VK) {
1350     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1351     DIELoc *Block = getDIELoc();
1352     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1353     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1354     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1355     ContainingTypeMap.insert(
1356         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1357   }
1358
1359   if (!SP.isDefinition()) {
1360     addFlag(SPDie, dwarf::DW_AT_declaration);
1361
1362     // Add arguments. Do not add arguments for subprogram definition. They will
1363     // be handled while processing variables.
1364     constructSubprogramArguments(SPDie, Args);
1365   }
1366
1367   if (SP.isArtificial())
1368     addFlag(SPDie, dwarf::DW_AT_artificial);
1369
1370   if (!SP.isLocalToUnit())
1371     addFlag(SPDie, dwarf::DW_AT_external);
1372
1373   if (SP.isOptimized())
1374     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1375
1376   if (unsigned isa = Asm->getISAEncoding()) {
1377     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1378   }
1379
1380   if (SP.isLValueReference())
1381     addFlag(SPDie, dwarf::DW_AT_reference);
1382
1383   if (SP.isRValueReference())
1384     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1385
1386   if (SP.isProtected())
1387     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1388             dwarf::DW_ACCESS_protected);
1389   else if (SP.isPrivate())
1390     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1391             dwarf::DW_ACCESS_private);
1392   else if (SP.isPublic())
1393     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1394             dwarf::DW_ACCESS_public);
1395
1396   if (SP.isExplicit())
1397     addFlag(SPDie, dwarf::DW_AT_explicit);
1398 }
1399
1400 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1401 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1402   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1403   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1404
1405   // The LowerBound value defines the lower bounds which is typically zero for
1406   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1407   // Count == -1 then the array is unbounded and we do not emit
1408   // DW_AT_lower_bound and DW_AT_count attributes.
1409   int64_t LowerBound = SR.getLo();
1410   int64_t DefaultLowerBound = getDefaultLowerBound();
1411   int64_t Count = SR.getCount();
1412
1413   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1414     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1415
1416   if (Count != -1)
1417     // FIXME: An unbounded array should reference the expression that defines
1418     // the array.
1419     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1420 }
1421
1422 DIE *DwarfUnit::getIndexTyDie() {
1423   if (IndexTyDie)
1424     return IndexTyDie;
1425   // Construct an integer type to use for indexes.
1426   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1427   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1428   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1429   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1430           dwarf::DW_ATE_unsigned);
1431   return IndexTyDie;
1432 }
1433
1434 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1435 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1436   if (CTy.isVector())
1437     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1438
1439   // Emit the element type.
1440   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1441
1442   // Get an anonymous type for index type.
1443   // FIXME: This type should be passed down from the front end
1444   // as different languages may have different sizes for indexes.
1445   DIE *IdxTy = getIndexTyDie();
1446
1447   // Add subranges to array type.
1448   DIArray Elements = CTy.getElements();
1449   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1450     DIDescriptor Element = Elements.getElement(i);
1451     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1452       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1453   }
1454 }
1455
1456 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1457 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1458   DIArray Elements = CTy.getElements();
1459
1460   // Add enumerators to enumeration type.
1461   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1462     DIEnumerator Enum(Elements.getElement(i));
1463     if (Enum.isEnumerator()) {
1464       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1465       StringRef Name = Enum.getName();
1466       addString(Enumerator, dwarf::DW_AT_name, Name);
1467       int64_t Value = Enum.getEnumValue();
1468       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1469               Value);
1470     }
1471   }
1472   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1473   if (DTy) {
1474     addType(Buffer, DTy);
1475     addFlag(Buffer, dwarf::DW_AT_enum_class);
1476   }
1477 }
1478
1479 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1480 /// vtables.
1481 void DwarfUnit::constructContainingTypeDIEs() {
1482   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1483                                                  CE = ContainingTypeMap.end();
1484        CI != CE; ++CI) {
1485     DIE &SPDie = *CI->first;
1486     DIDescriptor D(CI->second);
1487     if (!D)
1488       continue;
1489     DIE *NDie = getDIE(D);
1490     if (!NDie)
1491       continue;
1492     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1493   }
1494 }
1495
1496 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1497 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1498   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1499   StringRef Name = DT.getName();
1500   if (!Name.empty())
1501     addString(MemberDie, dwarf::DW_AT_name, Name);
1502
1503   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1504
1505   addSourceLine(MemberDie, DT);
1506
1507   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1508
1509     // For C++, virtual base classes are not at fixed offset. Use following
1510     // expression to extract appropriate offset from vtable.
1511     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1512
1513     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1514     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1515     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1516     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1517     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1518     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1519     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1520     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1521
1522     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1523   } else {
1524     uint64_t Size = DT.getSizeInBits();
1525     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1526     uint64_t OffsetInBytes;
1527
1528     if (Size != FieldSize) {
1529       // Handle bitfield, assume bytes are 8 bits.
1530       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1531       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1532
1533       uint64_t Offset = DT.getOffsetInBits();
1534       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1535       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1536       uint64_t FieldOffset = (HiMark - FieldSize);
1537       Offset -= FieldOffset;
1538
1539       // Maybe we need to work from the other end.
1540       if (Asm->getDataLayout().isLittleEndian())
1541         Offset = FieldSize - (Offset + Size);
1542       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1543
1544       // Here DW_AT_data_member_location points to the anonymous
1545       // field that includes this bit field.
1546       OffsetInBytes = FieldOffset >> 3;
1547     } else
1548       // This is not a bitfield.
1549       OffsetInBytes = DT.getOffsetInBits() >> 3;
1550
1551     if (DD->getDwarfVersion() <= 2) {
1552       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1553       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1554       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1555       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1556     } else
1557       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1558               OffsetInBytes);
1559   }
1560
1561   if (DT.isProtected())
1562     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1563             dwarf::DW_ACCESS_protected);
1564   else if (DT.isPrivate())
1565     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1566             dwarf::DW_ACCESS_private);
1567   // Otherwise C++ member and base classes are considered public.
1568   else if (DT.isPublic())
1569     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1570             dwarf::DW_ACCESS_public);
1571   if (DT.isVirtual())
1572     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1573             dwarf::DW_VIRTUALITY_virtual);
1574
1575   // Objective-C properties.
1576   if (MDNode *PNode = DT.getObjCProperty())
1577     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1578       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1579                          PropertyDie);
1580
1581   if (DT.isArtificial())
1582     addFlag(MemberDie, dwarf::DW_AT_artificial);
1583 }
1584
1585 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1586 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1587   if (!DT.Verify())
1588     return nullptr;
1589
1590   // Construct the context before querying for the existence of the DIE in case
1591   // such construction creates the DIE.
1592   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1593   assert(dwarf::isType(ContextDIE->getTag()) &&
1594          "Static member should belong to a type.");
1595
1596   if (DIE *StaticMemberDIE = getDIE(DT))
1597     return StaticMemberDIE;
1598
1599   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1600
1601   DIType Ty = resolve(DT.getTypeDerivedFrom());
1602
1603   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1604   addType(StaticMemberDIE, Ty);
1605   addSourceLine(StaticMemberDIE, DT);
1606   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1607   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1608
1609   // FIXME: We could omit private if the parent is a class_type, and
1610   // public if the parent is something else.
1611   if (DT.isProtected())
1612     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1613             dwarf::DW_ACCESS_protected);
1614   else if (DT.isPrivate())
1615     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1616             dwarf::DW_ACCESS_private);
1617   else if (DT.isPublic())
1618     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1619             dwarf::DW_ACCESS_public);
1620
1621   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1622     addConstantValue(StaticMemberDIE, CI, Ty);
1623   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1624     addConstantFPValue(StaticMemberDIE, CFP);
1625
1626   return &StaticMemberDIE;
1627 }
1628
1629 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1630   // Emit size of content not including length itself
1631   Asm->OutStreamer.AddComment("Length of Unit");
1632   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1633
1634   Asm->OutStreamer.AddComment("DWARF version number");
1635   Asm->EmitInt16(DD->getDwarfVersion());
1636   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1637   // We share one abbreviations table across all units so it's always at the
1638   // start of the section. Use a relocatable offset where needed to ensure
1639   // linking doesn't invalidate that offset.
1640   if (ASectionSym)
1641     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1642   else
1643     // Use a constant value when no symbol is provided.
1644     Asm->EmitInt32(0);
1645   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1646   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1647 }
1648
1649 void DwarfUnit::initSection(const MCSection *Section) {
1650   assert(!this->Section);
1651   this->Section = Section;
1652 }
1653
1654 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1655   DwarfUnit::emitHeader(ASectionSym);
1656   Asm->OutStreamer.AddComment("Type Signature");
1657   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1658   Asm->OutStreamer.AddComment("Type DIE Offset");
1659   // In a skeleton type unit there is no type DIE so emit a zero offset.
1660   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1661                                 sizeof(Ty->getOffset()));
1662 }
1663
1664 bool DwarfTypeUnit::isDwoUnit() const {
1665   // Since there are no skeleton type units, all type units are dwo type units
1666   // when split DWARF is being used.
1667   return DD->useSplitDwarf();
1668 }