lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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