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