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         T == dwarf::DW_TAG_union_type)
 589       return true;
 590     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 591            T == dwarf::DW_TAG_volatile_type ||
 592            T == dwarf::DW_TAG_restrict_type ||
 593            T == dwarf::DW_TAG_enumeration_type);
 594     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
 595       return isUnsignedDIType(DD, DD->resolve(Deriv));
 596     // FIXME: Enums without a fixed underlying type have unknown signedness
 597     // here, leading to incorrectly emitted constants.
 598     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
 599     return false;
 600   }
 601
 602   DIBasicType BTy(Ty);
 603   assert(BTy.isBasicType());
 604   unsigned Encoding = BTy.getEncoding();
 605   assert((Encoding == dwarf::DW_ATE_unsigned ||
 606           Encoding == dwarf::DW_ATE_unsigned_char ||
 607           Encoding == dwarf::DW_ATE_signed ||
 608           Encoding == dwarf::DW_ATE_signed_char ||
 609           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 610           (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
 611            Ty.getName() == "decltype(nullptr)")) &&
 612          "Unsupported encoding");
 613   return (Encoding == dwarf::DW_ATE_unsigned ||
 614           Encoding == dwarf::DW_ATE_unsigned_char ||
 615           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 616           Ty.getTag() == dwarf::DW_TAG_unspecified_type);
 617 }
 618
 619 /// If this type is derived from a base type then return base type size.
 620 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
 621   unsigned Tag = Ty.getTag();
 622
 623   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 624       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 625       Tag != dwarf::DW_TAG_restrict_type)
 626     return Ty.getSizeInBits();
 627
 628   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
 629
 630   // If this type is not derived from any type or the type is a declaration then
 631   // take conservative approach.
 632   if (!BaseType.isValid() || BaseType.isForwardDecl())
 633     return Ty.getSizeInBits();
 634
 635   // If this is a derived type, go ahead and get the base type, unless it's a
 636   // reference then it's just the size of the field. Pointer types have no need
 637   // of this since they're a different type of qualification on the type.
 638   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
 639       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
 640     return Ty.getSizeInBits();
 641
 642   if (BaseType.isDerivedType())
 643     return getBaseTypeSize(DD, DIDerivedType(BaseType));
 644
 645   return BaseType.getSizeInBits();
 646 }
 647
 648 /// addConstantFPValue - Add constant value entry in variable DIE.
 649 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 650   assert(MO.isFPImm() && "Invalid machine operand!");
 651   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 652   APFloat FPImm = MO.getFPImm()->getValueAPF();
 653
 654   // Get the raw data form of the floating point.
 655   const APInt FltVal = FPImm.bitcastToAPInt();
 656   const char *FltPtr = (const char *)FltVal.getRawData();
 657
 658   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 659   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 660   int Incr = (LittleEndian ? 1 : -1);
 661   int Start = (LittleEndian ? 0 : NumBytes - 1);
 662   int Stop = (LittleEndian ? NumBytes : -1);
 663
 664   // Output the constant to DWARF one byte at a time.
 665   for (; Start != Stop; Start += Incr)
 666     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 667
 668   addBlock(Die, dwarf::DW_AT_const_value, Block);
 669 }
 670
 671 /// addConstantFPValue - Add constant value entry in variable DIE.
 672 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 673   // Pass this down to addConstantValue as an unsigned bag of bits.
 674   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 675 }
 676
 677 /// addConstantValue - Add constant value entry in variable DIE.
 678 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
 679   addConstantValue(Die, CI->getValue(), Ty);
 680 }
 681
 682 /// addConstantValue - Add constant value entry in variable DIE.
 683 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 684                                  DIType Ty) {
 685   assert(MO.isImm() && "Invalid machine operand!");
 686
 687   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 688 }
 689
 690 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 691   // FIXME: This is a bit conservative/simple - it emits negative values always
 692   // sign extended to 64 bits rather than minimizing the number of bytes.
 693   addUInt(Die, dwarf::DW_AT_const_value,
 694           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 695 }
 696
 697 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
 698   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 699 }
 700
 701 // addConstantValue - Add constant value entry in variable DIE.
 702 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 703   unsigned CIBitWidth = Val.getBitWidth();
 704   if (CIBitWidth <= 64) {
 705     addConstantValue(Die, Unsigned,
 706                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 707     return;
 708   }
 709
 710   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 711
 712   // Get the raw data form of the large APInt.
 713   const uint64_t *Ptr64 = Val.getRawData();
 714
 715   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 716   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 717
 718   // Output the constant to DWARF one byte at a time.
 719   for (int i = 0; i < NumBytes; i++) {
 720     uint8_t c;
 721     if (LittleEndian)
 722       c = Ptr64[i / 8] >> (8 * (i & 7));
 723     else
 724       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 725     addUInt(*Block, dwarf::DW_FORM_data1, c);
 726   }
 727
 728   addBlock(Die, dwarf::DW_AT_const_value, Block);
 729 }
 730
 731 /// addTemplateParams - Add template parameters into buffer.
 732 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 733   // Add template parameters.
 734   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 735     DIDescriptor Element = TParams.getElement(i);
 736     if (Element.isTemplateTypeParameter())
 737       constructTemplateTypeParameterDIE(Buffer,
 738                                         DITemplateTypeParameter(Element));
 739     else if (Element.isTemplateValueParameter())
 740       constructTemplateValueParameterDIE(Buffer,
 741                                          DITemplateValueParameter(Element));
 742   }
 743 }
 744
 745 /// getOrCreateContextDIE - Get context owner's DIE.
 746 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 747   if (!Context || Context.isFile())
 748     return &getUnitDie();
 749   if (Context.isType())
 750     return getOrCreateTypeDIE(DIType(Context));
 751   if (Context.isNameSpace())
 752     return getOrCreateNameSpace(DINameSpace(Context));
 753   if (Context.isSubprogram())
 754     return getOrCreateSubprogramDIE(DISubprogram(Context));
 755   return getDIE(Context);
 756 }
 757
 758 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
 759   DIScope Context = resolve(Ty.getContext());
 760   DIE *ContextDIE = getOrCreateContextDIE(Context);
 761
 762   if (DIE *TyDIE = getDIE(Ty))
 763     return TyDIE;
 764
 765   // Create new type.
 766   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 767
 768   constructTypeDIE(TyDIE, Ty);
 769
 770   updateAcceleratorTables(Context, Ty, TyDIE);
 771   return &TyDIE;
 772 }
 773
 774 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 775 /// given DIType.
 776 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 777   if (!TyNode)
 778     return nullptr;
 779
 780   DIType Ty(TyNode);
 781   assert(Ty.isType());
 782   assert(Ty == resolve(Ty.getRef()) &&
 783          "type was not uniqued, possible ODR violation.");
 784
 785   // DW_TAG_restrict_type is not supported in DWARF2
 786   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 787     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
 788
 789   // Construct the context before querying for the existence of the DIE in case
 790   // such construction creates the DIE.
 791   DIScope Context = resolve(Ty.getContext());
 792   DIE *ContextDIE = getOrCreateContextDIE(Context);
 793   assert(ContextDIE);
 794
 795   if (DIE *TyDIE = getDIE(Ty))
 796     return TyDIE;
 797
 798   // Create new type.
 799   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 800
 801   updateAcceleratorTables(Context, Ty, TyDIE);
 802
 803   if (Ty.isBasicType())
 804     constructTypeDIE(TyDIE, DIBasicType(Ty));
 805   else if (Ty.isCompositeType()) {
 806     DICompositeType CTy(Ty);
 807     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
 808       if (MDString *TypeId = CTy.getIdentifier()) {
 809         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 810         // Skip updating the accelerator tables since this is not the full type.
 811         return &TyDIE;
 812       }
 813     constructTypeDIE(TyDIE, CTy);
 814   } else {
 815     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 816     constructTypeDIE(TyDIE, DIDerivedType(Ty));
 817   }
 818
 819   return &TyDIE;
 820 }
 821
 822 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
 823                                         const DIE &TyDIE) {
 824   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 825     bool IsImplementation = 0;
 826     if (Ty.isCompositeType()) {
 827       DICompositeType CT(Ty);
 828       // A runtime language of 0 actually means C/C++ and that any
 829       // non-negative value is some version of Objective-C/C++.
 830       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
 831     }
 832     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 833     DD->addAccelType(Ty.getName(), TyDIE, Flags);
 834
 835     if (!Context || Context.isCompileUnit() || Context.isFile() ||
 836         Context.isNameSpace())
 837       addGlobalType(Ty, TyDIE, Context);
 838   }
 839 }
 840
 841 /// addType - Add a new type attribute to the specified entity.
 842 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 843   assert(Ty && "Trying to add a type that doesn't exist?");
 844
 845   // Check for pre-existence.
 846   DIEEntry *Entry = getDIEEntry(Ty);
 847   // If it exists then use the existing value.
 848   if (Entry) {
 849     addDIEEntry(Entity, Attribute, Entry);
 850     return;
 851   }
 852
 853   // Construct type.
 854   DIE *Buffer = getOrCreateTypeDIE(Ty);
 855
 856   // Set up proxy.
 857   Entry = createDIEEntry(*Buffer);
 858   insertDIEEntry(Ty, Entry);
 859   addDIEEntry(Entity, Attribute, Entry);
 860 }
 861
 862 /// getParentContextString - Walks the metadata parent chain in a language
 863 /// specific manner (using the compile unit language) and returns
 864 /// it as a string. This is done at the metadata level because DIEs may
 865 /// not currently have been added to the parent context and walking the
 866 /// DIEs looking for names is more expensive than walking the metadata.
 867 std::string DwarfUnit::getParentContextString(DIScope Context) const {
 868   if (!Context)
 869     return "";
 870
 871   // FIXME: Decide whether to implement this for non-C++ languages.
 872   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 873     return "";
 874
 875   std::string CS;
 876   SmallVector<DIScope, 1> Parents;
 877   while (!Context.isCompileUnit()) {
 878     Parents.push_back(Context);
 879     if (Context.getContext())
 880       Context = resolve(Context.getContext());
 881     else
 882       // Structure, etc types will have a NULL context if they're at the top
 883       // level.
 884       break;
 885   }
 886
 887   // Reverse iterate over our list to go from the outermost construct to the
 888   // innermost.
 889   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
 890                                                   E = Parents.rend();
 891        I != E; ++I) {
 892     DIScope Ctx = *I;
 893     StringRef Name = Ctx.getName();
 894     if (Name.empty() && Ctx.isNameSpace())
 895       Name = "(anonymous namespace)";
 896     if (!Name.empty()) {
 897       CS += Name;
 898       CS += "::";
 899     }
 900   }
 901   return CS;
 902 }
 903
 904 /// constructTypeDIE - Construct basic type die from DIBasicType.
 905 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 906   // Get core information.
 907   StringRef Name = BTy.getName();
 908   // Add name if not anonymous or intermediate type.
 909   if (!Name.empty())
 910     addString(Buffer, dwarf::DW_AT_name, Name);
 911
 912   // An unspecified type only has a name attribute.
 913   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
 914     return;
 915
 916   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 917           BTy.getEncoding());
 918
 919   uint64_t Size = BTy.getSizeInBits() >> 3;
 920   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 921 }
 922
 923 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 924 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 925   // Get core information.
 926   StringRef Name = DTy.getName();
 927   uint64_t Size = DTy.getSizeInBits() >> 3;
 928   uint16_t Tag = Buffer.getTag();
 929
 930   // Map to main type, void will not have a type.
 931   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
 932   if (FromTy)
 933     addType(Buffer, FromTy);
 934
 935   // Add name if not anonymous or intermediate type.
 936   if (!Name.empty())
 937     addString(Buffer, dwarf::DW_AT_name, Name);
 938
 939   // Add size if non-zero (derived types might be zero-sized.)
 940   if (Size && Tag != dwarf::DW_TAG_pointer_type
 941            && Tag != dwarf::DW_TAG_ptr_to_member_type)
 942     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 943
 944   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 945     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 946                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
 947   // Add source line info if available and TyDesc is not a forward declaration.
 948   if (!DTy.isForwardDecl())
 949     addSourceLine(Buffer, DTy);
 950 }
 951
 952 /// constructSubprogramArguments - Construct function argument DIEs.
 953 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
 954   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
 955     DIType Ty = resolve(Args.getElement(i));
 956     if (!Ty) {
 957       assert(i == N-1 && "Unspecified parameter must be the last argument");
 958       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 959     } else {
 960       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 961       addType(Arg, Ty);
 962       if (Ty.isArtificial())
 963         addFlag(Arg, dwarf::DW_AT_artificial);
 964     }
 965   }
 966 }
 967
 968 /// constructTypeDIE - Construct type DIE from DICompositeType.
 969 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 970   // Add name if not anonymous or intermediate type.
 971   StringRef Name = CTy.getName();
 972
 973   uint64_t Size = CTy.getSizeInBits() >> 3;
 974   uint16_t Tag = Buffer.getTag();
 975
 976   switch (Tag) {
 977   case dwarf::DW_TAG_array_type:
 978     constructArrayTypeDIE(Buffer, CTy);
 979     break;
 980   case dwarf::DW_TAG_enumeration_type:
 981     constructEnumTypeDIE(Buffer, CTy);
 982     break;
 983   case dwarf::DW_TAG_subroutine_type: {
 984     // Add return type. A void return won't have a type.
 985     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
 986     DIType RTy(resolve(Elements.getElement(0)));
 987     if (RTy)
 988       addType(Buffer, RTy);
 989
 990     bool isPrototyped = true;
 991     if (Elements.getNumElements() == 2 &&
 992         !Elements.getElement(1))
 993       isPrototyped = false;
 994
 995     constructSubprogramArguments(Buffer, Elements);
 996
 997     // Add prototype flag if we're dealing with a C language and the
 998     // function has been prototyped.
 999     uint16_t Language = getLanguage();
1000     if (isPrototyped &&
1001         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1002          Language == dwarf::DW_LANG_ObjC))
1003       addFlag(Buffer, dwarf::DW_AT_prototyped);
1004
1005     if (CTy.isLValueReference())
1006       addFlag(Buffer, dwarf::DW_AT_reference);
1007
1008     if (CTy.isRValueReference())
1009       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1010   } break;
1011   case dwarf::DW_TAG_structure_type:
1012   case dwarf::DW_TAG_union_type:
1013   case dwarf::DW_TAG_class_type: {
1014     // Add elements to structure type.
1015     DIArray Elements = CTy.getElements();
1016     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1017       DIDescriptor Element = Elements.getElement(i);
1018       if (Element.isSubprogram())
1019         getOrCreateSubprogramDIE(DISubprogram(Element));
1020       else if (Element.isDerivedType()) {
1021         DIDerivedType DDTy(Element);
1022         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1023           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1024           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1025                   dwarf::DW_AT_friend);
1026         } else if (DDTy.isStaticMember()) {
1027           getOrCreateStaticMemberDIE(DDTy);
1028         } else {
1029           constructMemberDIE(Buffer, DDTy);
1030         }
1031       } else if (Element.isObjCProperty()) {
1032         DIObjCProperty Property(Element);
1033         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1034         StringRef PropertyName = Property.getObjCPropertyName();
1035         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1036         if (Property.getType())
1037           addType(ElemDie, Property.getType());
1038         addSourceLine(ElemDie, Property);
1039         StringRef GetterName = Property.getObjCPropertyGetterName();
1040         if (!GetterName.empty())
1041           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1042         StringRef SetterName = Property.getObjCPropertySetterName();
1043         if (!SetterName.empty())
1044           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1045         unsigned PropertyAttributes = 0;
1046         if (Property.isReadOnlyObjCProperty())
1047           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1048         if (Property.isReadWriteObjCProperty())
1049           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1050         if (Property.isAssignObjCProperty())
1051           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1052         if (Property.isRetainObjCProperty())
1053           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1054         if (Property.isCopyObjCProperty())
1055           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1056         if (Property.isNonAtomicObjCProperty())
1057           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1058         if (PropertyAttributes)
1059           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1060                   PropertyAttributes);
1061
1062         DIEEntry *Entry = getDIEEntry(Element);
1063         if (!Entry) {
1064           Entry = createDIEEntry(ElemDie);
1065           insertDIEEntry(Element, Entry);
1066         }
1067       } else
1068         continue;
1069     }
1070
1071     if (CTy.isAppleBlockExtension())
1072       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1073
1074     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1075     // inside C++ composite types to point to the base class with the vtable.
1076     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1077     if (ContainingType)
1078       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1079                   *getOrCreateTypeDIE(ContainingType));
1080
1081     if (CTy.isObjcClassComplete())
1082       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1083
1084     // Add template parameters to a class, structure or union types.
1085     // FIXME: The support isn't in the metadata for this yet.
1086     if (Tag == dwarf::DW_TAG_class_type ||
1087         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1088       addTemplateParams(Buffer, CTy.getTemplateParams());
1089
1090     break;
1091   }
1092   default:
1093     break;
1094   }
1095
1096   // Add name if not anonymous or intermediate type.
1097   if (!Name.empty())
1098     addString(Buffer, dwarf::DW_AT_name, Name);
1099
1100   if (Tag == dwarf::DW_TAG_enumeration_type ||
1101       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1102       Tag == dwarf::DW_TAG_union_type) {
1103     // Add size if non-zero (derived types might be zero-sized.)
1104     // TODO: Do we care about size for enum forward declarations?
1105     if (Size)
1106       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1107     else if (!CTy.isForwardDecl())
1108       // Add zero size if it is not a forward declaration.
1109       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1110
1111     // If we're a forward decl, say so.
1112     if (CTy.isForwardDecl())
1113       addFlag(Buffer, dwarf::DW_AT_declaration);
1114
1115     // Add source line info if available.
1116     if (!CTy.isForwardDecl())
1117       addSourceLine(Buffer, CTy);
1118
1119     // No harm in adding the runtime language to the declaration.
1120     unsigned RLang = CTy.getRunTimeLang();
1121     if (RLang)
1122       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1123               RLang);
1124   }
1125 }
1126
1127 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1128 /// DITemplateTypeParameter.
1129 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1130                                                   DITemplateTypeParameter TP) {
1131   DIE &ParamDIE =
1132       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1133   // Add the type if it exists, it could be void and therefore no type.
1134   if (TP.getType())
1135     addType(ParamDIE, resolve(TP.getType()));
1136   if (!TP.getName().empty())
1137     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1138 }
1139
1140 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1141 /// DITemplateValueParameter.
1142 void
1143 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1144                                               DITemplateValueParameter VP) {
1145   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1146
1147   // Add the type if there is one, template template and template parameter
1148   // packs will not have a type.
1149   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1150     addType(ParamDIE, resolve(VP.getType()));
1151   if (!VP.getName().empty())
1152     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1153   if (Metadata *Val = VP.getValue()) {
1154     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1155       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1156     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1157       // For declaration non-type template parameters (such as global values and
1158       // functions)
1159       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1160       addOpAddress(*Loc, Asm->getSymbol(GV));
1161       // Emit DW_OP_stack_value to use the address as the immediate value of the
1162       // parameter, rather than a pointer to it.
1163       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1164       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1165     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1166       assert(isa<MDString>(Val));
1167       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1168                 cast<MDString>(Val)->getString());
1169     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1170       assert(isa<MDNode>(Val));
1171       DIArray A(cast<MDNode>(Val));
1172       addTemplateParams(ParamDIE, A);
1173     }
1174   }
1175 }
1176
1177 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1178 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1179   // Construct the context before querying for the existence of the DIE in case
1180   // such construction creates the DIE.
1181   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1182
1183   if (DIE *NDie = getDIE(NS))
1184     return NDie;
1185   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1186
1187   StringRef Name = NS.getName();
1188   if (!Name.empty())
1189     addString(NDie, dwarf::DW_AT_name, NS.getName());
1190   else
1191     Name = "(anonymous namespace)";
1192   DD->addAccelNamespace(Name, NDie);
1193   addGlobalName(Name, NDie, NS.getContext());
1194   addSourceLine(NDie, NS);
1195   return &NDie;
1196 }
1197
1198 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1199 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1200   // Construct the context before querying for the existence of the DIE in case
1201   // such construction creates the DIE (as is the case for member function
1202   // declarations).
1203   DIE *ContextDIE =
1204       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1205
1206   if (DIE *SPDie = getDIE(SP))
1207     return SPDie;
1208
1209   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1210     if (!Minimal) {
1211       // Add subprogram definitions to the CU die directly.
1212       ContextDIE = &getUnitDie();
1213       // Build the decl now to ensure it precedes the definition.
1214       getOrCreateSubprogramDIE(SPDecl);
1215     }
1216   }
1217
1218   // DW_TAG_inlined_subroutine may refer to this DIE.
1219   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1220
1221   // Stop here and fill this in later, depending on whether or not this
1222   // subprogram turns out to have inlined instances or not.
1223   if (SP.isDefinition())
1224     return &SPDie;
1225
1226   applySubprogramAttributes(SP, SPDie);
1227   return &SPDie;
1228 }
1229
1230 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1231                                                     DIE &SPDie) {
1232   DIE *DeclDie = nullptr;
1233   StringRef DeclLinkageName;
1234   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1235     DeclDie = getDIE(SPDecl);
1236     assert(DeclDie && "This DIE should've already been constructed when the "
1237                       "definition DIE was created in "
1238                       "getOrCreateSubprogramDIE");
1239     DeclLinkageName = SPDecl.getLinkageName();
1240   }
1241
1242   // Add function template parameters.
1243   addTemplateParams(SPDie, SP.getTemplateParams());
1244
1245   // Add the linkage name if we have one and it isn't in the Decl.
1246   StringRef LinkageName = SP.getLinkageName();
1247   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1248           LinkageName == DeclLinkageName) &&
1249          "decl has a linkage name and it is different");
1250   if (!LinkageName.empty() && DeclLinkageName.empty())
1251     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1252               GlobalValue::getRealLinkageName(LinkageName));
1253
1254   if (!DeclDie)
1255     return false;
1256
1257   // Refer to the function declaration where all the other attributes will be
1258   // found.
1259   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1260   return true;
1261 }
1262
1263 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1264                                           bool Minimal) {
1265   if (!Minimal)
1266     if (applySubprogramDefinitionAttributes(SP, SPDie))
1267       return;
1268
1269   // Constructors and operators for anonymous aggregates do not have names.
1270   if (!SP.getName().empty())
1271     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1272
1273   // Skip the rest of the attributes under -gmlt to save space.
1274   if (Minimal)
1275     return;
1276
1277   addSourceLine(SPDie, SP);
1278
1279   // Add the prototype if we have a prototype and we have a C like
1280   // language.
1281   uint16_t Language = getLanguage();
1282   if (SP.isPrototyped() &&
1283       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1284        Language == dwarf::DW_LANG_ObjC))
1285     addFlag(SPDie, dwarf::DW_AT_prototyped);
1286
1287   DISubroutineType SPTy = SP.getType();
1288   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1289          "the type of a subprogram should be a subroutine");
1290
1291   DITypeArray Args = SPTy.getTypeArray();
1292   // Add a return type. If this is a type like a C/C++ void type we don't add a
1293   // return type.
1294   if (resolve(Args.getElement(0)))
1295     addType(SPDie, DIType(resolve(Args.getElement(0))));
1296
1297   unsigned VK = SP.getVirtuality();
1298   if (VK) {
1299     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1300     DIELoc *Block = getDIELoc();
1301     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1302     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1303     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1304     ContainingTypeMap.insert(
1305         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1306   }
1307
1308   if (!SP.isDefinition()) {
1309     addFlag(SPDie, dwarf::DW_AT_declaration);
1310
1311     // Add arguments. Do not add arguments for subprogram definition. They will
1312     // be handled while processing variables.
1313     constructSubprogramArguments(SPDie, Args);
1314   }
1315
1316   if (SP.isArtificial())
1317     addFlag(SPDie, dwarf::DW_AT_artificial);
1318
1319   if (!SP.isLocalToUnit())
1320     addFlag(SPDie, dwarf::DW_AT_external);
1321
1322   if (SP.isOptimized())
1323     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1324
1325   if (unsigned isa = Asm->getISAEncoding()) {
1326     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1327   }
1328
1329   if (SP.isLValueReference())
1330     addFlag(SPDie, dwarf::DW_AT_reference);
1331
1332   if (SP.isRValueReference())
1333     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1334
1335   if (SP.isProtected())
1336     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1337             dwarf::DW_ACCESS_protected);
1338   else if (SP.isPrivate())
1339     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1340             dwarf::DW_ACCESS_private);
1341   else if (SP.isPublic())
1342     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1343             dwarf::DW_ACCESS_public);
1344
1345   if (SP.isExplicit())
1346     addFlag(SPDie, dwarf::DW_AT_explicit);
1347 }
1348
1349 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1350 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1351   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1352   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1353
1354   // The LowerBound value defines the lower bounds which is typically zero for
1355   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1356   // Count == -1 then the array is unbounded and we do not emit
1357   // DW_AT_lower_bound and DW_AT_count attributes.
1358   int64_t LowerBound = SR.getLo();
1359   int64_t DefaultLowerBound = getDefaultLowerBound();
1360   int64_t Count = SR.getCount();
1361
1362   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1363     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1364
1365   if (Count != -1)
1366     // FIXME: An unbounded array should reference the expression that defines
1367     // the array.
1368     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1369 }
1370
1371 DIE *DwarfUnit::getIndexTyDie() {
1372   if (IndexTyDie)
1373     return IndexTyDie;
1374   // Construct an integer type to use for indexes.
1375   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1376   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1377   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1378   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1379           dwarf::DW_ATE_unsigned);
1380   return IndexTyDie;
1381 }
1382
1383 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1384 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1385   if (CTy.isVector())
1386     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1387
1388   // Emit the element type.
1389   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1390
1391   // Get an anonymous type for index type.
1392   // FIXME: This type should be passed down from the front end
1393   // as different languages may have different sizes for indexes.
1394   DIE *IdxTy = getIndexTyDie();
1395
1396   // Add subranges to array type.
1397   DIArray Elements = CTy.getElements();
1398   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1399     DIDescriptor Element = Elements.getElement(i);
1400     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1401       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1402   }
1403 }
1404
1405 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1406 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1407   DIArray Elements = CTy.getElements();
1408
1409   // Add enumerators to enumeration type.
1410   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1411     DIEnumerator Enum(Elements.getElement(i));
1412     if (Enum.isEnumerator()) {
1413       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1414       StringRef Name = Enum.getName();
1415       addString(Enumerator, dwarf::DW_AT_name, Name);
1416       int64_t Value = Enum.getEnumValue();
1417       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1418               Value);
1419     }
1420   }
1421   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1422   if (DTy) {
1423     addType(Buffer, DTy);
1424     addFlag(Buffer, dwarf::DW_AT_enum_class);
1425   }
1426 }
1427
1428 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1429 /// vtables.
1430 void DwarfUnit::constructContainingTypeDIEs() {
1431   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1432                                                  CE = ContainingTypeMap.end();
1433        CI != CE; ++CI) {
1434     DIE &SPDie = *CI->first;
1435     DIDescriptor D(CI->second);
1436     if (!D)
1437       continue;
1438     DIE *NDie = getDIE(D);
1439     if (!NDie)
1440       continue;
1441     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1442   }
1443 }
1444
1445 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1446 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1447   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1448   StringRef Name = DT.getName();
1449   if (!Name.empty())
1450     addString(MemberDie, dwarf::DW_AT_name, Name);
1451
1452   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1453
1454   addSourceLine(MemberDie, DT);
1455
1456   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1457
1458     // For C++, virtual base classes are not at fixed offset. Use following
1459     // expression to extract appropriate offset from vtable.
1460     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1461
1462     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1463     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1464     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1465     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1466     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1467     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1468     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1469     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1470
1471     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1472   } else {
1473     uint64_t Size = DT.getSizeInBits();
1474     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1475     uint64_t OffsetInBytes;
1476
1477     if (Size != FieldSize) {
1478       // Handle bitfield, assume bytes are 8 bits.
1479       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1480       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1481
1482       uint64_t Offset = DT.getOffsetInBits();
1483       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1484       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1485       uint64_t FieldOffset = (HiMark - FieldSize);
1486       Offset -= FieldOffset;
1487
1488       // Maybe we need to work from the other end.
1489       if (Asm->getDataLayout().isLittleEndian())
1490         Offset = FieldSize - (Offset + Size);
1491       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1492
1493       // Here DW_AT_data_member_location points to the anonymous
1494       // field that includes this bit field.
1495       OffsetInBytes = FieldOffset >> 3;
1496     } else
1497       // This is not a bitfield.
1498       OffsetInBytes = DT.getOffsetInBits() >> 3;
1499
1500     if (DD->getDwarfVersion() <= 2) {
1501       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1502       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1503       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1504       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1505     } else
1506       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1507               OffsetInBytes);
1508   }
1509
1510   if (DT.isProtected())
1511     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1512             dwarf::DW_ACCESS_protected);
1513   else if (DT.isPrivate())
1514     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1515             dwarf::DW_ACCESS_private);
1516   // Otherwise C++ member and base classes are considered public.
1517   else if (DT.isPublic())
1518     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1519             dwarf::DW_ACCESS_public);
1520   if (DT.isVirtual())
1521     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1522             dwarf::DW_VIRTUALITY_virtual);
1523
1524   // Objective-C properties.
1525   if (MDNode *PNode = DT.getObjCProperty())
1526     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1527       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1528                          PropertyDie);
1529
1530   if (DT.isArtificial())
1531     addFlag(MemberDie, dwarf::DW_AT_artificial);
1532 }
1533
1534 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1535 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1536   if (!DT.Verify())
1537     return nullptr;
1538
1539   // Construct the context before querying for the existence of the DIE in case
1540   // such construction creates the DIE.
1541   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1542   assert(dwarf::isType(ContextDIE->getTag()) &&
1543          "Static member should belong to a type.");
1544
1545   if (DIE *StaticMemberDIE = getDIE(DT))
1546     return StaticMemberDIE;
1547
1548   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1549
1550   DIType Ty = resolve(DT.getTypeDerivedFrom());
1551
1552   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1553   addType(StaticMemberDIE, Ty);
1554   addSourceLine(StaticMemberDIE, DT);
1555   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1556   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1557
1558   // FIXME: We could omit private if the parent is a class_type, and
1559   // public if the parent is something else.
1560   if (DT.isProtected())
1561     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1562             dwarf::DW_ACCESS_protected);
1563   else if (DT.isPrivate())
1564     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1565             dwarf::DW_ACCESS_private);
1566   else if (DT.isPublic())
1567     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1568             dwarf::DW_ACCESS_public);
1569
1570   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1571     addConstantValue(StaticMemberDIE, CI, Ty);
1572   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1573     addConstantFPValue(StaticMemberDIE, CFP);
1574
1575   return &StaticMemberDIE;
1576 }
1577
1578 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1579   // Emit size of content not including length itself
1580   Asm->OutStreamer.AddComment("Length of Unit");
1581   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1582
1583   Asm->OutStreamer.AddComment("DWARF version number");
1584   Asm->EmitInt16(DD->getDwarfVersion());
1585   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1586   // We share one abbreviations table across all units so it's always at the
1587   // start of the section. Use a relocatable offset where needed to ensure
1588   // linking doesn't invalidate that offset.
1589   if (ASectionSym)
1590     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1591   else
1592     // Use a constant value when no symbol is provided.
1593     Asm->EmitInt32(0);
1594   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1595   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1596 }
1597
1598 void DwarfUnit::initSection(const MCSection *Section) {
1599   assert(!this->Section);
1600   this->Section = Section;
1601 }
1602
1603 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1604   DwarfUnit::emitHeader(ASectionSym);
1605   Asm->OutStreamer.AddComment("Type Signature");
1606   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1607   Asm->OutStreamer.AddComment("Type DIE Offset");
1608   // In a skeleton type unit there is no type DIE so emit a zero offset.
1609   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1610                                 sizeof(Ty->getOffset()));
1611 }
1612
1613 bool DwarfTypeUnit::isDwoUnit() const {
1614   // Since there are no skeleton type units, all type units are dwo type units
1615   // when split DWARF is being used.
1616   return DD->useSplitDwarf();
1617 }