lib/CodeGen/AsmPrinter/DwarfUnit.cpp

   1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for constructing a dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "DwarfUnit.h"
  15 #include "DwarfAccelTable.h"
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfDebug.h"
  18 #include "DwarfExpression.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DIBuilder.h"
  23 #include "llvm/IR/DataLayout.h"
  24 #include "llvm/IR/GlobalVariable.h"
  25 #include "llvm/IR/Instructions.h"
  26 #include "llvm/IR/Mangler.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/MC/MCContext.h"
  29 #include "llvm/MC/MCSection.h"
  30 #include "llvm/MC/MCStreamer.h"
  31 #include "llvm/Support/CommandLine.h"
  32 #include "llvm/Target/TargetFrameLowering.h"
  33 #include "llvm/Target/TargetLoweringObjectFile.h"
  34 #include "llvm/Target/TargetMachine.h"
  35 #include "llvm/Target/TargetRegisterInfo.h"
  36 #include "llvm/Target/TargetSubtargetInfo.h"
  37
  38 using namespace llvm;
  39
  40 #define DEBUG_TYPE "dwarfdebug"
  41
  42 static cl::opt<bool>
  43 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  44                        cl::desc("Generate DWARF4 type units."),
  45                        cl::init(false));
  46
  47 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
  48                                        DIELoc &DIE)
  49     : DwarfExpression(*AP.MF->getSubtarget().getRegisterInfo(),
  50                       AP.getDwarfDebug()->getDwarfVersion()),
  51       AP(AP), DU(DU), DIE(DIE) {}
  52
  53 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
  54   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
  55 }
  56 void DIEDwarfExpression::EmitSigned(int64_t Value) {
  57   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
  58 }
  59 void DIEDwarfExpression::EmitUnsigned(uint64_t Value) {
  60   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
  61 }
  62 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
  63   return MachineReg == TRI.getFrameRegister(*AP.MF);
  64 }
  65
  66
  67 /// Unit - Unit constructor.
  68 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
  69                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
  70     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
  71       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  72   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  73          UnitTag == dwarf::DW_TAG_type_unit);
  74   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  75 }
  76
  77 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
  78                              DwarfDebug *DW, DwarfFile *DWU,
  79                              MCDwarfDwoLineTable *SplitLineTable)
  80     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
  81       CU(CU), SplitLineTable(SplitLineTable) {
  82   if (SplitLineTable)
  83     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  84 }
  85
  86 /// ~Unit - Destructor for compile unit.
  87 DwarfUnit::~DwarfUnit() {
  88   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  89     DIEBlocks[j]->~DIEBlock();
  90   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  91     DIELocs[j]->~DIELoc();
  92 }
  93
  94 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  95 /// information entry.
  96 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
  97   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  98   return Value;
  99 }
 100
 101 /// getDefaultLowerBound - Return the default lower bound for an array. If the
 102 /// DWARF version doesn't handle the language, return -1.
 103 int64_t DwarfUnit::getDefaultLowerBound() const {
 104   switch (getLanguage()) {
 105   default:
 106     break;
 107
 108   case dwarf::DW_LANG_C89:
 109   case dwarf::DW_LANG_C99:
 110   case dwarf::DW_LANG_C:
 111   case dwarf::DW_LANG_C_plus_plus:
 112   case dwarf::DW_LANG_ObjC:
 113   case dwarf::DW_LANG_ObjC_plus_plus:
 114     return 0;
 115
 116   case dwarf::DW_LANG_Fortran77:
 117   case dwarf::DW_LANG_Fortran90:
 118   case dwarf::DW_LANG_Fortran95:
 119     return 1;
 120
 121   // The languages below have valid values only if the DWARF version >= 4.
 122   case dwarf::DW_LANG_Java:
 123   case dwarf::DW_LANG_Python:
 124   case dwarf::DW_LANG_UPC:
 125   case dwarf::DW_LANG_D:
 126     if (dwarf::DWARF_VERSION >= 4)
 127       return 0;
 128     break;
 129
 130   case dwarf::DW_LANG_Ada83:
 131   case dwarf::DW_LANG_Ada95:
 132   case dwarf::DW_LANG_Cobol74:
 133   case dwarf::DW_LANG_Cobol85:
 134   case dwarf::DW_LANG_Modula2:
 135   case dwarf::DW_LANG_Pascal83:
 136   case dwarf::DW_LANG_PLI:
 137     if (dwarf::DWARF_VERSION >= 4)
 138       return 1;
 139     break;
 140
 141   // The languages below have valid values only if the DWARF version >= 5.
 142   case dwarf::DW_LANG_OpenCL:
 143   case dwarf::DW_LANG_Go:
 144   case dwarf::DW_LANG_Haskell:
 145   case dwarf::DW_LANG_C_plus_plus_03:
 146   case dwarf::DW_LANG_C_plus_plus_11:
 147   case dwarf::DW_LANG_OCaml:
 148   case dwarf::DW_LANG_Rust:
 149   case dwarf::DW_LANG_C11:
 150   case dwarf::DW_LANG_Swift:
 151   case dwarf::DW_LANG_Dylan:
 152   case dwarf::DW_LANG_C_plus_plus_14:
 153     if (dwarf::DWARF_VERSION >= 5)
 154       return 0;
 155     break;
 156
 157   case dwarf::DW_LANG_Modula3:
 158   case dwarf::DW_LANG_Julia:
 159   case dwarf::DW_LANG_Fortran03:
 160   case dwarf::DW_LANG_Fortran08:
 161     if (dwarf::DWARF_VERSION >= 5)
 162       return 1;
 163     break;
 164   }
 165
 166   return -1;
 167 }
 168
 169 /// Check whether the DIE for this MDNode can be shared across CUs.
 170 static bool isShareableAcrossCUs(DIDescriptor D) {
 171   // When the MDNode can be part of the type system, the DIE can be shared
 172   // across CUs.
 173   // Combining type units and cross-CU DIE sharing is lower value (since
 174   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 175   // level already) but may be implementable for some value in projects
 176   // building multiple independent libraries with LTO and then linking those
 177   // together.
 178   return (isa<MDType>(D) ||
 179           (isa<MDSubprogram>(D) && !cast<MDSubprogram>(D)->isDefinition())) &&
 180          !GenerateDwarfTypeUnits;
 181 }
 182
 183 /// getDIE - Returns the debug information entry map slot for the
 184 /// specified debug variable. We delegate the request to DwarfDebug
 185 /// when the DIE for this MDNode can be shared across CUs. The mappings
 186 /// will be kept in DwarfDebug for shareable DIEs.
 187 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
 188   if (isShareableAcrossCUs(D))
 189     return DU->getDIE(D);
 190   return MDNodeToDieMap.lookup(D);
 191 }
 192
 193 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
 194 /// when the DIE for this MDNode can be shared across CUs. The mappings
 195 /// will be kept in DwarfDebug for shareable DIEs.
 196 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
 197   if (isShareableAcrossCUs(Desc)) {
 198     DU->insertDIE(Desc, D);
 199     return;
 200   }
 201   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 202 }
 203
 204 /// addFlag - Add a flag that is true.
 205 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 206   if (DD->getDwarfVersion() >= 4)
 207     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
 208   else
 209     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
 210 }
 211
 212 /// addUInt - Add an unsigned integer attribute data and value.
 213 ///
 214 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
 215                         Optional<dwarf::Form> Form, uint64_t Integer) {
 216   if (!Form)
 217     Form = DIEInteger::BestForm(false, Integer);
 218   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
 219                         DIEInteger(Integer);
 220   Die.addValue(Attribute, *Form, Value);
 221 }
 222
 223 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
 224   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 225 }
 226
 227 /// addSInt - Add an signed integer attribute data and value.
 228 ///
 229 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
 230                         Optional<dwarf::Form> Form, int64_t Integer) {
 231   if (!Form)
 232     Form = DIEInteger::BestForm(true, Integer);
 233   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 234   Die.addValue(Attribute, *Form, Value);
 235 }
 236
 237 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 238                         int64_t Integer) {
 239   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 240 }
 241
 242 /// addString - Add a string attribute data and value. We always emit a
 243 /// reference to the string pool instead of immediate strings so that DIEs have
 244 /// more predictable sizes. In the case of split dwarf we emit an index
 245 /// into another table which gets us the static offset into the string
 246 /// table.
 247 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 248                           StringRef String) {
 249   if (!isDwoUnit())
 250     return addLocalString(Die, Attribute, String);
 251
 252   addIndexedString(Die, Attribute, String);
 253 }
 254
 255 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
 256                                  StringRef String) {
 257   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
 258   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
 259   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 260   Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
 261 }
 262
 263 /// addLocalString - Add a string attribute data and value. This is guaranteed
 264 /// to be in the local string pool instead of indirected.
 265 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
 266                                StringRef String) {
 267   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 268   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
 269   DIEValue *Value;
 270   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 271     Value = new (DIEValueAllocator) DIELabel(Symb);
 272   else
 273     Value = new (DIEValueAllocator)
 274         DIEDelta(Symb, TLOF.getDwarfStrSection()->getBeginSymbol());
 275   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 276   Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
 277 }
 278
 279 /// addLabel - Add a Dwarf label attribute data and value.
 280 ///
 281 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
 282                          const MCSymbol *Label) {
 283   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 284   Die.addValue(Attribute, Form, Value);
 285 }
 286
 287 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 288   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 289 }
 290
 291 /// addSectionOffset - Add an offset into a section attribute data and value.
 292 ///
 293 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 294                                  uint64_t Integer) {
 295   if (DD->getDwarfVersion() >= 4)
 296     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 297   else
 298     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 299 }
 300
 301 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
 302   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
 303                         : getCU().getOrCreateSourceID(FileName, DirName);
 304 }
 305
 306 /// addOpAddress - Add a dwarf op address data and value using the
 307 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
 308 ///
 309 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 310   if (!DD->useSplitDwarf()) {
 311     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 312     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 313   } else {
 314     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 315     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 316             DD->getAddressPool().getIndex(Sym));
 317   }
 318 }
 319
 320 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 321                               const MCSymbol *Hi, const MCSymbol *Lo) {
 322   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 323   Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
 324 }
 325
 326 /// addDIEEntry - Add a DIE attribute data and value.
 327 ///
 328 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 329   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
 330 }
 331
 332 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
 333   // Flag the type unit reference as a declaration so that if it contains
 334   // members (implicit special members, static data member definitions, member
 335   // declarations for definitions in this CU, etc) consumers don't get confused
 336   // and think this is a full definition.
 337   addFlag(Die, dwarf::DW_AT_declaration);
 338
 339   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
 340                new (DIEValueAllocator) DIETypeSignature(Type));
 341 }
 342
 343 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 344                             DIEEntry *Entry) {
 345   const DIE *DieCU = Die.getUnitOrNull();
 346   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
 347   if (!DieCU)
 348     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 349     DieCU = &getUnitDie();
 350   if (!EntryCU)
 351     EntryCU = &getUnitDie();
 352   Die.addValue(Attribute,
 353                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 354                Entry);
 355 }
 356
 357 /// Create a DIE with the given Tag, add the DIE to its parent, and
 358 /// call insertDIE if MD is not null.
 359 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
 360   assert(Tag != dwarf::DW_TAG_auto_variable &&
 361          Tag != dwarf::DW_TAG_arg_variable);
 362   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
 363   DIE &Die = *Parent.getChildren().back();
 364   if (N)
 365     insertDIE(N, &Die);
 366   return Die;
 367 }
 368
 369 /// addBlock - Add block data.
 370 ///
 371 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 372   Loc->ComputeSize(Asm);
 373   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 374   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
 375 }
 376
 377 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 378                          DIEBlock *Block) {
 379   Block->ComputeSize(Asm);
 380   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 381   Die.addValue(Attribute, Block->BestForm(), Block);
 382 }
 383
 384 /// addSourceLine - Add location information to specified debug information
 385 /// entry.
 386 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
 387                               StringRef Directory) {
 388   if (Line == 0)
 389     return;
 390
 391   unsigned FileID = getOrCreateSourceID(File, Directory);
 392   assert(FileID && "Invalid file id");
 393   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 394   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 395 }
 396
 397 /// addSourceLine - Add location information to specified debug information
 398 /// entry.
 399 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
 400   assert(V);
 401
 402   addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
 403                 V->getScope()->getDirectory());
 404 }
 405
 406 /// addSourceLine - Add location information to specified debug information
 407 /// entry.
 408 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
 409   assert(G);
 410
 411   addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
 412 }
 413
 414 /// addSourceLine - Add location information to specified debug information
 415 /// entry.
 416 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
 417   assert(SP);
 418
 419   addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
 420 }
 421
 422 /// addSourceLine - Add location information to specified debug information
 423 /// entry.
 424 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
 425   assert(Ty);
 426
 427   addSourceLine(Die, Ty->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 (DITypeRef 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 (unsigned i = 0, e = TParams.size(); i != e; ++i) {
 767     DIDescriptor Element = TParams[i];
 768     if (auto *TTP = dyn_cast<MDTemplateTypeParameter>(Element))
 769       constructTemplateTypeParameterDIE(Buffer, TTP);
 770     else if (auto *TVP = dyn_cast<MDTemplateValueParameter>(Element))
 771       constructTemplateValueParameterDIE(Buffer, TVP);
 772   }
 773 }
 774
 775 /// getOrCreateContextDIE - Get context owner's DIE.
 776 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 777   if (!Context || isa<MDFile>(Context))
 778     return &getUnitDie();
 779   if (auto *T = dyn_cast<MDType>(Context))
 780     return getOrCreateTypeDIE(T);
 781   if (auto *NS = dyn_cast<MDNamespace>(Context))
 782     return getOrCreateNameSpace(NS);
 783   if (auto *SP = dyn_cast<MDSubprogram>(Context))
 784     return getOrCreateSubprogramDIE(SP);
 785   return getDIE(Context);
 786 }
 787
 788 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
 789   DIScope Context = resolve(Ty->getScope());
 790   DIE *ContextDIE = getOrCreateContextDIE(Context);
 791
 792   if (DIE *TyDIE = getDIE(Ty))
 793     return TyDIE;
 794
 795   // Create new type.
 796   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 797
 798   constructTypeDIE(TyDIE, Ty);
 799
 800   updateAcceleratorTables(Context, Ty, TyDIE);
 801   return &TyDIE;
 802 }
 803
 804 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 805 /// given DIType.
 806 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 807   if (!TyNode)
 808     return nullptr;
 809
 810   auto *Ty = cast<MDType>(TyNode);
 811   assert(Ty == resolve(Ty->getRef()) &&
 812          "type was not uniqued, possible ODR violation.");
 813
 814   // DW_TAG_restrict_type is not supported in DWARF2
 815   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 816     return getOrCreateTypeDIE(
 817         resolve(DITypeRef(cast<MDDerivedType>(Ty)->getBaseType())));
 818
 819   // Construct the context before querying for the existence of the DIE in case
 820   // such construction creates the DIE.
 821   DIScope Context = resolve(Ty->getScope());
 822   DIE *ContextDIE = getOrCreateContextDIE(Context);
 823   assert(ContextDIE);
 824
 825   if (DIE *TyDIE = getDIE(Ty))
 826     return TyDIE;
 827
 828   // Create new type.
 829   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 830
 831   updateAcceleratorTables(Context, Ty, TyDIE);
 832
 833   if (auto *BT = dyn_cast<MDBasicType>(Ty))
 834     constructTypeDIE(TyDIE, BT);
 835   else if (DICompositeType CTy = dyn_cast<MDCompositeTypeBase>(Ty)) {
 836     if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
 837       if (MDString *TypeId = CTy->getRawIdentifier()) {
 838         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 839         // Skip updating the accelerator tables since this is not the full type.
 840         return &TyDIE;
 841       }
 842     constructTypeDIE(TyDIE, CTy);
 843   } else {
 844     constructTypeDIE(TyDIE, cast<MDDerivedType>(Ty));
 845   }
 846
 847   return &TyDIE;
 848 }
 849
 850 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
 851                                         const DIE &TyDIE) {
 852   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
 853     bool IsImplementation = 0;
 854     if (auto *CT = dyn_cast<MDCompositeTypeBase>(Ty)) {
 855       // A runtime language of 0 actually means C/C++ and that any
 856       // non-negative value is some version of Objective-C/C++.
 857       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
 858     }
 859     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 860     DD->addAccelType(Ty->getName(), TyDIE, Flags);
 861
 862     if (!Context || isa<MDCompileUnit>(Context) || isa<MDFile>(Context) ||
 863         isa<MDNamespace>(Context))
 864       addGlobalType(Ty, TyDIE, Context);
 865   }
 866 }
 867
 868 /// addType - Add a new type attribute to the specified entity.
 869 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 870   assert(Ty && "Trying to add a type that doesn't exist?");
 871
 872   // Check for pre-existence.
 873   DIEEntry *Entry = getDIEEntry(Ty);
 874   // If it exists then use the existing value.
 875   if (Entry) {
 876     addDIEEntry(Entity, Attribute, Entry);
 877     return;
 878   }
 879
 880   // Construct type.
 881   DIE *Buffer = getOrCreateTypeDIE(Ty);
 882
 883   // Set up proxy.
 884   Entry = createDIEEntry(*Buffer);
 885   insertDIEEntry(Ty, Entry);
 886   addDIEEntry(Entity, Attribute, Entry);
 887 }
 888
 889 /// getParentContextString - Walks the metadata parent chain in a language
 890 /// specific manner (using the compile unit language) and returns
 891 /// it as a string. This is done at the metadata level because DIEs may
 892 /// not currently have been added to the parent context and walking the
 893 /// DIEs looking for names is more expensive than walking the metadata.
 894 std::string DwarfUnit::getParentContextString(DIScope Context) const {
 895   if (!Context)
 896     return "";
 897
 898   // FIXME: Decide whether to implement this for non-C++ languages.
 899   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 900     return "";
 901
 902   std::string CS;
 903   SmallVector<DIScope, 1> Parents;
 904   while (!isa<MDCompileUnit>(Context)) {
 905     Parents.push_back(Context);
 906     if (Context->getScope())
 907       Context = resolve(Context->getScope());
 908     else
 909       // Structure, etc types will have a NULL context if they're at the top
 910       // level.
 911       break;
 912   }
 913
 914   // Reverse iterate over our list to go from the outermost construct to the
 915   // innermost.
 916   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
 917                                                   E = Parents.rend();
 918        I != E; ++I) {
 919     const MDScope *Ctx = *I;
 920     StringRef Name = Ctx->getName();
 921     if (Name.empty() && isa<MDNamespace>(Ctx))
 922       Name = "(anonymous namespace)";
 923     if (!Name.empty()) {
 924       CS += Name;
 925       CS += "::";
 926     }
 927   }
 928   return CS;
 929 }
 930
 931 /// constructTypeDIE - Construct basic type die from DIBasicType.
 932 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 933   // Get core information.
 934   StringRef Name = BTy->getName();
 935   // Add name if not anonymous or intermediate type.
 936   if (!Name.empty())
 937     addString(Buffer, dwarf::DW_AT_name, Name);
 938
 939   // An unspecified type only has a name attribute.
 940   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
 941     return;
 942
 943   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 944           BTy->getEncoding());
 945
 946   uint64_t Size = BTy->getSizeInBits() >> 3;
 947   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 948 }
 949
 950 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 951 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 952   // Get core information.
 953   StringRef Name = DTy->getName();
 954   uint64_t Size = DTy->getSizeInBits() >> 3;
 955   uint16_t Tag = Buffer.getTag();
 956
 957   // Map to main type, void will not have a type.
 958   DIType FromTy = resolve(DTy->getBaseType());
 959   if (FromTy)
 960     addType(Buffer, FromTy);
 961
 962   // Add name if not anonymous or intermediate type.
 963   if (!Name.empty())
 964     addString(Buffer, dwarf::DW_AT_name, Name);
 965
 966   // Add size if non-zero (derived types might be zero-sized.)
 967   if (Size && Tag != dwarf::DW_TAG_pointer_type
 968            && Tag != dwarf::DW_TAG_ptr_to_member_type)
 969     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 970
 971   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 972     addDIEEntry(
 973         Buffer, dwarf::DW_AT_containing_type,
 974         *getOrCreateTypeDIE(resolve(cast<MDDerivedType>(DTy)->getClassType())));
 975   // Add source line info if available and TyDesc is not a forward declaration.
 976   if (!DTy->isForwardDecl())
 977     addSourceLine(Buffer, DTy);
 978 }
 979
 980 /// constructSubprogramArguments - Construct function argument DIEs.
 981 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
 982   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 983     DIType Ty = resolve(Args[i]);
 984     if (!Ty) {
 985       assert(i == N-1 && "Unspecified parameter must be the last argument");
 986       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 987     } else {
 988       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 989       addType(Arg, Ty);
 990       if (Ty->isArtificial())
 991         addFlag(Arg, dwarf::DW_AT_artificial);
 992     }
 993   }
 994 }
 995
 996 /// constructTypeDIE - Construct type DIE from DICompositeType.
 997 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 998   // Add name if not anonymous or intermediate type.
 999   StringRef Name = CTy->getName();
