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
  16 #include "DwarfAccelTable.h"
  17 #include "DwarfCompileUnit.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/IR/Constants.h"
  21 #include "llvm/IR/DIBuilder.h"
  22 #include "llvm/IR/DataLayout.h"
  23 #include "llvm/IR/GlobalVariable.h"
  24 #include "llvm/IR/Instructions.h"
  25 #include "llvm/IR/Mangler.h"
  26 #include "llvm/MC/MCAsmInfo.h"
  27 #include "llvm/MC/MCContext.h"
  28 #include "llvm/MC/MCSection.h"
  29 #include "llvm/MC/MCStreamer.h"
  30 #include "llvm/Support/CommandLine.h"
  31 #include "llvm/Target/TargetFrameLowering.h"
  32 #include "llvm/Target/TargetLoweringObjectFile.h"
  33 #include "llvm/Target/TargetMachine.h"
  34 #include "llvm/Target/TargetRegisterInfo.h"
  35 #include "llvm/Target/TargetSubtargetInfo.h"
  36
  37 using namespace llvm;
  38
  39 #define DEBUG_TYPE "dwarfdebug"
  40
  41 static cl::opt<bool>
  42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  43                        cl::desc("Generate DWARF4 type units."),
  44                        cl::init(false));
  45
  46 /// Unit - Unit constructor.
  47 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
  48                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
  49     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
  50       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  51   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  52          UnitTag == dwarf::DW_TAG_type_unit);
  53   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  54 }
  55
  56 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
  57                              DwarfDebug *DW, DwarfFile *DWU,
  58                              MCDwarfDwoLineTable *SplitLineTable)
  59     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
  60       CU(CU), SplitLineTable(SplitLineTable) {
  61   if (SplitLineTable)
  62     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  63 }
  64
  65 /// ~Unit - Destructor for compile unit.
  66 DwarfUnit::~DwarfUnit() {
  67   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  68     DIEBlocks[j]->~DIEBlock();
  69   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  70     DIELocs[j]->~DIELoc();
  71 }
  72
  73 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  74 /// information entry.
  75 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
  76   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  77   return Value;
  78 }
  79
  80 /// getDefaultLowerBound - Return the default lower bound for an array. If the
  81 /// DWARF version doesn't handle the language, return -1.
  82 int64_t DwarfUnit::getDefaultLowerBound() const {
  83   switch (getLanguage()) {
  84   default:
  85     break;
  86
  87   case dwarf::DW_LANG_C89:
  88   case dwarf::DW_LANG_C99:
  89   case dwarf::DW_LANG_C:
  90   case dwarf::DW_LANG_C_plus_plus:
  91   case dwarf::DW_LANG_ObjC:
  92   case dwarf::DW_LANG_ObjC_plus_plus:
  93     return 0;
  94
  95   case dwarf::DW_LANG_Fortran77:
  96   case dwarf::DW_LANG_Fortran90:
  97   case dwarf::DW_LANG_Fortran95:
  98     return 1;
  99
 100   // The languages below have valid values only if the DWARF version >= 4.
 101   case dwarf::DW_LANG_Java:
 102   case dwarf::DW_LANG_Python:
 103   case dwarf::DW_LANG_UPC:
 104   case dwarf::DW_LANG_D:
 105     if (dwarf::DWARF_VERSION >= 4)
 106       return 0;
 107     break;
 108
 109   case dwarf::DW_LANG_Ada83:
 110   case dwarf::DW_LANG_Ada95:
 111   case dwarf::DW_LANG_Cobol74:
 112   case dwarf::DW_LANG_Cobol85:
 113   case dwarf::DW_LANG_Modula2:
 114   case dwarf::DW_LANG_Pascal83:
 115   case dwarf::DW_LANG_PLI:
 116     if (dwarf::DWARF_VERSION >= 4)
 117       return 1;
 118     break;
 119   }
 120
 121   return -1;
 122 }
 123
 124 /// Check whether the DIE for this MDNode can be shared across CUs.
 125 static bool isShareableAcrossCUs(DIDescriptor D) {
 126   // When the MDNode can be part of the type system, the DIE can be shared
 127   // across CUs.
 128   // Combining type units and cross-CU DIE sharing is lower value (since
 129   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 130   // level already) but may be implementable for some value in projects
 131   // building multiple independent libraries with LTO and then linking those
 132   // together.
 133   return (D.isType() ||
 134           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
 135          !GenerateDwarfTypeUnits;
 136 }
 137
 138 /// getDIE - Returns the debug information entry map slot for the
 139 /// specified debug variable. We delegate the request to DwarfDebug
 140 /// when the DIE for this MDNode can be shared across CUs. The mappings
 141 /// will be kept in DwarfDebug for shareable DIEs.
 142 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
 143   if (isShareableAcrossCUs(D))
 144     return DD->getDIE(D);
 145   return MDNodeToDieMap.lookup(D);
 146 }
 147
 148 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
 149 /// when the DIE for this MDNode can be shared across CUs. The mappings
 150 /// will be kept in DwarfDebug for shareable DIEs.
 151 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
 152   if (isShareableAcrossCUs(Desc)) {
 153     DD->insertDIE(Desc, D);
 154     return;
 155   }
 156   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 157 }
 158
 159 /// addFlag - Add a flag that is true.
 160 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 161   if (DD->getDwarfVersion() >= 4)
 162     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
 163   else
 164     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
 165 }
 166
 167 /// addUInt - Add an unsigned integer attribute data and value.
 168 ///
 169 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
 170                         Optional<dwarf::Form> Form, uint64_t Integer) {
 171   if (!Form)
 172     Form = DIEInteger::BestForm(false, Integer);
 173   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
 174                         DIEInteger(Integer);
 175   Die.addValue(Attribute, *Form, Value);
 176 }
 177
 178 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
 179   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 180 }
 181
 182 /// addSInt - Add an signed integer attribute data and value.
 183 ///
 184 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
 185                         Optional<dwarf::Form> Form, int64_t Integer) {
 186   if (!Form)
 187     Form = DIEInteger::BestForm(true, Integer);
 188   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 189   Die.addValue(Attribute, *Form, Value);
 190 }
 191
 192 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 193                         int64_t Integer) {
 194   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 195 }
 196
 197 /// addString - Add a string attribute data and value. We always emit a
 198 /// reference to the string pool instead of immediate strings so that DIEs have
 199 /// more predictable sizes. In the case of split dwarf we emit an index
 200 /// into another table which gets us the static offset into the string
 201 /// table.
 202 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 203                           StringRef String) {
 204
 205   if (!DD->useSplitDwarf())
 206     return addLocalString(Die, Attribute, String);
 207
 208   unsigned idx = DU->getStringPool().getIndex(*Asm, String);
 209   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
 210   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 211   Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
 212 }
 213
 214 /// addLocalString - Add a string attribute data and value. This is guaranteed
 215 /// to be in the local string pool instead of indirected.
 216 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
 217                                StringRef String) {
 218   MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
 219   DIEValue *Value;
 220   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 221     Value = new (DIEValueAllocator) DIELabel(Symb);
 222   else
 223     Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
 224   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 225   Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
 226 }
 227
 228 /// addExpr - Add a Dwarf expression attribute data and value.
 229 ///
 230 void DwarfUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) {
 231   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
 232   Die.addValue((dwarf::Attribute)0, Form, Value);
 233 }
 234
 235 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
 236 ///
 237 void DwarfUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
 238                                 unsigned Index) {
 239   DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
 240   dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
 241                                                 : dwarf::DW_FORM_data4;
 242   Die.addValue(Attribute, Form, Value);
 243 }
 244
 245 /// addLabel - Add a Dwarf label attribute data and value.
 246 ///
 247 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
 248                          const MCSymbol *Label) {
 249   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 250   Die.addValue(Attribute, Form, Value);
 251 }
 252
 253 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 254   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 255 }
 256
 257 /// addSectionOffset - Add an offset into a section attribute data and value.
 258 ///
 259 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 260                                  uint64_t Integer) {
 261   if (DD->getDwarfVersion() >= 4)
 262     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 263   else
 264     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 265 }
 266
 267 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
 268   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
 269                         : getCU().getOrCreateSourceID(FileName, DirName);
 270 }
 271
 272 /// addOpAddress - Add a dwarf op address data and value using the
 273 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
 274 ///
 275 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 276   if (!DD->useSplitDwarf()) {
 277     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 278     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 279   } else {
 280     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 281     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 282             DD->getAddressPool().getIndex(Sym));
 283   }
 284 }
 285
 286 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 287                               const MCSymbol *Hi, const MCSymbol *Lo) {
 288   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 289   Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
 290 }
 291
 292 /// addDIEEntry - Add a DIE attribute data and value.
 293 ///
 294 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 295   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
 296 }
 297
 298 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
 299   // Flag the type unit reference as a declaration so that if it contains
 300   // members (implicit special members, static data member definitions, member
 301   // declarations for definitions in this CU, etc) consumers don't get confused
 302   // and think this is a full definition.
 303   addFlag(Die, dwarf::DW_AT_declaration);
 304
 305   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
 306                new (DIEValueAllocator) DIETypeSignature(Type));
 307 }
 308
 309 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 310                             DIEEntry *Entry) {
 311   const DIE *DieCU = Die.getUnitOrNull();
 312   const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
 313   if (!DieCU)
 314     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 315     DieCU = &getUnitDie();
 316   if (!EntryCU)
 317     EntryCU = &getUnitDie();
 318   Die.addValue(Attribute,
 319                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 320                Entry);
 321 }
 322
 323 /// Create a DIE with the given Tag, add the DIE to its parent, and
 324 /// call insertDIE if MD is not null.
 325 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
 326   assert(Tag != dwarf::DW_TAG_auto_variable &&
 327          Tag != dwarf::DW_TAG_arg_variable);
 328   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
 329   DIE &Die = *Parent.getChildren().back();
 330   if (N)
 331     insertDIE(N, &Die);
 332   return Die;
 333 }
 334
 335 /// addBlock - Add block data.
 336 ///
 337 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 338   Loc->ComputeSize(Asm);
 339   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 340   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
 341 }
 342
 343 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 344                          DIEBlock *Block) {
 345   Block->ComputeSize(Asm);
 346   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 347   Die.addValue(Attribute, Block->BestForm(), Block);
 348 }
 349
 350 /// addSourceLine - Add location information to specified debug information
 351 /// entry.
 352 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
 353                               StringRef Directory) {
 354   if (Line == 0)
 355     return;
 356
 357   unsigned FileID = getOrCreateSourceID(File, Directory);
 358   assert(FileID && "Invalid file id");
 359   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 360   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 361 }
 362
 363 /// addSourceLine - Add location information to specified debug information
 364 /// entry.
 365 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
 366   assert(V.isVariable());
 367
 368   addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
 369                 V.getContext().getDirectory());
 370 }
 371
 372 /// addSourceLine - Add location information to specified debug information
 373 /// entry.
 374 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
 375   assert(G.isGlobalVariable());
 376
 377   addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
 378 }
 379
 380 /// addSourceLine - Add location information to specified debug information
 381 /// entry.
 382 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
 383   assert(SP.isSubprogram());
 384
 385   addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
 386 }
 387
 388 /// addSourceLine - Add location information to specified debug information
 389 /// entry.
 390 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
 391   assert(Ty.isType());
 392
 393   addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
 394 }
 395
 396 /// addSourceLine - Add location information to specified debug information
 397 /// entry.
 398 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
 399   assert(Ty.isObjCProperty());
 400
 401   DIFile File = Ty.getFile();
 402   addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
 403                 File.getDirectory());
 404 }
 405
 406 /// addSourceLine - Add location information to specified debug information
 407 /// entry.
 408 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
 409   assert(NS.Verify());
 410
 411   addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
 412 }
 413
 414 /// addVariableAddress - Add DW_AT_location attribute for a
 415 /// DbgVariable based on provided MachineLocation.
 416 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
 417                                    MachineLocation Location) {
 418   if (DV.variableHasComplexAddress())
 419     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
 420   else if (DV.isBlockByrefVariable())
 421     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
 422   else
 423     addAddress(Die, dwarf::DW_AT_location, Location,
 424                DV.getVariable().isIndirect());
 425 }
 426
 427 /// addRegisterOp - Add register operand.
 428 // FIXME: Ideally, this would share the implementation with
 429 // AsmPrinter::EmitDwarfRegOpPiece.
 430 void DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
 431                                    unsigned SizeInBits, unsigned OffsetInBits) {
 432   const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
 433   int DWReg = RI->getDwarfRegNum(Reg, false);
 434   bool isSubRegister = DWReg < 0;
 435
 436   unsigned Idx = 0;
 437
 438   // Go up the super-register chain until we hit a valid dwarf register number.
 439   for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
 440     DWReg = RI->getDwarfRegNum(*SR, false);
 441     if (DWReg >= 0)
 442       Idx = RI->getSubRegIndex(*SR, Reg);
 443   }
 444
 445   if (DWReg < 0) {
 446     DEBUG(dbgs() << "Invalid Dwarf register number.\n");
 447     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
 448     return;
 449   }
 450
 451   // Emit register.
 452   if (DWReg < 32)
 453     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
 454   else {
 455     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 456     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
 457   }
 458
 459   // Emit mask.
 460   bool isPiece = SizeInBits > 0;
 461   if (isSubRegister || isPiece) {
 462     const unsigned SizeOfByte = 8;
 463     unsigned RegSizeInBits = RI->getSubRegIdxSize(Idx);
 464     unsigned RegOffsetInBits = RI->getSubRegIdxOffset(Idx);
 465     unsigned PieceSizeInBits = std::max(SizeInBits, RegSizeInBits);
 466     unsigned PieceOffsetInBits = OffsetInBits ? OffsetInBits : RegOffsetInBits;
 467     assert(RegSizeInBits >= SizeInBits && "register smaller than value");
 468
 469     if (RegOffsetInBits != PieceOffsetInBits) {
 470       // Manually shift the value into place, since the DW_OP_piece
 471       // describes the part of the variable, not the position of the
 472       // subregister.
 473       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 474       addUInt(TheDie, dwarf::DW_FORM_data1, RegOffsetInBits);
 475       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_shr);
 476     }
 477
 478     if (PieceOffsetInBits > 0 || PieceSizeInBits % SizeOfByte) {
 479       assert(PieceSizeInBits > 0 && "piece has zero size");
 480       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
 481       addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits);
 482       addUInt(TheDie, dwarf::DW_FORM_data1, PieceOffsetInBits);
 483      } else {
 484       assert(PieceSizeInBits > 0 && "piece has zero size");
 485       addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
 486       addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits/SizeOfByte);
 487     }
 488   }
 489 }
 490
 491 /// addRegisterOffset - Add register offset.
 492 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
 493                                   int64_t Offset) {
 494   const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
 495   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 496   const TargetRegisterInfo *TRI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
 497   if (Reg == TRI->getFrameRegister(*Asm->MF))
 498     // If variable offset is based in frame register then use fbreg.
 499     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
 500   else if (DWReg < 32)
 501     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
 502   else {
 503     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 504     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
 505   }
 506   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
 507 }
 508
 509 /// addAddress - Add an address attribute to a die based on the location
 510 /// provided.
 511 void DwarfUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
 512                            const MachineLocation &Location, bool Indirect) {
 513   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
 514
 515   if (Location.isReg() && !Indirect)
 516     addRegisterOpPiece(*Loc, Location.getReg());
 517   else {
 518     addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 519     if (Indirect && !Location.isReg()) {
 520       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 521     }
 522   }
 523
 524   // Now attach the location information to the DIE.
 525   addBlock(Die, Attribute, Loc);
 526 }
 527
 528 /// addComplexAddress - Start with the address based on the location provided,
 529 /// and generate the DWARF information necessary to find the actual variable
 530 /// given the extra address information encoded in the DbgVariable, starting
 531 /// from the starting location.  Add the DWARF information to the die.
 532 ///
 533 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
 534                                   dwarf::Attribute Attribute,
 535                                   const MachineLocation &Location) {
 536   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
 537   unsigned N = DV.getNumAddrElements();
 538   unsigned i = 0;
 539   if (Location.isReg()) {
 540     if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_plus) {
 541       assert(!DV.getVariable().isIndirect() &&
 542              "double indirection not handled");
 543       // If first address element is OpPlus then emit
 544       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
 545       addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1));
 546       i = 2;
 547     } else if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_deref) {
 548       assert(!DV.getVariable().isIndirect() &&
 549              "double indirection not handled");
 550       addRegisterOpPiece(*Loc, Location.getReg(),
 551                          DV.getExpression().getPieceSize(),
 552                          DV.getExpression().getPieceOffset());
 553       i = 3;
 554     } else
 555       addRegisterOpPiece(*Loc, Location.getReg());
 556   } else
 557     addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 558
 559   for (; i < N; ++i) {
 560     uint64_t Element = DV.getAddrElement(i);
 561     if (Element == dwarf::DW_OP_plus) {
 562       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 563       addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
 564
 565     } else if (Element == dwarf::DW_OP_deref) {
 566       if (!Location.isReg())
 567         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 568
 569     } else if (Element == dwarf::DW_OP_piece) {
 570       const unsigned SizeOfByte = 8;
 571       unsigned PieceOffsetInBits = DV.getAddrElement(++i)*SizeOfByte;
 572       unsigned PieceSizeInBits = DV.getAddrElement(++i)*SizeOfByte;
 573       // Emit DW_OP_bit_piece Size Offset.
 574       assert(PieceSizeInBits > 0 && "piece has zero size");
 575       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
 576       addUInt(*Loc, dwarf::DW_FORM_udata, PieceSizeInBits);
 577       addUInt(*Loc, dwarf::DW_FORM_udata, PieceOffsetInBits);
 578
 579     } else
 580       llvm_unreachable("unknown DIBuilder Opcode");
 581   }
 582
 583   // Now attach the location information to the DIE.
 584   addBlock(Die, Attribute, Loc);
 585 }
 586
 587 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 588    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 589    gives the variable VarName either the struct, or a pointer to the struct, as
 590    its type.  This is necessary for various behind-the-scenes things the
 591    compiler needs to do with by-reference variables in Blocks.
 592
 593    However, as far as the original *programmer* is concerned, the variable
 594    should still have type 'SomeType', as originally declared.
 595
 596    The function getBlockByrefType dives into the __Block_byref_x_VarName
 597    struct to find the original type of the variable, which is then assigned to
 598    the variable's Debug Information Entry as its real type.  So far, so good.
 599    However now the debugger will expect the variable VarName to have the type
 600    SomeType.  So we need the location attribute for the variable to be an
 601    expression that explains to the debugger how to navigate through the
 602    pointers and struct to find the actual variable of type SomeType.
 603
 604    The following function does just that.  We start by getting
 605    the "normal" location for the variable. This will be the location
 606    of either the struct __Block_byref_x_VarName or the pointer to the
 607    struct __Block_byref_x_VarName.
 608
 609    The struct will look something like:
 610
 611    struct __Block_byref_x_VarName {
 612      ... <various fields>
 613      struct __Block_byref_x_VarName *forwarding;
 614      ... <various other fields>
 615      SomeType VarName;
 616      ... <maybe more fields>
 617    };
 618
 619    If we are given the struct directly (as our starting point) we
 620    need to tell the debugger to:
 621
 622    1).  Add the offset of the forwarding field.
 623
 624    2).  Follow that pointer to get the real __Block_byref_x_VarName
 625    struct to use (the real one may have been copied onto the heap).
 626
 627    3).  Add the offset for the field VarName, to find the actual variable.
 628
 629    If we started with a pointer to the struct, then we need to
 630    dereference that pointer first, before the other steps.
 631    Translating this into DWARF ops, we will need to append the following
 632    to the current location description for the variable:
 633
 634    DW_OP_deref                    -- optional, if we start with a pointer
 635    DW_OP_plus_uconst <forward_fld_offset>
 636    DW_OP_deref
 637    DW_OP_plus_uconst <varName_fld_offset>
 638
 639    That is what this function does.  */
 640
 641 /// addBlockByrefAddress - Start with the address based on the location
 642 /// provided, and generate the DWARF information necessary to find the
 643 /// actual Block variable (navigating the Block struct) based on the
 644 /// starting location.  Add the DWARF information to the die.  For
 645 /// more information, read large comment just above here.
 646 ///
 647 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
 648                                      dwarf::Attribute Attribute,
 649                                      const MachineLocation &Location) {
 650   DIType Ty = DV.getType();
 651   DIType TmpTy = Ty;
 652   uint16_t Tag = Ty.getTag();
 653   bool isPointer = false;
 654
 655   StringRef varName = DV.getName();
 656
 657   if (Tag == dwarf::DW_TAG_pointer_type) {
 658     DIDerivedType DTy(Ty);
 659     TmpTy = resolve(DTy.getTypeDerivedFrom());
 660     isPointer = true;
 661   }
 662
 663   DICompositeType blockStruct(TmpTy);
 664
 665   // Find the __forwarding field and the variable field in the __Block_byref
 666   // struct.
 667   DIArray Fields = blockStruct.getElements();
 668   DIDerivedType varField;
 669   DIDerivedType forwardingField;
 670
 671   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 672     DIDerivedType DT(Fields.getElement(i));
 673     StringRef fieldName = DT.getName();
 674     if (fieldName == "__forwarding")
 675       forwardingField = DT;
 676     else if (fieldName == varName)
 677       varField = DT;
 678   }
 679
 680   // Get the offsets for the forwarding field and the variable field.
 681   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
 682   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
 683
 684   // Decode the original location, and use that as the start of the byref
 685   // variable's location.
 686   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
 687
 688   if (Location.isReg())
 689     addRegisterOpPiece(*Loc, Location.getReg());
 690   else
 691     addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 692
 693   // If we started with a pointer to the __Block_byref... struct, then
 694   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 695   if (isPointer)
 696     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 697
 698   // Next add the offset for the '__forwarding' field:
 699   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 700   // adding the offset if it's 0.
 701   if (forwardingFieldOffset > 0) {
 702     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 703     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
 704   }
 705
 706   // Now dereference the __forwarding field to get to the real __Block_byref
 707   // struct:  DW_OP_deref.
 708   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 709
 710   // Now that we've got the real __Block_byref... struct, add the offset
 711   // for the variable's field to get to the location of the actual variable:
 712   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 713   if (varFieldOffset > 0) {
 714     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 715     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
 716   }
 717
 718   // Now attach the location information to the DIE.
 719   addBlock(Die, Attribute, Loc);
 720 }
 721
 722 /// Return true if type encoding is unsigned.
 723 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
 724   DIDerivedType DTy(Ty);
 725   if (DTy.isDerivedType()) {
 726     dwarf::Tag T = (dwarf::Tag)Ty.getTag();
 727     // Encode pointer constants as unsigned bytes. This is used at least for
 728     // null pointer constant emission.
 729     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
 730     // here, but accept them for now due to a bug in SROA producing bogus
 731     // dbg.values.
 732     if (T == dwarf::DW_TAG_pointer_type ||
 733         T == dwarf::DW_TAG_ptr_to_member_type ||
 734         T == dwarf::DW_TAG_reference_type ||
 735         T == dwarf::DW_TAG_rvalue_reference_type)
 736       return true;
 737     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 738            T == dwarf::DW_TAG_volatile_type ||
 739            T == dwarf::DW_TAG_restrict_type ||
 740            T == dwarf::DW_TAG_enumeration_type);
 741     if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
 742       return isUnsignedDIType(DD, DD->resolve(Deriv));
 743     // FIXME: Enums without a fixed underlying type have unknown signedness
 744     // here, leading to incorrectly emitted constants.
 745     assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
 746     return false;
 747   }
 748
 749   DIBasicType BTy(Ty);
 750   assert(BTy.isBasicType());
 751   unsigned Encoding = BTy.getEncoding();
 752   assert((Encoding == dwarf::DW_ATE_unsigned ||
 753           Encoding == dwarf::DW_ATE_unsigned_char ||
 754           Encoding == dwarf::DW_ATE_signed ||
 755           Encoding == dwarf::DW_ATE_signed_char ||
 756           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) &&
 757          "Unsupported encoding");
 758   return (Encoding == dwarf::DW_ATE_unsigned ||
 759           Encoding == dwarf::DW_ATE_unsigned_char ||
 760           Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean);
 761 }
 762
 763 /// If this type is derived from a base type then return base type size.
 764 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
 765   unsigned Tag = Ty.getTag();
 766
 767   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 768       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 769       Tag != dwarf::DW_TAG_restrict_type)
 770     return Ty.getSizeInBits();
 771
 772   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
 773
 774   // If this type is not derived from any type or the type is a declaration then
 775   // take conservative approach.
 776   if (!BaseType.isValid() || BaseType.isForwardDecl())
 777     return Ty.getSizeInBits();
 778
 779   // If this is a derived type, go ahead and get the base type, unless it's a
 780   // reference then it's just the size of the field. Pointer types have no need
 781   // of this since they're a different type of qualification on the type.
 782   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
 783       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
 784     return Ty.getSizeInBits();
 785
 786   if (BaseType.isDerivedType())
 787     return getBaseTypeSize(DD, DIDerivedType(BaseType));
 788
 789   return BaseType.getSizeInBits();
 790 }
 791
 792 /// addConstantFPValue - Add constant value entry in variable DIE.
 793 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 794   assert(MO.isFPImm() && "Invalid machine operand!");
 795   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 796   APFloat FPImm = MO.getFPImm()->getValueAPF();
 797
 798   // Get the raw data form of the floating point.
 799   const APInt FltVal = FPImm.bitcastToAPInt();
 800   const char *FltPtr = (const char *)FltVal.getRawData();
 801
 802   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 803   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 804   int Incr = (LittleEndian ? 1 : -1);
 805   int Start = (LittleEndian ? 0 : NumBytes - 1);
 806   int Stop = (LittleEndian ? NumBytes : -1);
 807
 808   // Output the constant to DWARF one byte at a time.
 809   for (; Start != Stop; Start += Incr)
 810     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 811
 812   addBlock(Die, dwarf::DW_AT_const_value, Block);
 813 }
 814
 815 /// addConstantFPValue - Add constant value entry in variable DIE.
 816 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 817   // Pass this down to addConstantValue as an unsigned bag of bits.
 818   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 819 }
 820
 821 /// addConstantValue - Add constant value entry in variable DIE.
 822 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
 823   addConstantValue(Die, CI->getValue(), Ty);
 824 }
 825
 826 /// addConstantValue - Add constant value entry in variable DIE.
 827 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 828                                  DIType Ty) {
 829   assert(MO.isImm() && "Invalid machine operand!");
 830
 831   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 832 }
 833
 834 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 835   // FIXME: This is a bit conservative/simple - it emits negative values always
 836   // sign extended to 64 bits rather than minimizing the number of bytes.
 837   addUInt(Die, dwarf::DW_AT_const_value,
 838           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 839 }
 840
 841 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
 842   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 843 }
 844
 845 // addConstantValue - Add constant value entry in variable DIE.
 846 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 847   unsigned CIBitWidth = Val.getBitWidth();
 848   if (CIBitWidth <= 64) {
 849     addConstantValue(Die, Unsigned,
 850                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 851     return;
 852   }
 853
 854   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 855
 856   // Get the raw data form of the large APInt.
 857   const uint64_t *Ptr64 = Val.getRawData();
 858
 859   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 860   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 861
 862   // Output the constant to DWARF one byte at a time.
 863   for (int i = 0; i < NumBytes; i++) {
 864     uint8_t c;
 865     if (LittleEndian)
 866       c = Ptr64[i / 8] >> (8 * (i & 7));
 867     else
 868       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 869     addUInt(*Block, dwarf::DW_FORM_data1, c);
 870   }
 871
 872   addBlock(Die, dwarf::DW_AT_const_value, Block);
 873 }
 874
 875 /// addTemplateParams - Add template parameters into buffer.
 876 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 877   // Add template parameters.
 878   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 879     DIDescriptor Element = TParams.getElement(i);
 880     if (Element.isTemplateTypeParameter())
 881       constructTemplateTypeParameterDIE(Buffer,
 882                                         DITemplateTypeParameter(Element));
 883     else if (Element.isTemplateValueParameter())
 884       constructTemplateValueParameterDIE(Buffer,
 885                                          DITemplateValueParameter(Element));
 886   }
 887 }
 888
 889 /// getOrCreateContextDIE - Get context owner's DIE.
 890 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 891   if (!Context || Context.isFile())
 892     return &getUnitDie();
 893   if (Context.isType())
 894     return getOrCreateTypeDIE(DIType(Context));
 895   if (Context.isNameSpace())
 896     return getOrCreateNameSpace(DINameSpace(Context));
 897   if (Context.isSubprogram())
 898     return getOrCreateSubprogramDIE(DISubprogram(Context));
 899   return getDIE(Context);
 900 }
 901
 902 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
 903   DIScope Context = resolve(Ty.getContext());
 904   DIE *ContextDIE = getOrCreateContextDIE(Context);
 905
 906   if (DIE *TyDIE = getDIE(Ty))
 907     return TyDIE;
 908
 909   // Create new type.
 910   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 911
 912   constructTypeDIE(TyDIE, Ty);
 913
 914   updateAcceleratorTables(Context, Ty, TyDIE);
 915   return &TyDIE;
 916 }
 917
 918 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 919 /// given DIType.
 920 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 921   if (!TyNode)
 922     return nullptr;
 923
 924   DIType Ty(TyNode);
 925   assert(Ty.isType());
 926   assert(Ty == resolve(Ty.getRef()) &&
 927          "type was not uniqued, possible ODR violation.");
 928
 929   // DW_TAG_restrict_type is not supported in DWARF2
 930   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 931     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
 932
 933   // Construct the context before querying for the existence of the DIE in case
 934   // such construction creates the DIE.
 935   DIScope Context = resolve(Ty.getContext());
 936   DIE *ContextDIE = getOrCreateContextDIE(Context);
 937   assert(ContextDIE);
 938
 939   if (DIE *TyDIE = getDIE(Ty))
 940     return TyDIE;
 941
 942   // Create new type.
 943   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 944
 945   updateAcceleratorTables(Context, Ty, TyDIE);
 946
 947   if (Ty.isBasicType())
 948     constructTypeDIE(TyDIE, DIBasicType(Ty));
 949   else if (Ty.isCompositeType()) {
 950     DICompositeType CTy(Ty);
 951     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
 952       if (MDString *TypeId = CTy.getIdentifier()) {
 953         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 954         // Skip updating the accelerator tables since this is not the full type.
 955         return &TyDIE;
 956       }
 957     constructTypeDIE(TyDIE, CTy);
 958   } else {
 959     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 960     constructTypeDIE(TyDIE, DIDerivedType(Ty));
 961   }
 962
 963   return &TyDIE;
 964 }
 965
 966 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
 967                                         const DIE &TyDIE) {
 968   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 969     bool IsImplementation = 0;
 970     if (Ty.isCompositeType()) {
 971       DICompositeType CT(Ty);
 972       // A runtime language of 0 actually means C/C++ and that any
 973       // non-negative value is some version of Objective-C/C++.
 974       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
 975     }
 976     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 977     DD->addAccelType(Ty.getName(), TyDIE, Flags);
 978
 979     if (!Context || Context.isCompileUnit() || Context.isFile() ||
 980         Context.isNameSpace())
 981       addGlobalType(Ty, TyDIE, Context);
 982   }
 983 }
 984
 985 /// addType - Add a new type attribute to the specified entity.
 986 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 987   assert(Ty && "Trying to add a type that doesn't exist?");
 988
 989   // Check for pre-existence.
 990   DIEEntry *Entry = getDIEEntry(Ty);
 991   // If it exists then use the existing value.
 992   if (Entry) {
 993     addDIEEntry(Entity, Attribute, Entry);
 994     return;
 995   }
 996
 997   // Construct type.
 998   DIE *Buffer = getOrCreateTypeDIE(Ty);
 999
