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