1000
1001   uint64_t Size = CTy->getSizeInBits() >> 3;
1002   uint16_t Tag = Buffer.getTag();
1003
1004   switch (Tag) {
1005   case dwarf::DW_TAG_array_type:
1006     constructArrayTypeDIE(Buffer, CTy);
1007     break;
1008   case dwarf::DW_TAG_enumeration_type:
1009     constructEnumTypeDIE(Buffer, CTy);
1010     break;
1011   case dwarf::DW_TAG_subroutine_type: {
1012     // Add return type. A void return won't have a type.
1013     auto Elements = cast<MDSubroutineType>(CTy)->getTypeArray();
1014     if (Elements.size())
1015       if (auto RTy = resolve(Elements[0]))
1016         addType(Buffer, RTy);
1017
1018     bool isPrototyped = true;
1019     if (Elements.size() == 2 && !Elements[1])
1020       isPrototyped = false;
1021
1022     constructSubprogramArguments(Buffer, Elements);
1023
1024     // Add prototype flag if we're dealing with a C language and the
1025     // function has been prototyped.
1026     uint16_t Language = getLanguage();
1027     if (isPrototyped &&
1028         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1029          Language == dwarf::DW_LANG_ObjC))
1030       addFlag(Buffer, dwarf::DW_AT_prototyped);
1031
1032     if (CTy->isLValueReference())
1033       addFlag(Buffer, dwarf::DW_AT_reference);
1034
1035     if (CTy->isRValueReference())
1036       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1037   } break;
1038   case dwarf::DW_TAG_structure_type:
1039   case dwarf::DW_TAG_union_type:
1040   case dwarf::DW_TAG_class_type: {
1041     // Add elements to structure type.
1042     DIArray Elements = CTy->getElements();
1043     for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1044       DIDescriptor Element = Elements[i];
1045       if (!Element)
1046         continue;
1047       if (auto *SP = dyn_cast<MDSubprogram>(Element))
1048         getOrCreateSubprogramDIE(SP);
1049       else if (DIDerivedType DDTy = dyn_cast<MDDerivedTypeBase>(Element)) {
1050         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
1051           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1052           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
1053         } else if (DDTy->isStaticMember()) {
1054           getOrCreateStaticMemberDIE(DDTy);
1055         } else {
1056           constructMemberDIE(Buffer, DDTy);
1057         }
1058       } else if (DIObjCProperty Property = dyn_cast<MDObjCProperty>(Element)) {
1059         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
1060         StringRef PropertyName = Property->getName();
1061         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1062         if (Property->getType())
1063           addType(ElemDie, Property->getType());
1064         addSourceLine(ElemDie, Property);
1065         StringRef GetterName = Property->getGetterName();
1066         if (!GetterName.empty())
1067           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1068         StringRef SetterName = Property->getSetterName();
1069         if (!SetterName.empty())
1070           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1071         if (unsigned PropertyAttributes = Property->getAttributes())
1072           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1073                   PropertyAttributes);
1074
1075         DIEEntry *Entry = getDIEEntry(Element);
1076         if (!Entry) {
1077           Entry = createDIEEntry(ElemDie);
1078           insertDIEEntry(Element, Entry);
1079         }
1080       }
1081     }
1082
1083     if (CTy->isAppleBlockExtension())
1084       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1085
1086     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1087     // inside C++ composite types to point to the base class with the vtable.
1088     if (DICompositeType ContainingType =
1089             dyn_cast_or_null<MDCompositeType>(resolve(CTy->getVTableHolder())))
1090       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1091                   *getOrCreateTypeDIE(ContainingType));
1092
1093     if (CTy->isObjcClassComplete())
1094       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1095
1096     // Add template parameters to a class, structure or union types.
1097     // FIXME: The support isn't in the metadata for this yet.
1098     if (Tag == dwarf::DW_TAG_class_type ||
1099         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1100       addTemplateParams(Buffer, CTy->getTemplateParams());
1101
1102     break;
1103   }
1104   default:
1105     break;
1106   }
1107
1108   // Add name if not anonymous or intermediate type.
1109   if (!Name.empty())
1110     addString(Buffer, dwarf::DW_AT_name, Name);
1111
1112   if (Tag == dwarf::DW_TAG_enumeration_type ||
1113       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1114       Tag == dwarf::DW_TAG_union_type) {
1115     // Add size if non-zero (derived types might be zero-sized.)
1116     // TODO: Do we care about size for enum forward declarations?
1117     if (Size)
1118       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1119     else if (!CTy->isForwardDecl())
1120       // Add zero size if it is not a forward declaration.
1121       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1122
1123     // If we're a forward decl, say so.
1124     if (CTy->isForwardDecl())
1125       addFlag(Buffer, dwarf::DW_AT_declaration);
1126
1127     // Add source line info if available.
1128     if (!CTy->isForwardDecl())
1129       addSourceLine(Buffer, CTy);
1130
1131     // No harm in adding the runtime language to the declaration.
1132     unsigned RLang = CTy->getRuntimeLang();
1133     if (RLang)
1134       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1135               RLang);
1136   }
1137 }
1138
1139 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1140 /// DITemplateTypeParameter.
1141 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1142                                                   DITemplateTypeParameter TP) {
1143   DIE &ParamDIE =
1144       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1145   // Add the type if it exists, it could be void and therefore no type.
1146   if (TP->getType())
1147     addType(ParamDIE, resolve(TP->getType()));
1148   if (!TP->getName().empty())
1149     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1150 }
1151
1152 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1153 /// DITemplateValueParameter.
1154 void
1155 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1156                                               DITemplateValueParameter VP) {
1157   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1158
1159   // Add the type if there is one, template template and template parameter
1160   // packs will not have a type.
1161   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1162     addType(ParamDIE, resolve(VP->getType()));
1163   if (!VP->getName().empty())
1164     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1165   if (Metadata *Val = VP->getValue()) {
1166     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1167       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1168     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1169       // For declaration non-type template parameters (such as global values and
1170       // functions)
1171       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1172       addOpAddress(*Loc, Asm->getSymbol(GV));
1173       // Emit DW_OP_stack_value to use the address as the immediate value of the
1174       // parameter, rather than a pointer to it.
1175       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1176       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1177     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1178       assert(isa<MDString>(Val));
1179       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1180                 cast<MDString>(Val)->getString());
1181     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1182       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1183     }
1184   }
1185 }
1186
1187 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1188 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1189   // Construct the context before querying for the existence of the DIE in case
1190   // such construction creates the DIE.
1191   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1192
1193   if (DIE *NDie = getDIE(NS))
1194     return NDie;
1195   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1196
1197   StringRef Name = NS->getName();
1198   if (!Name.empty())
1199     addString(NDie, dwarf::DW_AT_name, NS->getName());
1200   else
1201     Name = "(anonymous namespace)";
1202   DD->addAccelNamespace(Name, NDie);
1203   addGlobalName(Name, NDie, NS->getScope());
1204   addSourceLine(NDie, NS);
1205   return &NDie;
1206 }
1207
1208 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1209 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1210   // Construct the context before querying for the existence of the DIE in case
1211   // such construction creates the DIE (as is the case for member function
1212   // declarations).
1213   DIE *ContextDIE =
1214       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1215
1216   if (DIE *SPDie = getDIE(SP))
1217     return SPDie;
1218
1219   if (auto *SPDecl = SP->getDeclaration()) {
1220     if (!Minimal) {
1221       // Add subprogram definitions to the CU die directly.
1222       ContextDIE = &getUnitDie();
1223       // Build the decl now to ensure it precedes the definition.
1224       getOrCreateSubprogramDIE(SPDecl);
1225     }
1226   }
1227
1228   // DW_TAG_inlined_subroutine may refer to this DIE.
1229   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1230
1231   // Stop here and fill this in later, depending on whether or not this
1232   // subprogram turns out to have inlined instances or not.
1233   if (SP->isDefinition())
1234     return &SPDie;
1235
1236   applySubprogramAttributes(SP, SPDie);
1237   return &SPDie;
1238 }
1239
1240 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1241                                                     DIE &SPDie) {
1242   DIE *DeclDie = nullptr;
1243   StringRef DeclLinkageName;
1244   if (auto *SPDecl = SP->getDeclaration()) {
1245     DeclDie = getDIE(SPDecl);
1246     assert(DeclDie && "This DIE should've already been constructed when the "
1247                       "definition DIE was created in "
1248                       "getOrCreateSubprogramDIE");
1249     DeclLinkageName = SPDecl->getLinkageName();
1250   }
1251
1252   // Add function template parameters.
1253   addTemplateParams(SPDie, SP->getTemplateParams());
1254
1255   // Add the linkage name if we have one and it isn't in the Decl.
1256   StringRef LinkageName = SP->getLinkageName();
1257   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1258           LinkageName == DeclLinkageName) &&
1259          "decl has a linkage name and it is different");
1260   if (DeclLinkageName.empty())
1261     addLinkageName(SPDie, LinkageName);
1262
1263   if (!DeclDie)
1264     return false;
1265
1266   // Refer to the function declaration where all the other attributes will be
1267   // found.
1268   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1269   return true;
1270 }
1271
1272 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1273                                           bool Minimal) {
1274   if (!Minimal)
1275     if (applySubprogramDefinitionAttributes(SP, SPDie))
1276       return;
1277
1278   // Constructors and operators for anonymous aggregates do not have names.
1279   if (!SP->getName().empty())
1280     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1281
1282   // Skip the rest of the attributes under -gmlt to save space.
1283   if (Minimal)
1284     return;
1285
1286   addSourceLine(SPDie, SP);
1287
1288   // Add the prototype if we have a prototype and we have a C like
1289   // language.
1290   uint16_t Language = getLanguage();
1291   if (SP->isPrototyped() &&
1292       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1293        Language == dwarf::DW_LANG_ObjC))
1294     addFlag(SPDie, dwarf::DW_AT_prototyped);
1295
1296   DISubroutineType SPTy = SP->getType();
1297   assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1298          "the type of a subprogram should be a subroutine");
1299
1300   auto Args = SPTy->getTypeArray();
1301   // Add a return type. If this is a type like a C/C++ void type we don't add a
1302   // return type.
1303   if (Args.size())
1304     if (auto Ty = resolve(Args[0]))
1305       addType(SPDie, Ty);
1306
1307   unsigned VK = SP->getVirtuality();
1308   if (VK) {
1309     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1310     DIELoc *Block = getDIELoc();
1311     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1312     addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1313     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1314     ContainingTypeMap.insert(
1315         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1316   }
1317
1318   if (!SP->isDefinition()) {
1319     addFlag(SPDie, dwarf::DW_AT_declaration);
1320
1321     // Add arguments. Do not add arguments for subprogram definition. They will
1322     // be handled while processing variables.
1323     constructSubprogramArguments(SPDie, Args);
1324   }
1325
1326   if (SP->isArtificial())
1327     addFlag(SPDie, dwarf::DW_AT_artificial);
1328
1329   if (!SP->isLocalToUnit())
1330     addFlag(SPDie, dwarf::DW_AT_external);
1331
1332   if (SP->isOptimized())
1333     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1334
1335   if (unsigned isa = Asm->getISAEncoding())
1336     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1337
1338   if (SP->isLValueReference())
1339     addFlag(SPDie, dwarf::DW_AT_reference);
1340
1341   if (SP->isRValueReference())
1342     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1343
1344   if (SP->isProtected())
1345     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1346             dwarf::DW_ACCESS_protected);
1347   else if (SP->isPrivate())
1348     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1349             dwarf::DW_ACCESS_private);
1350   else if (SP->isPublic())
1351     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1352             dwarf::DW_ACCESS_public);
1353
1354   if (SP->isExplicit())
1355     addFlag(SPDie, dwarf::DW_AT_explicit);
1356 }
1357
1358 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1359 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1360   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1361   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1362
1363   // The LowerBound value defines the lower bounds which is typically zero for
1364   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1365   // Count == -1 then the array is unbounded and we do not emit
1366   // DW_AT_lower_bound and DW_AT_count attributes.
1367   int64_t LowerBound = SR->getLowerBound();
1368   int64_t DefaultLowerBound = getDefaultLowerBound();
1369   int64_t Count = SR->getCount();
1370
1371   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1372     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1373
1374   if (Count != -1)
1375     // FIXME: An unbounded array should reference the expression that defines
1376     // the array.
1377     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1378 }
1379
1380 DIE *DwarfUnit::getIndexTyDie() {
1381   if (IndexTyDie)
1382     return IndexTyDie;
1383   // Construct an integer type to use for indexes.
1384   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1385   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1386   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1387   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1388           dwarf::DW_ATE_unsigned);
1389   return IndexTyDie;
1390 }
1391
1392 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1393 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1394   if (CTy->isVector())
1395     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1396
1397   // Emit the element type.
1398   addType(Buffer, resolve(CTy->getBaseType()));
1399
1400   // Get an anonymous type for index type.
1401   // FIXME: This type should be passed down from the front end
1402   // as different languages may have different sizes for indexes.
1403   DIE *IdxTy = getIndexTyDie();
1404
1405   // Add subranges to array type.
1406   DIArray Elements = CTy->getElements();
1407   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1408     DIDescriptor Element = Elements[i];
1409     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1410       constructSubrangeDIE(Buffer, cast<MDSubrange>(Element), IdxTy);
1411   }
1412 }
1413
1414 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1415 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1416   DIArray Elements = CTy->getElements();
1417
1418   // Add enumerators to enumeration type.
1419   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1420     auto *Enum = dyn_cast_or_null<MDEnumerator>(Elements[i]);
1421     if (Enum) {
1422       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1423       StringRef Name = Enum->getName();
1424       addString(Enumerator, dwarf::DW_AT_name, Name);
1425       int64_t Value = Enum->getValue();
1426       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1427               Value);
1428     }
1429   }
1430   DIType DTy = resolve(CTy->getBaseType());
1431   if (DTy) {
1432     addType(Buffer, DTy);
1433     addFlag(Buffer, dwarf::DW_AT_enum_class);
1434   }
1435 }
1436
1437 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1438 /// vtables.
1439 void DwarfUnit::constructContainingTypeDIEs() {
1440   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1441                                                  CE = ContainingTypeMap.end();
1442        CI != CE; ++CI) {
1443     DIE &SPDie = *CI->first;
1444     DIDescriptor D(CI->second);
1445     if (!D)
1446       continue;
1447     DIE *NDie = getDIE(D);
1448     if (!NDie)
1449       continue;
1450     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1451   }
1452 }
1453
1454 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1455 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT_) {
1456   // Downcast to MDDerivedType.
1457   const MDDerivedType *DT = cast<MDDerivedType>(DT_);
1458
1459   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1460   StringRef Name = DT->getName();
1461   if (!Name.empty())
1462     addString(MemberDie, dwarf::DW_AT_name, Name);
1463
1464   addType(MemberDie, resolve(DT->getBaseType()));
1465
1466   addSourceLine(MemberDie, DT);
1467
1468   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1469
1470     // For C++, virtual base classes are not at fixed offset. Use following
1471     // expression to extract appropriate offset from vtable.
1472     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1473
1474     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1475     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1476     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1477     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1478     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1479     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1480     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1481     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1482
1483     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1484   } else {
1485     uint64_t Size = DT->getSizeInBits();
1486     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1487     uint64_t OffsetInBytes;
1488
1489     if (FieldSize && Size != FieldSize) {
1490       // Handle bitfield, assume bytes are 8 bits.
1491       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1492       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1493
1494       uint64_t Offset = DT->getOffsetInBits();
1495       uint64_t AlignMask = ~(DT->getAlignInBits() - 1);
1496       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1497       uint64_t FieldOffset = (HiMark - FieldSize);
1498       Offset -= FieldOffset;
1499
1500       // Maybe we need to work from the other end.
1501       if (Asm->getDataLayout().isLittleEndian())
1502         Offset = FieldSize - (Offset + Size);
1503       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1504
1505       // Here DW_AT_data_member_location points to the anonymous
1506       // field that includes this bit field.
1507       OffsetInBytes = FieldOffset >> 3;
1508     } else
1509       // This is not a bitfield.
1510       OffsetInBytes = DT->getOffsetInBits() >> 3;
1511
1512     if (DD->getDwarfVersion() <= 2) {
1513       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1514       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1515       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1516       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1517     } else
1518       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1519               OffsetInBytes);
1520   }
1521
1522   if (DT->isProtected())
1523     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1524             dwarf::DW_ACCESS_protected);
1525   else if (DT->isPrivate())
1526     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1527             dwarf::DW_ACCESS_private);
1528   // Otherwise C++ member and base classes are considered public.
1529   else if (DT->isPublic())
1530     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1531             dwarf::DW_ACCESS_public);
1532   if (DT->isVirtual())
1533     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1534             dwarf::DW_VIRTUALITY_virtual);
1535
1536   // Objective-C properties.
1537   if (MDNode *PNode = DT->getObjCProperty())
1538     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1539       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1540                          PropertyDie);
1541
1542   if (DT->isArtificial())
1543     addFlag(MemberDie, dwarf::DW_AT_artificial);
1544 }
1545
1546 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1547 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT_) {
1548   const MDDerivedType *DT = cast_or_null<MDDerivedType>(DT_);
1549   if (!DT)
1550     return nullptr;
1551
1552   // Construct the context before querying for the existence of the DIE in case
1553   // such construction creates the DIE.
1554   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1555   assert(dwarf::isType(ContextDIE->getTag()) &&
1556          "Static member should belong to a type.");
1557
1558   if (DIE *StaticMemberDIE = getDIE(DT))
1559     return StaticMemberDIE;
1560
1561   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1562
1563   DIType Ty = resolve(DT->getBaseType());
1564
1565   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1566   addType(StaticMemberDIE, Ty);
1567   addSourceLine(StaticMemberDIE, DT);
1568   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1569   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1570
1571   // FIXME: We could omit private if the parent is a class_type, and
1572   // public if the parent is something else.
1573   if (DT->isProtected())
1574     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1575             dwarf::DW_ACCESS_protected);
1576   else if (DT->isPrivate())
1577     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1578             dwarf::DW_ACCESS_private);
1579   else if (DT->isPublic())
1580     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1581             dwarf::DW_ACCESS_public);
1582
1583   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1584     addConstantValue(StaticMemberDIE, CI, Ty);
1585   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1586     addConstantFPValue(StaticMemberDIE, CFP);
1587
1588   return &StaticMemberDIE;
1589 }
1590
1591 void DwarfUnit::emitHeader(bool UseOffsets) {
1592   // Emit size of content not including length itself
1593   Asm->OutStreamer.AddComment("Length of Unit");
1594   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1595
1596   Asm->OutStreamer.AddComment("DWARF version number");
1597   Asm->EmitInt16(DD->getDwarfVersion());
1598   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1599
1600   // We share one abbreviations table across all units so it's always at the
1601   // start of the section. Use a relocatable offset where needed to ensure
1602   // linking doesn't invalidate that offset.
1603   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1604   if (!UseOffsets)
1605     Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1606   else
1607     Asm->EmitInt32(0);
1608
1609   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1610   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1611 }
1612
1613 void DwarfUnit::initSection(const MCSection *Section) {
1614   assert(!this->Section);
1615   this->Section = Section;
1616 }
1617
1618 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1619   DwarfUnit::emitHeader(UseOffsets);
1620   Asm->OutStreamer.AddComment("Type Signature");
1621   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1622   Asm->OutStreamer.AddComment("Type DIE Offset");
1623   // In a skeleton type unit there is no type DIE so emit a zero offset.
1624   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1625                                 sizeof(Ty->getOffset()));
1626 }
1627
1628 bool DwarfTypeUnit::isDwoUnit() const {
1629   // Since there are no skeleton type units, all type units are dwo type units
1630   // when split DWARF is being used.
1631   return DD->useSplitDwarf();
1632 }