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.getLineNumber(), SP.getFilename(), SP.getDirectory());
 420 }
 421
 422 /// addSourceLine - Add location information to specified debug information
 423 /// entry.
 424 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
 425   assert(Ty);
 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.getLineNumber(), 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.isValid() && "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(Buffer, dwarf::DW_AT_containing_type,
 975                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
 976   // Add source line info if available and TyDesc is not a forward declaration.
 977   if (!DTy.isForwardDecl())
 978     addSourceLine(Buffer, DTy);
 979 }
 980
 981 /// constructSubprogramArguments - Construct function argument DIEs.
 982 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
 983   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 984     DIType Ty = resolve(Args[i]);
 985     if (!Ty) {
 986       assert(i == N-1 && "Unspecified parameter must be the last argument");
 987       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 988     } else {
 989       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 990       addType(Arg, Ty);
 991       if (Ty.isArtificial())
 992         addFlag(Arg, dwarf::DW_AT_artificial);
 993     }
 994   }
 995 }
 996
 997 /// constructTypeDIE - Construct type DIE from DICompositeType.
 998 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 999   // Add name if not anonymous or intermediate type.
1000   StringRef Name = CTy.getName();
1001
1002   uint64_t Size = CTy.getSizeInBits() >> 3;
1003   uint16_t Tag = Buffer.getTag();
1004
1005   switch (Tag) {
1006   case dwarf::DW_TAG_array_type:
1007     constructArrayTypeDIE(Buffer, CTy);
1008     break;
1009   case dwarf::DW_TAG_enumeration_type:
1010     constructEnumTypeDIE(Buffer, CTy);
1011     break;
1012   case dwarf::DW_TAG_subroutine_type: {
1013     // Add return type. A void return won't have a type.
1014     auto Elements = cast<MDSubroutineType>(CTy)->getTypeArray();
1015     if (Elements.size())
1016       if (auto RTy = resolve(Elements[0]))
1017         addType(Buffer, RTy);
1018
1019     bool isPrototyped = true;
1020     if (Elements.size() == 2 && !Elements[1])
1021       isPrototyped = false;
1022
1023     constructSubprogramArguments(Buffer, Elements);
1024
1025     // Add prototype flag if we're dealing with a C language and the
1026     // function has been prototyped.
1027     uint16_t Language = getLanguage();
1028     if (isPrototyped &&
1029         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1030          Language == dwarf::DW_LANG_ObjC))
1031       addFlag(Buffer, dwarf::DW_AT_prototyped);
1032
1033     if (CTy.isLValueReference())
1034       addFlag(Buffer, dwarf::DW_AT_reference);
1035
1036     if (CTy.isRValueReference())
1037       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1038   } break;
1039   case dwarf::DW_TAG_structure_type:
1040   case dwarf::DW_TAG_union_type:
1041   case dwarf::DW_TAG_class_type: {
1042     // Add elements to structure type.
1043     DIArray Elements = CTy.getElements();
1044     for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1045       DIDescriptor Element = Elements[i];
1046       if (!Element)
1047         continue;
1048       if (auto *SP = dyn_cast<MDSubprogram>(Element))
1049         getOrCreateSubprogramDIE(SP);
1050       else if (DIDerivedType DDTy = dyn_cast<MDDerivedTypeBase>(Element)) {
1051         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1052           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1053           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1054                   dwarf::DW_AT_friend);
1055         } else if (DDTy.isStaticMember()) {
1056           getOrCreateStaticMemberDIE(DDTy);
1057         } else {
1058           constructMemberDIE(Buffer, DDTy);
1059         }
1060       } else if (DIObjCProperty Property = dyn_cast<MDObjCProperty>(Element)) {
1061         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
1062         StringRef PropertyName = Property->getName();
1063         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1064         if (Property->getType())
1065           addType(ElemDie, Property->getType());
1066         addSourceLine(ElemDie, Property);
1067         StringRef GetterName = Property->getGetterName();
1068         if (!GetterName.empty())
1069           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1070         StringRef SetterName = Property->getSetterName();
1071         if (!SetterName.empty())
1072           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1073         if (unsigned PropertyAttributes = Property->getAttributes())
1074           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1075                   PropertyAttributes);
1076
1077         DIEEntry *Entry = getDIEEntry(Element);
1078         if (!Entry) {
1079           Entry = createDIEEntry(ElemDie);
1080           insertDIEEntry(Element, Entry);
1081         }
1082       }
1083     }
1084
1085     if (CTy.isAppleBlockExtension())
1086       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1087
1088     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1089     // inside C++ composite types to point to the base class with the vtable.
1090     if (DICompositeType ContainingType =
1091             dyn_cast_or_null<MDCompositeType>(resolve(CTy.getContainingType())))
1092       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1093                   *getOrCreateTypeDIE(ContainingType));
1094
1095     if (CTy.isObjcClassComplete())
1096       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1097
1098     // Add template parameters to a class, structure or union types.
1099     // FIXME: The support isn't in the metadata for this yet.
1100     if (Tag == dwarf::DW_TAG_class_type ||
1101         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1102       addTemplateParams(Buffer, CTy.getTemplateParams());
1103
1104     break;
1105   }
1106   default:
1107     break;
1108   }
1109
1110   // Add name if not anonymous or intermediate type.
1111   if (!Name.empty())
1112     addString(Buffer, dwarf::DW_AT_name, Name);
1113
1114   if (Tag == dwarf::DW_TAG_enumeration_type ||
1115       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1116       Tag == dwarf::DW_TAG_union_type) {
1117     // Add size if non-zero (derived types might be zero-sized.)
1118     // TODO: Do we care about size for enum forward declarations?
1119     if (Size)
1120       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1121     else if (!CTy.isForwardDecl())
1122       // Add zero size if it is not a forward declaration.
1123       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1124
1125     // If we're a forward decl, say so.
1126     if (CTy.isForwardDecl())
1127       addFlag(Buffer, dwarf::DW_AT_declaration);
1128
1129     // Add source line info if available.
1130     if (!CTy.isForwardDecl())
1131       addSourceLine(Buffer, CTy);
1132
1133     // No harm in adding the runtime language to the declaration.
1134     unsigned RLang = CTy.getRunTimeLang();
1135     if (RLang)
1136       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1137               RLang);
1138   }
1139 }
1140
1141 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1142 /// DITemplateTypeParameter.
1143 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1144                                                   DITemplateTypeParameter TP) {
1145   DIE &ParamDIE =
1146       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1147   // Add the type if it exists, it could be void and therefore no type.
1148   if (TP.getType())
1149     addType(ParamDIE, resolve(TP.getType()));
1150   if (!TP.getName().empty())
1151     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1152 }
1153
1154 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1155 /// DITemplateValueParameter.
1156 void
1157 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1158                                               DITemplateValueParameter VP) {
1159   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1160
1161   // Add the type if there is one, template template and template parameter
1162   // packs will not have a type.
1163   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1164     addType(ParamDIE, resolve(VP.getType()));
1165   if (!VP.getName().empty())
1166     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1167   if (Metadata *Val = VP.getValue()) {
1168     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1169       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1170     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1171       // For declaration non-type template parameters (such as global values and
1172       // functions)
1173       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1174       addOpAddress(*Loc, Asm->getSymbol(GV));
1175       // Emit DW_OP_stack_value to use the address as the immediate value of the
1176       // parameter, rather than a pointer to it.
1177       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1178       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1179     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1180       assert(isa<MDString>(Val));
1181       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1182                 cast<MDString>(Val)->getString());
1183     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1184       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1185     }
1186   }
1187 }
1188
1189 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1190 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1191   // Construct the context before querying for the existence of the DIE in case
1192   // such construction creates the DIE.
1193   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1194
1195   if (DIE *NDie = getDIE(NS))
1196     return NDie;
1197   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1198
1199   StringRef Name = NS.getName();
1200   if (!Name.empty())
1201     addString(NDie, dwarf::DW_AT_name, NS.getName());
1202   else
1203     Name = "(anonymous namespace)";
1204   DD->addAccelNamespace(Name, NDie);
1205   addGlobalName(Name, NDie, NS.getContext());
1206   addSourceLine(NDie, NS);
1207   return &NDie;
1208 }
1209
1210 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1211 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1212   // Construct the context before querying for the existence of the DIE in case
1213   // such construction creates the DIE (as is the case for member function
1214   // declarations).
1215   DIE *ContextDIE =
1216       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1217
1218   if (DIE *SPDie = getDIE(SP))
1219     return SPDie;
1220
1221   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1222     if (!Minimal) {
1223       // Add subprogram definitions to the CU die directly.
1224       ContextDIE = &getUnitDie();
1225       // Build the decl now to ensure it precedes the definition.
1226       getOrCreateSubprogramDIE(SPDecl);
1227     }
1228   }
1229
1230   // DW_TAG_inlined_subroutine may refer to this DIE.
1231   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1232
1233   // Stop here and fill this in later, depending on whether or not this
1234   // subprogram turns out to have inlined instances or not.
1235   if (SP.isDefinition())
1236     return &SPDie;
1237
1238   applySubprogramAttributes(SP, SPDie);
1239   return &SPDie;
1240 }
1241
1242 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1243                                                     DIE &SPDie) {
1244   DIE *DeclDie = nullptr;
1245   StringRef DeclLinkageName;
1246   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1247     DeclDie = getDIE(SPDecl);
1248     assert(DeclDie && "This DIE should've already been constructed when the "
1249                       "definition DIE was created in "
1250                       "getOrCreateSubprogramDIE");
1251     DeclLinkageName = SPDecl.getLinkageName();
1252   }
1253
1254   // Add function template parameters.
1255   addTemplateParams(SPDie, SP.getTemplateParams());
1256
1257   // Add the linkage name if we have one and it isn't in the Decl.
1258   StringRef LinkageName = SP.getLinkageName();
1259   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1260           LinkageName == DeclLinkageName) &&
1261          "decl has a linkage name and it is different");
1262   if (DeclLinkageName.empty())
1263     addLinkageName(SPDie, LinkageName);
1264
1265   if (!DeclDie)
1266     return false;
1267
1268   // Refer to the function declaration where all the other attributes will be
1269   // found.
1270   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1271   return true;
1272 }
1273
1274 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1275                                           bool Minimal) {
1276   if (!Minimal)
1277     if (applySubprogramDefinitionAttributes(SP, SPDie))
1278       return;
1279
1280   // Constructors and operators for anonymous aggregates do not have names.
1281   if (!SP.getName().empty())
1282     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1283
1284   // Skip the rest of the attributes under -gmlt to save space.
1285   if (Minimal)
1286     return;
1287
1288   addSourceLine(SPDie, SP);
1289
1290   // Add the prototype if we have a prototype and we have a C like
1291   // language.
1292   uint16_t Language = getLanguage();
1293   if (SP.isPrototyped() &&
1294       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1295        Language == dwarf::DW_LANG_ObjC))
1296     addFlag(SPDie, dwarf::DW_AT_prototyped);
1297
1298   DISubroutineType SPTy = SP.getType();
1299   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1300          "the type of a subprogram should be a subroutine");
1301
1302   auto Args = SPTy.getTypeArray();
1303   // Add a return type. If this is a type like a C/C++ void type we don't add a
1304   // return type.
1305   if (Args.size())
1306     if (auto Ty = resolve(Args[0]))
1307       addType(SPDie, Ty);
1308
1309   unsigned VK = SP.getVirtuality();
1310   if (VK) {
1311     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1312     DIELoc *Block = getDIELoc();
1313     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1314     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1315     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1316     ContainingTypeMap.insert(
1317         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1318   }
1319
1320   if (!SP.isDefinition()) {
1321     addFlag(SPDie, dwarf::DW_AT_declaration);
1322
1323     // Add arguments. Do not add arguments for subprogram definition. They will
1324     // be handled while processing variables.
1325     constructSubprogramArguments(SPDie, Args);
1326   }
1327
1328   if (SP.isArtificial())
1329     addFlag(SPDie, dwarf::DW_AT_artificial);
1330
1331   if (!SP.isLocalToUnit())
1332     addFlag(SPDie, dwarf::DW_AT_external);
1333
1334   if (SP.isOptimized())
1335     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1336
1337   if (unsigned isa = Asm->getISAEncoding())
1338     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1339
1340   if (SP.isLValueReference())
1341     addFlag(SPDie, dwarf::DW_AT_reference);
1342
1343   if (SP.isRValueReference())
1344     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1345
1346   if (SP.isProtected())
1347     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1348             dwarf::DW_ACCESS_protected);
1349   else if (SP.isPrivate())
1350     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1351             dwarf::DW_ACCESS_private);
1352   else if (SP.isPublic())
1353     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1354             dwarf::DW_ACCESS_public);
1355
1356   if (SP.isExplicit())
1357     addFlag(SPDie, dwarf::DW_AT_explicit);
1358 }
1359
1360 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1361 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1362   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1363   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1364
1365   // The LowerBound value defines the lower bounds which is typically zero for
1366   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1367   // Count == -1 then the array is unbounded and we do not emit
1368   // DW_AT_lower_bound and DW_AT_count attributes.
1369   int64_t LowerBound = SR.getLo();
1370   int64_t DefaultLowerBound = getDefaultLowerBound();
1371   int64_t Count = SR.getCount();
1372
1373   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1374     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1375
1376   if (Count != -1)
1377     // FIXME: An unbounded array should reference the expression that defines
1378     // the array.
1379     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1380 }
1381
1382 DIE *DwarfUnit::getIndexTyDie() {
1383   if (IndexTyDie)
1384     return IndexTyDie;
1385   // Construct an integer type to use for indexes.
1386   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1387   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1388   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1389   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1390           dwarf::DW_ATE_unsigned);
1391   return IndexTyDie;
1392 }
1393
1394 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1395 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1396   if (CTy.isVector())
1397     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1398
1399   // Emit the element type.
1400   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1401
1402   // Get an anonymous type for index type.
1403   // FIXME: This type should be passed down from the front end
1404   // as different languages may have different sizes for indexes.
1405   DIE *IdxTy = getIndexTyDie();
1406
1407   // Add subranges to array type.
1408   DIArray Elements = CTy.getElements();
1409   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1410     DIDescriptor Element = Elements[i];
1411     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1412       constructSubrangeDIE(Buffer, cast<MDSubrange>(Element), IdxTy);
1413   }
1414 }
1415
1416 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1417 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1418   DIArray Elements = CTy.getElements();
1419
1420   // Add enumerators to enumeration type.
1421   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1422     DIEnumerator Enum = dyn_cast_or_null<MDEnumerator>(Elements[i]);
1423     if (Enum) {
1424       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1425       StringRef Name = Enum.getName();
1426       addString(Enumerator, dwarf::DW_AT_name, Name);
1427       int64_t Value = Enum.getEnumValue();
1428       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1429               Value);
1430     }
1431   }
1432   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1433   if (DTy) {
1434     addType(Buffer, DTy);
1435     addFlag(Buffer, dwarf::DW_AT_enum_class);
1436   }
1437 }
1438
1439 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1440 /// vtables.
1441 void DwarfUnit::constructContainingTypeDIEs() {
1442   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1443                                                  CE = ContainingTypeMap.end();
1444        CI != CE; ++CI) {
1445     DIE &SPDie = *CI->first;
1446     DIDescriptor D(CI->second);
1447     if (!D)
1448       continue;
1449     DIE *NDie = getDIE(D);
1450     if (!NDie)
1451       continue;
1452     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1453   }
1454 }
1455
1456 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1457 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1458   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1459   StringRef Name = DT.getName();
1460   if (!Name.empty())
1461     addString(MemberDie, dwarf::DW_AT_name, Name);
1462
1463   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1464
1465   addSourceLine(MemberDie, DT);
1466
1467   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1468
1469     // For C++, virtual base classes are not at fixed offset. Use following
1470     // expression to extract appropriate offset from vtable.
1471     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1472
1473     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1474     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1475     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1476     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1477     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1478     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1479     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1480     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1481
1482     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1483   } else {
1484     uint64_t Size = DT.getSizeInBits();
1485     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1486     uint64_t OffsetInBytes;
1487
1488     if (FieldSize && Size != FieldSize) {
1489       // Handle bitfield, assume bytes are 8 bits.
1490       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1491       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1492
1493       uint64_t Offset = DT.getOffsetInBits();
1494       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1495       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1496       uint64_t FieldOffset = (HiMark - FieldSize);
1497       Offset -= FieldOffset;
1498
1499       // Maybe we need to work from the other end.
1500       if (Asm->getDataLayout().isLittleEndian())
1501         Offset = FieldSize - (Offset + Size);
1502       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1503
1504       // Here DW_AT_data_member_location points to the anonymous
1505       // field that includes this bit field.
1506       OffsetInBytes = FieldOffset >> 3;
1507     } else
1508       // This is not a bitfield.
1509       OffsetInBytes = DT.getOffsetInBits() >> 3;
1510
1511     if (DD->getDwarfVersion() <= 2) {
1512       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1513       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1514       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1515       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1516     } else
1517       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1518               OffsetInBytes);
1519   }
1520
1521   if (DT.isProtected())
1522     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1523             dwarf::DW_ACCESS_protected);
1524   else if (DT.isPrivate())
1525     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1526             dwarf::DW_ACCESS_private);
1527   // Otherwise C++ member and base classes are considered public.
1528   else if (DT.isPublic())
1529     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1530             dwarf::DW_ACCESS_public);
1531   if (DT.isVirtual())
1532     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1533             dwarf::DW_VIRTUALITY_virtual);
1534
1535   // Objective-C properties.
1536   if (MDNode *PNode = DT.getObjCProperty())
1537     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1538       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1539                          PropertyDie);
1540
1541   if (DT.isArtificial())
1542     addFlag(MemberDie, dwarf::DW_AT_artificial);
1543 }
1544
1545 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1546 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1547   if (!DT)
1548     return nullptr;
1549
1550   // Construct the context before querying for the existence of the DIE in case
1551   // such construction creates the DIE.
1552   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1553   assert(dwarf::isType(ContextDIE->getTag()) &&
1554          "Static member should belong to a type.");
1555
1556   if (DIE *StaticMemberDIE = getDIE(DT))
1557     return StaticMemberDIE;
1558
1559   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1560
1561   DIType Ty = resolve(DT.getTypeDerivedFrom());
1562
1563   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1564   addType(StaticMemberDIE, Ty);
1565   addSourceLine(StaticMemberDIE, DT);
1566   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1567   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1568
1569   // FIXME: We could omit private if the parent is a class_type, and
1570   // public if the parent is something else.
1571   if (DT.isProtected())
1572     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1573             dwarf::DW_ACCESS_protected);
1574   else if (DT.isPrivate())
1575     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1576             dwarf::DW_ACCESS_private);
1577   else if (DT.isPublic())
1578     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1579             dwarf::DW_ACCESS_public);
1580
1581   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1582     addConstantValue(StaticMemberDIE, CI, Ty);
1583   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1584     addConstantFPValue(StaticMemberDIE, CFP);
1585
1586   return &StaticMemberDIE;
1587 }
1588
1589 void DwarfUnit::emitHeader(bool UseOffsets) {
1590   // Emit size of content not including length itself
1591   Asm->OutStreamer.AddComment("Length of Unit");
1592   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1593
1594   Asm->OutStreamer.AddComment("DWARF version number");
1595   Asm->EmitInt16(DD->getDwarfVersion());
1596   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1597
1598   // We share one abbreviations table across all units so it's always at the
1599   // start of the section. Use a relocatable offset where needed to ensure
1600   // linking doesn't invalidate that offset.
1601   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1602   if (!UseOffsets)
1603     Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1604   else
1605     Asm->EmitInt32(0);
1606
1607   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1608   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1609 }
1610
1611 void DwarfUnit::initSection(const MCSection *Section) {
1612   assert(!this->Section);
1613   this->Section = Section;
1614 }
1615
1616 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1617   DwarfUnit::emitHeader(UseOffsets);
1618   Asm->OutStreamer.AddComment("Type Signature");
1619   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1620   Asm->OutStreamer.AddComment("Type DIE Offset");
1621   // In a skeleton type unit there is no type DIE so emit a zero offset.
1622   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1623                                 sizeof(Ty->getOffset()));
1624 }
1625
1626 bool DwarfTypeUnit::isDwoUnit() const {
1627   // Since there are no skeleton type units, all type units are dwo type units
1628   // when split DWARF is being used.
1629   return DD->useSplitDwarf();
1630 }