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