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