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