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::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1261   DIE *DeclDie = nullptr;
1262   StringRef DeclLinkageName;
1263   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1264     DeclDie = getDIE(SPDecl);
1265     assert(DeclDie && "This DIE should've already been constructed when the "
1266                       "definition DIE was created in "
1267                       "getOrCreateSubprogramDIE");
1268     DeclLinkageName = SPDecl.getLinkageName();
1269   }
1270
1271   // Add function template parameters.
1272   addTemplateParams(SPDie, SP.getTemplateParams());
1273
1274   // Add the linkage name if we have one and it isn't in the Decl.
1275   StringRef LinkageName = SP.getLinkageName();
1276   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1277           LinkageName == DeclLinkageName) &&
1278          "decl has a linkage name and it is different");
1279   if (!LinkageName.empty() && DeclLinkageName.empty())
1280     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1281               GlobalValue::getRealLinkageName(LinkageName));
1282
1283   if (DeclDie) {
1284     // Refer to the function declaration where all the other attributes will be
1285     // found.
1286     addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1287     return;
1288   }
1289
1290   // Constructors and operators for anonymous aggregates do not have names.
1291   if (!SP.getName().empty())
1292     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1293
1294   // Skip the rest of the attributes under -gmlt to save space.
1295   if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1296     return;
1297
1298   addSourceLine(SPDie, SP);
1299
1300   // Add the prototype if we have a prototype and we have a C like
1301   // language.
1302   uint16_t Language = getLanguage();
1303   if (SP.isPrototyped() &&
1304       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1305        Language == dwarf::DW_LANG_ObjC))
1306     addFlag(SPDie, dwarf::DW_AT_prototyped);
1307
1308   DISubroutineType SPTy = SP.getType();
1309   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1310          "the type of a subprogram should be a subroutine");
1311
1312   DITypeArray Args = SPTy.getTypeArray();
1313   // Add a return type. If this is a type like a C/C++ void type we don't add a
1314   // return type.
1315   if (resolve(Args.getElement(0)))
1316     addType(SPDie, DIType(resolve(Args.getElement(0))));
1317
1318   unsigned VK = SP.getVirtuality();
1319   if (VK) {
1320     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1321     DIELoc *Block = getDIELoc();
1322     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1323     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1324     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1325     ContainingTypeMap.insert(
1326         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1327   }
1328
1329   if (!SP.isDefinition()) {
1330     addFlag(SPDie, dwarf::DW_AT_declaration);
1331
1332     // Add arguments. Do not add arguments for subprogram definition. They will
1333     // be handled while processing variables.
1334     constructSubprogramArguments(SPDie, Args);
1335   }
1336
1337   if (SP.isArtificial())
1338     addFlag(SPDie, dwarf::DW_AT_artificial);
1339
1340   if (!SP.isLocalToUnit())
1341     addFlag(SPDie, dwarf::DW_AT_external);
1342
1343   if (SP.isOptimized())
1344     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1345
1346   if (unsigned isa = Asm->getISAEncoding()) {
1347     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1348   }
1349
1350   if (SP.isLValueReference())
1351     addFlag(SPDie, dwarf::DW_AT_reference);
1352
1353   if (SP.isRValueReference())
1354     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1355
1356   if (SP.isProtected())
1357     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1358             dwarf::DW_ACCESS_protected);
1359   else if (SP.isPrivate())
1360     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1361             dwarf::DW_ACCESS_private);
1362   else if (SP.isPublic())
1363     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1364             dwarf::DW_ACCESS_public);
1365
1366   if (SP.isExplicit())
1367     addFlag(SPDie, dwarf::DW_AT_explicit);
1368 }
1369
1370 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1371 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1372   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1373   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1374
1375   // The LowerBound value defines the lower bounds which is typically zero for
1376   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1377   // Count == -1 then the array is unbounded and we do not emit
1378   // DW_AT_lower_bound and DW_AT_count attributes.
1379   int64_t LowerBound = SR.getLo();
1380   int64_t DefaultLowerBound = getDefaultLowerBound();
1381   int64_t Count = SR.getCount();
1382
1383   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1384     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1385
1386   if (Count != -1)
1387     // FIXME: An unbounded array should reference the expression that defines
1388     // the array.
1389     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1390 }
1391
1392 DIE *DwarfUnit::getIndexTyDie() {
1393   if (IndexTyDie)
1394     return IndexTyDie;
1395   // Construct an integer type to use for indexes.
1396   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1397   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1398   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1399   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1400           dwarf::DW_ATE_unsigned);
1401   return IndexTyDie;
1402 }
1403
1404 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1405 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1406   if (CTy.isVector())
1407     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1408
1409   // Emit the element type.
1410   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1411
1412   // Get an anonymous type for index type.
1413   // FIXME: This type should be passed down from the front end
1414   // as different languages may have different sizes for indexes.
1415   DIE *IdxTy = getIndexTyDie();
1416
1417   // Add subranges to array type.
1418   DIArray Elements = CTy.getElements();
1419   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1420     DIDescriptor Element = Elements.getElement(i);
1421     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1422       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1423   }
1424 }
1425
1426 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1427 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1428   DIArray Elements = CTy.getElements();
1429
1430   // Add enumerators to enumeration type.
1431   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1432     DIEnumerator Enum(Elements.getElement(i));
1433     if (Enum.isEnumerator()) {
1434       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1435       StringRef Name = Enum.getName();
1436       addString(Enumerator, dwarf::DW_AT_name, Name);
1437       int64_t Value = Enum.getEnumValue();
1438       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1439               Value);
1440     }
1441   }
1442   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1443   if (DTy) {
1444     addType(Buffer, DTy);
1445     addFlag(Buffer, dwarf::DW_AT_enum_class);
1446   }
1447 }
1448
1449 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1450 /// vtables.
1451 void DwarfUnit::constructContainingTypeDIEs() {
1452   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1453                                                  CE = ContainingTypeMap.end();
1454        CI != CE; ++CI) {
1455     DIE &SPDie = *CI->first;
1456     DIDescriptor D(CI->second);
1457     if (!D)
1458       continue;
1459     DIE *NDie = getDIE(D);
1460     if (!NDie)
1461       continue;
1462     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1463   }
1464 }
1465
1466 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1467 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1468   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1469   StringRef Name = DT.getName();
1470   if (!Name.empty())
1471     addString(MemberDie, dwarf::DW_AT_name, Name);
1472
1473   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1474
1475   addSourceLine(MemberDie, DT);
1476
1477   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1478
1479     // For C++, virtual base classes are not at fixed offset. Use following
1480     // expression to extract appropriate offset from vtable.
1481     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1482
1483     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1484     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1485     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1486     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1487     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1488     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1489     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1490     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1491
1492     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1493   } else {
1494     uint64_t Size = DT.getSizeInBits();
1495     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1496     uint64_t OffsetInBytes;
1497
1498     if (Size != FieldSize) {
1499       // Handle bitfield, assume bytes are 8 bits.
1500       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1501       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1502
1503       uint64_t Offset = DT.getOffsetInBits();
1504       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1505       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1506       uint64_t FieldOffset = (HiMark - FieldSize);
1507       Offset -= FieldOffset;
1508
1509       // Maybe we need to work from the other end.
1510       if (Asm->getDataLayout().isLittleEndian())
1511         Offset = FieldSize - (Offset + Size);
1512       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1513
1514       // Here DW_AT_data_member_location points to the anonymous
1515       // field that includes this bit field.
1516       OffsetInBytes = FieldOffset >> 3;
1517     } else
1518       // This is not a bitfield.
1519       OffsetInBytes = DT.getOffsetInBits() >> 3;
1520
1521     if (DD->getDwarfVersion() <= 2) {
1522       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1523       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1524       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1525       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1526     } else
1527       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1528               OffsetInBytes);
1529   }
1530
1531   if (DT.isProtected())
1532     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1533             dwarf::DW_ACCESS_protected);
1534   else if (DT.isPrivate())
1535     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1536             dwarf::DW_ACCESS_private);
1537   // Otherwise C++ member and base classes are considered public.
1538   else if (DT.isPublic())
1539     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1540             dwarf::DW_ACCESS_public);
1541   if (DT.isVirtual())
1542     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1543             dwarf::DW_VIRTUALITY_virtual);
1544
1545   // Objective-C properties.
1546   if (MDNode *PNode = DT.getObjCProperty())
1547     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1548       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1549                          PropertyDie);
1550
1551   if (DT.isArtificial())
1552     addFlag(MemberDie, dwarf::DW_AT_artificial);
1553 }
1554
1555 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1556 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1557   if (!DT.Verify())
1558     return nullptr;
1559
1560   // Construct the context before querying for the existence of the DIE in case
1561   // such construction creates the DIE.
1562   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1563   assert(dwarf::isType(ContextDIE->getTag()) &&
1564          "Static member should belong to a type.");
1565
1566   if (DIE *StaticMemberDIE = getDIE(DT))
1567     return StaticMemberDIE;
1568
1569   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1570
1571   DIType Ty = resolve(DT.getTypeDerivedFrom());
1572
1573   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1574   addType(StaticMemberDIE, Ty);
1575   addSourceLine(StaticMemberDIE, DT);
1576   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1577   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1578
1579   // FIXME: We could omit private if the parent is a class_type, and
1580   // public if the parent is something else.
1581   if (DT.isProtected())
1582     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1583             dwarf::DW_ACCESS_protected);
1584   else if (DT.isPrivate())
1585     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1586             dwarf::DW_ACCESS_private);
1587   else if (DT.isPublic())
1588     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1589             dwarf::DW_ACCESS_public);
1590
1591   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1592     addConstantValue(StaticMemberDIE, CI, Ty);
1593   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1594     addConstantFPValue(StaticMemberDIE, CFP);
1595
1596   return &StaticMemberDIE;
1597 }
1598
1599 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1600   // Emit size of content not including length itself
1601   Asm->OutStreamer.AddComment("Length of Unit");
1602   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1603
1604   Asm->OutStreamer.AddComment("DWARF version number");
1605   Asm->EmitInt16(DD->getDwarfVersion());
1606   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1607   // We share one abbreviations table across all units so it's always at the
1608   // start of the section. Use a relocatable offset where needed to ensure
1609   // linking doesn't invalidate that offset.
1610   if (ASectionSym)
1611     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1612   else
1613     // Use a constant value when no symbol is provided.
1614     Asm->EmitInt32(0);
1615   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1616   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1617 }
1618
1619 void DwarfUnit::initSection(const MCSection *Section) {
1620   assert(!this->Section);
1621   this->Section = Section;
1622 }
1623
1624 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1625   DwarfUnit::emitHeader(ASectionSym);
1626   Asm->OutStreamer.AddComment("Type Signature");
1627   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1628   Asm->OutStreamer.AddComment("Type DIE Offset");
1629   // In a skeleton type unit there is no type DIE so emit a zero offset.
1630   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1631                                 sizeof(Ty->getOffset()));
1632 }
1633