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