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