1000   // Set up proxy.
1001   Entry = createDIEEntry(*Buffer);
1002   insertDIEEntry(Ty, Entry);
1003   addDIEEntry(Entity, Attribute, Entry);
1004 }
1005
1006 /// getParentContextString - Walks the metadata parent chain in a language
1007 /// specific manner (using the compile unit language) and returns
1008 /// it as a string. This is done at the metadata level because DIEs may
1009 /// not currently have been added to the parent context and walking the
1010 /// DIEs looking for names is more expensive than walking the metadata.
1011 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1012   if (!Context)
1013     return "";
1014
1015   // FIXME: Decide whether to implement this for non-C++ languages.
1016   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1017     return "";
1018
1019   std::string CS;
1020   SmallVector<DIScope, 1> Parents;
1021   while (!Context.isCompileUnit()) {
1022     Parents.push_back(Context);
1023     if (Context.getContext())
1024       Context = resolve(Context.getContext());
1025     else
1026       // Structure, etc types will have a NULL context if they're at the top
1027       // level.
1028       break;
1029   }
1030
1031   // Reverse iterate over our list to go from the outermost construct to the
1032   // innermost.
1033   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1034                                                   E = Parents.rend();
1035        I != E; ++I) {
1036     DIScope Ctx = *I;
1037     StringRef Name = Ctx.getName();
1038     if (Name.empty() && Ctx.isNameSpace())
1039       Name = "(anonymous namespace)";
1040     if (!Name.empty()) {
1041       CS += Name;
1042       CS += "::";
1043     }
1044   }
1045   return CS;
1046 }
1047
1048 /// constructTypeDIE - Construct basic type die from DIBasicType.
1049 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1050   // Get core information.
1051   StringRef Name = BTy.getName();
1052   // Add name if not anonymous or intermediate type.
1053   if (!Name.empty())
1054     addString(Buffer, dwarf::DW_AT_name, Name);
1055
1056   // An unspecified type only has a name attribute.
1057   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1058     return;
1059
1060   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1061           BTy.getEncoding());
1062
1063   uint64_t Size = BTy.getSizeInBits() >> 3;
1064   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1065 }
1066
1067 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1068 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1069   // Get core information.
1070   StringRef Name = DTy.getName();
1071   uint64_t Size = DTy.getSizeInBits() >> 3;
1072   uint16_t Tag = Buffer.getTag();
1073
1074   // Map to main type, void will not have a type.
1075   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1076   if (FromTy)
1077     addType(Buffer, FromTy);
1078
1079   // Add name if not anonymous or intermediate type.
1080   if (!Name.empty())
1081     addString(Buffer, dwarf::DW_AT_name, Name);
1082
1083   // Add size if non-zero (derived types might be zero-sized.)
1084   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1085     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1086
1087   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1088     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1089                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1090   // Add source line info if available and TyDesc is not a forward declaration.
1091   if (!DTy.isForwardDecl())
1092     addSourceLine(Buffer, DTy);
1093 }
1094
1095 /// constructSubprogramArguments - Construct function argument DIEs.
1096 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1097   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1098     DIType Ty = resolve(Args.getElement(i));
1099     if (!Ty) {
1100       assert(i == N-1 && "Unspecified parameter must be the last argument");
1101       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1102     } else {
1103       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1104       addType(Arg, Ty);
1105       if (Ty.isArtificial())
1106         addFlag(Arg, dwarf::DW_AT_artificial);
1107     }
1108   }
1109 }
1110
1111 /// constructTypeDIE - Construct type DIE from DICompositeType.
1112 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1113   // Add name if not anonymous or intermediate type.
1114   StringRef Name = CTy.getName();
1115
1116   uint64_t Size = CTy.getSizeInBits() >> 3;
1117   uint16_t Tag = Buffer.getTag();
1118
1119   switch (Tag) {
1120   case dwarf::DW_TAG_array_type:
1121     constructArrayTypeDIE(Buffer, CTy);
1122     break;
1123   case dwarf::DW_TAG_enumeration_type:
1124     constructEnumTypeDIE(Buffer, CTy);
1125     break;
1126   case dwarf::DW_TAG_subroutine_type: {
1127     // Add return type. A void return won't have a type.
1128     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1129     DIType RTy(resolve(Elements.getElement(0)));
1130     if (RTy)
1131       addType(Buffer, RTy);
1132
1133     bool isPrototyped = true;
1134     if (Elements.getNumElements() == 2 &&
1135         !Elements.getElement(1))
1136       isPrototyped = false;
1137
1138     constructSubprogramArguments(Buffer, Elements);
1139
1140     // Add prototype flag if we're dealing with a C language and the
1141     // function has been prototyped.
1142     uint16_t Language = getLanguage();
1143     if (isPrototyped &&
1144         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1145          Language == dwarf::DW_LANG_ObjC))
1146       addFlag(Buffer, dwarf::DW_AT_prototyped);
1147
1148     if (CTy.isLValueReference())
1149       addFlag(Buffer, dwarf::DW_AT_reference);
1150
1151     if (CTy.isRValueReference())
1152       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1153   } break;
1154   case dwarf::DW_TAG_structure_type:
1155   case dwarf::DW_TAG_union_type:
1156   case dwarf::DW_TAG_class_type: {
1157     // Add elements to structure type.
1158     DIArray Elements = CTy.getElements();
1159     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1160       DIDescriptor Element = Elements.getElement(i);
1161       if (Element.isSubprogram())
1162         getOrCreateSubprogramDIE(DISubprogram(Element));
1163       else if (Element.isDerivedType()) {
1164         DIDerivedType DDTy(Element);
1165         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1166           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1167           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1168                   dwarf::DW_AT_friend);
1169         } else if (DDTy.isStaticMember()) {
1170           getOrCreateStaticMemberDIE(DDTy);
1171         } else {
1172           constructMemberDIE(Buffer, DDTy);
1173         }
1174       } else if (Element.isObjCProperty()) {
1175         DIObjCProperty Property(Element);
1176         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1177         StringRef PropertyName = Property.getObjCPropertyName();
1178         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1179         if (Property.getType())
1180           addType(ElemDie, Property.getType());
1181         addSourceLine(ElemDie, Property);
1182         StringRef GetterName = Property.getObjCPropertyGetterName();
1183         if (!GetterName.empty())
1184           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1185         StringRef SetterName = Property.getObjCPropertySetterName();
1186         if (!SetterName.empty())
1187           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1188         unsigned PropertyAttributes = 0;
1189         if (Property.isReadOnlyObjCProperty())
1190           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1191         if (Property.isReadWriteObjCProperty())
1192           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1193         if (Property.isAssignObjCProperty())
1194           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1195         if (Property.isRetainObjCProperty())
1196           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1197         if (Property.isCopyObjCProperty())
1198           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1199         if (Property.isNonAtomicObjCProperty())
1200           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1201         if (PropertyAttributes)
1202           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1203                   PropertyAttributes);
1204
1205         DIEEntry *Entry = getDIEEntry(Element);
1206         if (!Entry) {
1207           Entry = createDIEEntry(ElemDie);
1208           insertDIEEntry(Element, Entry);
1209         }
1210       } else
1211         continue;
1212     }
1213
1214     if (CTy.isAppleBlockExtension())
1215       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1216
1217     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1218     if (ContainingType)
1219       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1220                   *getOrCreateTypeDIE(ContainingType));
1221
1222     if (CTy.isObjcClassComplete())
1223       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1224
1225     // Add template parameters to a class, structure or union types.
1226     // FIXME: The support isn't in the metadata for this yet.
1227     if (Tag == dwarf::DW_TAG_class_type ||
1228         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1229       addTemplateParams(Buffer, CTy.getTemplateParams());
1230
1231     break;
1232   }
1233   default:
1234     break;
1235   }
1236
1237   // Add name if not anonymous or intermediate type.
1238   if (!Name.empty())
1239     addString(Buffer, dwarf::DW_AT_name, Name);
1240
1241   if (Tag == dwarf::DW_TAG_enumeration_type ||
1242       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1243       Tag == dwarf::DW_TAG_union_type) {
1244     // Add size if non-zero (derived types might be zero-sized.)
1245     // TODO: Do we care about size for enum forward declarations?
1246     if (Size)
1247       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1248     else if (!CTy.isForwardDecl())
1249       // Add zero size if it is not a forward declaration.
1250       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1251
1252     // If we're a forward decl, say so.
1253     if (CTy.isForwardDecl())
1254       addFlag(Buffer, dwarf::DW_AT_declaration);
1255
1256     // Add source line info if available.
1257     if (!CTy.isForwardDecl())
1258       addSourceLine(Buffer, CTy);
1259
1260     // No harm in adding the runtime language to the declaration.
1261     unsigned RLang = CTy.getRunTimeLang();
1262     if (RLang)
1263       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1264               RLang);
1265   }
1266 }
1267
1268 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1269 /// DITemplateTypeParameter.
1270 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1271                                                   DITemplateTypeParameter TP) {
1272   DIE &ParamDIE =
1273       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1274   // Add the type if it exists, it could be void and therefore no type.
1275   if (TP.getType())
1276     addType(ParamDIE, resolve(TP.getType()));
1277   if (!TP.getName().empty())
1278     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1279 }
1280
1281 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1282 /// DITemplateValueParameter.
1283 void
1284 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1285                                               DITemplateValueParameter VP) {
1286   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1287
1288   // Add the type if there is one, template template and template parameter
1289   // packs will not have a type.
1290   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1291     addType(ParamDIE, resolve(VP.getType()));
1292   if (!VP.getName().empty())
1293     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1294   if (Value *Val = VP.getValue()) {
1295     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1296       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1297     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1298       // For declaration non-type template parameters (such as global values and
1299       // functions)
1300       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1301       addOpAddress(*Loc, Asm->getSymbol(GV));
1302       // Emit DW_OP_stack_value to use the address as the immediate value of the
1303       // parameter, rather than a pointer to it.
1304       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1305       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1306     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1307       assert(isa<MDString>(Val));
1308       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1309                 cast<MDString>(Val)->getString());
1310     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1311       assert(isa<MDNode>(Val));
1312       DIArray A(cast<MDNode>(Val));
1313       addTemplateParams(ParamDIE, A);
1314     }
1315   }
1316 }
1317
1318 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1319 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1320   // Construct the context before querying for the existence of the DIE in case
1321   // such construction creates the DIE.
1322   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1323
1324   if (DIE *NDie = getDIE(NS))
1325     return NDie;
1326   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1327
1328   StringRef Name = NS.getName();
1329   if (!Name.empty())
1330     addString(NDie, dwarf::DW_AT_name, NS.getName());
1331   else
1332     Name = "(anonymous namespace)";
1333   DD->addAccelNamespace(Name, NDie);
1334   addGlobalName(Name, NDie, NS.getContext());
1335   addSourceLine(NDie, NS);
1336   return &NDie;
1337 }
1338
1339 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1340 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1341   // Construct the context before querying for the existence of the DIE in case
1342   // such construction creates the DIE (as is the case for member function
1343   // declarations).
1344   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1345
1346   if (DIE *SPDie = getDIE(SP))
1347     return SPDie;
1348
1349   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1350     // Add subprogram definitions to the CU die directly.
1351     ContextDIE = &getUnitDie();
1352     // Build the decl now to ensure it precedes the definition.
1353     getOrCreateSubprogramDIE(SPDecl);
1354   }
1355
1356   // DW_TAG_inlined_subroutine may refer to this DIE.
1357   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1358
1359   // Stop here and fill this in later, depending on whether or not this
1360   // subprogram turns out to have inlined instances or not.
1361   if (SP.isDefinition())
1362     return &SPDie;
1363
1364   applySubprogramAttributes(SP, SPDie);
1365   return &SPDie;
1366 }
1367
1368 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) {
1369   DISubprogram SPDecl = SP.getFunctionDeclaration();
1370   DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
1371   applySubprogramAttributes(SP, SPDie);
1372   addGlobalName(SP.getName(), SPDie, Context);
1373 }
1374
1375 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1376   DIE *DeclDie = nullptr;
1377   StringRef DeclLinkageName;
1378   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1379     DeclDie = getDIE(SPDecl);
1380     assert(DeclDie && "This DIE should've already been constructed when the "
1381                       "definition DIE was created in "
1382                       "getOrCreateSubprogramDIE");
1383     DeclLinkageName = SPDecl.getLinkageName();
1384   }
1385
1386   // Add function template parameters.
1387   addTemplateParams(SPDie, SP.getTemplateParams());
1388
1389   // Add the linkage name if we have one and it isn't in the Decl.
1390   StringRef LinkageName = SP.getLinkageName();
1391   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1392           LinkageName == DeclLinkageName) &&
1393          "decl has a linkage name and it is different");
1394   if (!LinkageName.empty() && DeclLinkageName.empty())
1395     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1396               GlobalValue::getRealLinkageName(LinkageName));
1397
1398   if (DeclDie) {
1399     // Refer to the function declaration where all the other attributes will be
1400     // found.
1401     addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1402     return;
1403   }
1404
1405   // Constructors and operators for anonymous aggregates do not have names.
1406   if (!SP.getName().empty())
1407     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1408
1409   // Skip the rest of the attributes under -gmlt to save space.
1410   if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1411     return;
1412
1413   addSourceLine(SPDie, SP);
1414
1415   // Add the prototype if we have a prototype and we have a C like
1416   // language.
1417   uint16_t Language = getLanguage();
1418   if (SP.isPrototyped() &&
1419       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1420        Language == dwarf::DW_LANG_ObjC))
1421     addFlag(SPDie, dwarf::DW_AT_prototyped);
1422
1423   DISubroutineType SPTy = SP.getType();
1424   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1425          "the type of a subprogram should be a subroutine");
1426
1427   DITypeArray Args = SPTy.getTypeArray();
1428   // Add a return type. If this is a type like a C/C++ void type we don't add a
1429   // return type.
1430   if (resolve(Args.getElement(0)))
1431     addType(SPDie, DIType(resolve(Args.getElement(0))));
1432
1433   unsigned VK = SP.getVirtuality();
1434   if (VK) {
1435     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1436     DIELoc *Block = getDIELoc();
1437     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1438     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1439     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1440     ContainingTypeMap.insert(
1441         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1442   }
1443
1444   if (!SP.isDefinition()) {
1445     addFlag(SPDie, dwarf::DW_AT_declaration);
1446
1447     // Add arguments. Do not add arguments for subprogram definition. They will
1448     // be handled while processing variables.
1449     constructSubprogramArguments(SPDie, Args);
1450   }
1451
1452   if (SP.isArtificial())
1453     addFlag(SPDie, dwarf::DW_AT_artificial);
1454
1455   if (!SP.isLocalToUnit())
1456     addFlag(SPDie, dwarf::DW_AT_external);
1457
1458   if (SP.isOptimized())
1459     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1460
1461   if (unsigned isa = Asm->getISAEncoding()) {
1462     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1463   }
1464
1465   if (SP.isLValueReference())
1466     addFlag(SPDie, dwarf::DW_AT_reference);
1467
1468   if (SP.isRValueReference())
1469     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1470
1471   if (SP.isProtected())
1472     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1473             dwarf::DW_ACCESS_protected);
1474   else if (SP.isPrivate())
1475     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1476             dwarf::DW_ACCESS_private);
1477   else if (SP.isPublic())
1478     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1479             dwarf::DW_ACCESS_public);
1480
1481   if (SP.isExplicit())
1482     addFlag(SPDie, dwarf::DW_AT_explicit);
1483 }
1484
1485 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var,
1486                                         DIE &VariableDie) {
1487   StringRef Name = Var.getName();
1488   if (!Name.empty())
1489     addString(VariableDie, dwarf::DW_AT_name, Name);
1490   addSourceLine(VariableDie, Var.getVariable());
1491   addType(VariableDie, Var.getType());
1492   if (Var.isArtificial())
1493     addFlag(VariableDie, dwarf::DW_AT_artificial);
1494 }
1495
1496 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1497 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1498   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1499   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1500
1501   // The LowerBound value defines the lower bounds which is typically zero for
1502   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1503   // Count == -1 then the array is unbounded and we do not emit
1504   // DW_AT_lower_bound and DW_AT_count attributes.
1505   int64_t LowerBound = SR.getLo();
1506   int64_t DefaultLowerBound = getDefaultLowerBound();
1507   int64_t Count = SR.getCount();
1508
1509   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1510     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1511
1512   if (Count != -1)
1513     // FIXME: An unbounded array should reference the expression that defines
1514     // the array.
1515     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1516 }
1517
1518 DIE *DwarfUnit::getIndexTyDie() {
1519   if (IndexTyDie)
1520     return IndexTyDie;
1521   // Construct an integer type to use for indexes.
1522   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1523   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1524   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1525   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1526           dwarf::DW_ATE_unsigned);
1527   return IndexTyDie;
1528 }
1529
1530 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1531 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1532   if (CTy.isVector())
1533     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1534
1535   // Emit the element type.
1536   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1537
1538   // Get an anonymous type for index type.
1539   // FIXME: This type should be passed down from the front end
1540   // as different languages may have different sizes for indexes.
1541   DIE *IdxTy = getIndexTyDie();
1542
1543   // Add subranges to array type.
1544   DIArray Elements = CTy.getElements();
1545   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1546     DIDescriptor Element = Elements.getElement(i);
1547     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1548       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1549   }
1550 }
1551
1552 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1553 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1554   DIArray Elements = CTy.getElements();
1555
1556   // Add enumerators to enumeration type.
1557   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1558     DIEnumerator Enum(Elements.getElement(i));
1559     if (Enum.isEnumerator()) {
1560       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1561       StringRef Name = Enum.getName();
1562       addString(Enumerator, dwarf::DW_AT_name, Name);
1563       int64_t Value = Enum.getEnumValue();
1564       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1565               Value);
1566     }
1567   }
1568   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1569   if (DTy) {
1570     addType(Buffer, DTy);
1571     addFlag(Buffer, dwarf::DW_AT_enum_class);
1572   }
1573 }
1574
1575 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1576 /// vtables.
1577 void DwarfUnit::constructContainingTypeDIEs() {
1578   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1579                                                  CE = ContainingTypeMap.end();
1580        CI != CE; ++CI) {
1581     DIE &SPDie = *CI->first;
1582     DIDescriptor D(CI->second);
1583     if (!D)
1584       continue;
1585     DIE *NDie = getDIE(D);
1586     if (!NDie)
1587       continue;
1588     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1589   }
1590 }
1591
1592 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1593 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1594   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1595   StringRef Name = DT.getName();
1596   if (!Name.empty())
1597     addString(MemberDie, dwarf::DW_AT_name, Name);
1598
1599   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1600
1601   addSourceLine(MemberDie, DT);
1602
1603   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1604
1605     // For C++, virtual base classes are not at fixed offset. Use following
1606     // expression to extract appropriate offset from vtable.
1607     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1608
1609     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1610     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1611     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1612     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1613     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1614     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1615     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1616     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1617
1618     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1619   } else {
1620     uint64_t Size = DT.getSizeInBits();
1621     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1622     uint64_t OffsetInBytes;
1623
1624     if (Size != FieldSize) {
1625       // Handle bitfield, assume bytes are 8 bits.
1626       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1627       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1628
1629       uint64_t Offset = DT.getOffsetInBits();
1630       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1631       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1632       uint64_t FieldOffset = (HiMark - FieldSize);
1633       Offset -= FieldOffset;
1634
1635       // Maybe we need to work from the other end.
1636       if (Asm->getDataLayout().isLittleEndian())
1637         Offset = FieldSize - (Offset + Size);
1638       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1639
1640       // Here DW_AT_data_member_location points to the anonymous
1641       // field that includes this bit field.
1642       OffsetInBytes = FieldOffset >> 3;
1643     } else
1644       // This is not a bitfield.
1645       OffsetInBytes = DT.getOffsetInBits() >> 3;
1646
1647     if (DD->getDwarfVersion() <= 2) {
1648       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1649       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1650       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1651       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1652     } else
1653       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1654               OffsetInBytes);
1655   }
1656
1657   if (DT.isProtected())
1658     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1659             dwarf::DW_ACCESS_protected);
1660   else if (DT.isPrivate())
1661     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1662             dwarf::DW_ACCESS_private);
1663   // Otherwise C++ member and base classes are considered public.
1664   else if (DT.isPublic())
1665     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1666             dwarf::DW_ACCESS_public);
1667   if (DT.isVirtual())
1668     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1669             dwarf::DW_VIRTUALITY_virtual);
1670
1671   // Objective-C properties.
1672   if (MDNode *PNode = DT.getObjCProperty())
1673     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1674       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1675                          PropertyDie);
1676
1677   if (DT.isArtificial())
1678     addFlag(MemberDie, dwarf::DW_AT_artificial);
1679 }
1680
1681 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1682 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1683   if (!DT.Verify())
1684     return nullptr;
1685
1686   // Construct the context before querying for the existence of the DIE in case
1687   // such construction creates the DIE.
1688   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1689   assert(dwarf::isType(ContextDIE->getTag()) &&
1690          "Static member should belong to a type.");
1691
1692   if (DIE *StaticMemberDIE = getDIE(DT))
1693     return StaticMemberDIE;
1694
1695   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1696
1697   DIType Ty = resolve(DT.getTypeDerivedFrom());
1698
1699   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1700   addType(StaticMemberDIE, Ty);
1701   addSourceLine(StaticMemberDIE, DT);
1702   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1703   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1704
1705   // FIXME: We could omit private if the parent is a class_type, and
1706   // public if the parent is something else.
1707   if (DT.isProtected())
1708     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1709             dwarf::DW_ACCESS_protected);
1710   else if (DT.isPrivate())
1711     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1712             dwarf::DW_ACCESS_private);
1713   else if (DT.isPublic())
1714     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1715             dwarf::DW_ACCESS_public);
1716
1717   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1718     addConstantValue(StaticMemberDIE, CI, Ty);
1719   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1720     addConstantFPValue(StaticMemberDIE, CFP);
1721
1722   return &StaticMemberDIE;
1723 }
1724
1725 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1726   // Emit size of content not including length itself
1727   Asm->OutStreamer.AddComment("Length of Unit");
1728   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1729
1730   Asm->OutStreamer.AddComment("DWARF version number");
1731   Asm->EmitInt16(DD->getDwarfVersion());
1732   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1733   // We share one abbreviations table across all units so it's always at the
1734   // start of the section. Use a relocatable offset where needed to ensure
1735   // linking doesn't invalidate that offset.
1736   if (ASectionSym)
1737     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1738   else
1739     // Use a constant value when no symbol is provided.
1740     Asm->EmitInt32(0);
1741   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1742   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1743 }
1744
1745 void DwarfUnit::initSection(const MCSection *Section) {
1746   assert(!this->Section);
1747   this->Section = Section;
1748 }
1749
1750 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1751   DwarfUnit::emitHeader(ASectionSym);
1752   Asm->OutStreamer.AddComment("Type Signature");
1753   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1754   Asm->OutStreamer.AddComment("Type DIE Offset");
1755   // In a skeleton type unit there is no type DIE so emit a zero offset.
1756   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1757                                 sizeof(Ty->getOffset()));
1758 }
1759