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