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