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