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