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