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         getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
 982       GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
 983           &TyDIE;
 984   }
 985 }
 986
 987 /// addType - Add a new type attribute to the specified entity.
 988 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 989   assert(Ty && "Trying to add a type that doesn't exist?");
 990
 991   // Check for pre-existence.
 992   DIEEntry *Entry = getDIEEntry(Ty);
 993   // If it exists then use the existing value.
 994   if (Entry) {
 995     addDIEEntry(Entity, Attribute, Entry);
 996     return;
 997   }
 998
 999   // Construct type.
1000   DIE *Buffer = getOrCreateTypeDIE(Ty);
1001
1002   // Set up proxy.
1003   Entry = createDIEEntry(*Buffer);
1004   insertDIEEntry(Ty, Entry);
1005   addDIEEntry(Entity, Attribute, Entry);
1006 }
1007
1008 /// addGlobalName - Add a new global name to the compile unit.
1009 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1010   if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1011     return;
1012   std::string FullName = getParentContextString(Context) + Name.str();
1013   GlobalNames[FullName] = &Die;
1014 }
1015
1016 /// getParentContextString - Walks the metadata parent chain in a language
1017 /// specific manner (using the compile unit language) and returns
1018 /// it as a string. This is done at the metadata level because DIEs may
1019 /// not currently have been added to the parent context and walking the
1020 /// DIEs looking for names is more expensive than walking the metadata.
1021 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1022   if (!Context)
1023     return "";
1024
1025   // FIXME: Decide whether to implement this for non-C++ languages.
1026   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1027     return "";
1028
1029   std::string CS;
1030   SmallVector<DIScope, 1> Parents;
1031   while (!Context.isCompileUnit()) {
1032     Parents.push_back(Context);
1033     if (Context.getContext())
1034       Context = resolve(Context.getContext());
1035     else
1036       // Structure, etc types will have a NULL context if they're at the top
1037       // level.
1038       break;
1039   }
1040
1041   // Reverse iterate over our list to go from the outermost construct to the
1042   // innermost.
1043   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1044                                                   E = Parents.rend();
1045        I != E; ++I) {
1046     DIScope Ctx = *I;
1047     StringRef Name = Ctx.getName();
1048     if (Name.empty() && Ctx.isNameSpace())
1049       Name = "(anonymous namespace)";
1050     if (!Name.empty()) {
1051       CS += Name;
1052       CS += "::";
1053     }
1054   }
1055   return CS;
1056 }
1057
1058 /// constructTypeDIE - Construct basic type die from DIBasicType.
1059 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1060   // Get core information.
1061   StringRef Name = BTy.getName();
1062   // Add name if not anonymous or intermediate type.
1063   if (!Name.empty())
1064     addString(Buffer, dwarf::DW_AT_name, Name);
1065
1066   // An unspecified type only has a name attribute.
1067   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1068     return;
1069
1070   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1071           BTy.getEncoding());
1072
1073   uint64_t Size = BTy.getSizeInBits() >> 3;
1074   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1075 }
1076
1077 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1078 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1079   // Get core information.
1080   StringRef Name = DTy.getName();
1081   uint64_t Size = DTy.getSizeInBits() >> 3;
1082   uint16_t Tag = Buffer.getTag();
1083
1084   // Map to main type, void will not have a type.
1085   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1086   if (FromTy)
1087     addType(Buffer, FromTy);
1088
1089   // Add name if not anonymous or intermediate type.
1090   if (!Name.empty())
1091     addString(Buffer, dwarf::DW_AT_name, Name);
1092
1093   // Add size if non-zero (derived types might be zero-sized.)
1094   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1095     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1096
1097   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1098     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1099                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1100   // Add source line info if available and TyDesc is not a forward declaration.
1101   if (!DTy.isForwardDecl())
1102     addSourceLine(Buffer, DTy);
1103 }
1104
1105 /// constructSubprogramArguments - Construct function argument DIEs.
1106 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1107   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1108     DIType Ty = resolve(Args.getElement(i));
1109     if (!Ty) {
1110       assert(i == N-1 && "Unspecified parameter must be the last argument");
1111       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1112     } else {
1113       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1114       addType(Arg, Ty);
1115       if (Ty.isArtificial())
1116         addFlag(Arg, dwarf::DW_AT_artificial);
1117     }
1118   }
1119 }
1120
1121 /// constructTypeDIE - Construct type DIE from DICompositeType.
1122 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1123   // Add name if not anonymous or intermediate type.
1124   StringRef Name = CTy.getName();
1125
1126   uint64_t Size = CTy.getSizeInBits() >> 3;
1127   uint16_t Tag = Buffer.getTag();
1128
1129   switch (Tag) {
1130   case dwarf::DW_TAG_array_type:
1131     constructArrayTypeDIE(Buffer, CTy);
1132     break;
1133   case dwarf::DW_TAG_enumeration_type:
1134     constructEnumTypeDIE(Buffer, CTy);
1135     break;
1136   case dwarf::DW_TAG_subroutine_type: {
1137     // Add return type. A void return won't have a type.
1138     DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1139     DIType RTy(resolve(Elements.getElement(0)));
1140     if (RTy)
1141       addType(Buffer, RTy);
1142
1143     bool isPrototyped = true;
1144     if (Elements.getNumElements() == 2 &&
1145         !Elements.getElement(1))
1146       isPrototyped = false;
1147
1148     constructSubprogramArguments(Buffer, Elements);
1149
1150     // Add prototype flag if we're dealing with a C language and the
1151     // function has been prototyped.
1152     uint16_t Language = getLanguage();
1153     if (isPrototyped &&
1154         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1155          Language == dwarf::DW_LANG_ObjC))
1156       addFlag(Buffer, dwarf::DW_AT_prototyped);
1157
1158     if (CTy.isLValueReference())
1159       addFlag(Buffer, dwarf::DW_AT_reference);
1160
1161     if (CTy.isRValueReference())
1162       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1163   } break;
1164   case dwarf::DW_TAG_structure_type:
1165   case dwarf::DW_TAG_union_type:
1166   case dwarf::DW_TAG_class_type: {
1167     // Add elements to structure type.
1168     DIArray Elements = CTy.getElements();
1169     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1170       DIDescriptor Element = Elements.getElement(i);
1171       if (Element.isSubprogram())
1172         getOrCreateSubprogramDIE(DISubprogram(Element));
1173       else if (Element.isDerivedType()) {
1174         DIDerivedType DDTy(Element);
1175         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1176           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1177           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1178                   dwarf::DW_AT_friend);
1179         } else if (DDTy.isStaticMember()) {
1180           getOrCreateStaticMemberDIE(DDTy);
1181         } else {
1182           constructMemberDIE(Buffer, DDTy);
1183         }
1184       } else if (Element.isObjCProperty()) {
1185         DIObjCProperty Property(Element);
1186         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1187         StringRef PropertyName = Property.getObjCPropertyName();
1188         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1189         if (Property.getType())
1190           addType(ElemDie, Property.getType());
1191         addSourceLine(ElemDie, Property);
1192         StringRef GetterName = Property.getObjCPropertyGetterName();
1193         if (!GetterName.empty())
1194           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1195         StringRef SetterName = Property.getObjCPropertySetterName();
1196         if (!SetterName.empty())
1197           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1198         unsigned PropertyAttributes = 0;
1199         if (Property.isReadOnlyObjCProperty())
1200           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1201         if (Property.isReadWriteObjCProperty())
1202           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1203         if (Property.isAssignObjCProperty())
1204           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1205         if (Property.isRetainObjCProperty())
1206           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1207         if (Property.isCopyObjCProperty())
1208           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1209         if (Property.isNonAtomicObjCProperty())
1210           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1211         if (PropertyAttributes)
1212           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1213                   PropertyAttributes);
1214
1215         DIEEntry *Entry = getDIEEntry(Element);
1216         if (!Entry) {
1217           Entry = createDIEEntry(ElemDie);
1218           insertDIEEntry(Element, Entry);
1219         }
1220       } else
1221         continue;
1222     }
1223
1224     if (CTy.isAppleBlockExtension())
1225       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1226
1227     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1228     if (ContainingType)
1229       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1230                   *getOrCreateTypeDIE(ContainingType));
1231
1232     if (CTy.isObjcClassComplete())
1233       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1234
1235     // Add template parameters to a class, structure or union types.
1236     // FIXME: The support isn't in the metadata for this yet.
1237     if (Tag == dwarf::DW_TAG_class_type ||
1238         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1239       addTemplateParams(Buffer, CTy.getTemplateParams());
1240
1241     break;
1242   }
1243   default:
1244     break;
1245   }
1246
1247   // Add name if not anonymous or intermediate type.
1248   if (!Name.empty())
1249     addString(Buffer, dwarf::DW_AT_name, Name);
1250
1251   if (Tag == dwarf::DW_TAG_enumeration_type ||
1252       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1253       Tag == dwarf::DW_TAG_union_type) {
1254     // Add size if non-zero (derived types might be zero-sized.)
1255     // TODO: Do we care about size for enum forward declarations?
1256     if (Size)
1257       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1258     else if (!CTy.isForwardDecl())
1259       // Add zero size if it is not a forward declaration.
1260       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1261
1262     // If we're a forward decl, say so.
1263     if (CTy.isForwardDecl())
1264       addFlag(Buffer, dwarf::DW_AT_declaration);
1265
1266     // Add source line info if available.
1267     if (!CTy.isForwardDecl())
1268       addSourceLine(Buffer, CTy);
1269
1270     // No harm in adding the runtime language to the declaration.
1271     unsigned RLang = CTy.getRunTimeLang();
1272     if (RLang)
1273       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1274               RLang);
1275   }
1276 }
1277
1278 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1279 /// DITemplateTypeParameter.
1280 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1281                                                   DITemplateTypeParameter TP) {
1282   DIE &ParamDIE =
1283       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1284   // Add the type if it exists, it could be void and therefore no type.
1285   if (TP.getType())
1286     addType(ParamDIE, resolve(TP.getType()));
1287   if (!TP.getName().empty())
1288     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1289 }
1290
1291 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1292 /// DITemplateValueParameter.
1293 void
1294 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1295                                               DITemplateValueParameter VP) {
1296   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1297
1298   // Add the type if there is one, template template and template parameter
1299   // packs will not have a type.
1300   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1301     addType(ParamDIE, resolve(VP.getType()));
1302   if (!VP.getName().empty())
1303     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1304   if (Value *Val = VP.getValue()) {
1305     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1306       addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1307     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1308       // For declaration non-type template parameters (such as global values and
1309       // functions)
1310       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1311       addOpAddress(*Loc, Asm->getSymbol(GV));
1312       // Emit DW_OP_stack_value to use the address as the immediate value of the
1313       // parameter, rather than a pointer to it.
1314       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1315       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1316     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1317       assert(isa<MDString>(Val));
1318       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1319                 cast<MDString>(Val)->getString());
1320     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1321       assert(isa<MDNode>(Val));
1322       DIArray A(cast<MDNode>(Val));
1323       addTemplateParams(ParamDIE, A);
1324     }
1325   }
1326 }
1327
1328 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1329 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1330   // Construct the context before querying for the existence of the DIE in case
1331   // such construction creates the DIE.
1332   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1333
1334   if (DIE *NDie = getDIE(NS))
1335     return NDie;
1336   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1337
1338   StringRef Name = NS.getName();
1339   if (!Name.empty())
1340     addString(NDie, dwarf::DW_AT_name, NS.getName());
1341   else
1342     Name = "(anonymous namespace)";
1343   DD->addAccelNamespace(Name, NDie);
1344   addGlobalName(Name, NDie, NS.getContext());
1345   addSourceLine(NDie, NS);
1346   return &NDie;
1347 }
1348
1349 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1350 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1351   // Construct the context before querying for the existence of the DIE in case
1352   // such construction creates the DIE (as is the case for member function
1353   // declarations).
1354   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1355
1356   if (DIE *SPDie = getDIE(SP))
1357     return SPDie;
1358
1359   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1360     // Add subprogram definitions to the CU die directly.
1361     ContextDIE = &getUnitDie();
1362     // Build the decl now to ensure it precedes the definition.
1363     getOrCreateSubprogramDIE(SPDecl);
1364   }
1365
1366   // DW_TAG_inlined_subroutine may refer to this DIE.
1367   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1368
1369   // Stop here and fill this in later, depending on whether or not this
1370   // subprogram turns out to have inlined instances or not.
1371   if (SP.isDefinition())
1372     return &SPDie;
1373
1374   applySubprogramAttributes(SP, SPDie);
1375   return &SPDie;
1376 }
1377
1378 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) {
1379   DISubprogram SPDecl = SP.getFunctionDeclaration();
1380   DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
1381   applySubprogramAttributes(SP, SPDie);
1382   addGlobalName(SP.getName(), SPDie, Context);
1383 }
1384
1385 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1386   DIE *DeclDie = nullptr;
1387   StringRef DeclLinkageName;
1388   if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1389     DeclDie = getDIE(SPDecl);
1390     assert(DeclDie && "This DIE should've already been constructed when the "
1391                       "definition DIE was created in "
1392                       "getOrCreateSubprogramDIE");
1393     DeclLinkageName = SPDecl.getLinkageName();
1394   }
1395
1396   // Add function template parameters.
1397   addTemplateParams(SPDie, SP.getTemplateParams());
1398
1399   // Add the linkage name if we have one and it isn't in the Decl.
1400   StringRef LinkageName = SP.getLinkageName();
1401   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1402           LinkageName == DeclLinkageName) &&
1403          "decl has a linkage name and it is different");
1404   if (!LinkageName.empty() && DeclLinkageName.empty())
1405     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1406               GlobalValue::getRealLinkageName(LinkageName));
1407
1408   if (DeclDie) {
1409     // Refer to the function declaration where all the other attributes will be
1410     // found.
1411     addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1412     return;
1413   }
1414
1415   // Constructors and operators for anonymous aggregates do not have names.
1416   if (!SP.getName().empty())
1417     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1418
1419   // Skip the rest of the attributes under -gmlt to save space.
1420   if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1421     return;
1422
1423   addSourceLine(SPDie, SP);
1424
1425   // Add the prototype if we have a prototype and we have a C like
1426   // language.
1427   uint16_t Language = getLanguage();
1428   if (SP.isPrototyped() &&
1429       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1430        Language == dwarf::DW_LANG_ObjC))
1431     addFlag(SPDie, dwarf::DW_AT_prototyped);
1432
1433   DISubroutineType SPTy = SP.getType();
1434   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1435          "the type of a subprogram should be a subroutine");
1436
1437   DITypeArray Args = SPTy.getTypeArray();
1438   // Add a return type. If this is a type like a C/C++ void type we don't add a
1439   // return type.
1440   if (resolve(Args.getElement(0)))
1441     addType(SPDie, DIType(resolve(Args.getElement(0))));
1442
1443   unsigned VK = SP.getVirtuality();
1444   if (VK) {
1445     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1446     DIELoc *Block = getDIELoc();
1447     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1448     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1449     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1450     ContainingTypeMap.insert(
1451         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1452   }
1453
1454   if (!SP.isDefinition()) {
1455     addFlag(SPDie, dwarf::DW_AT_declaration);
1456
1457     // Add arguments. Do not add arguments for subprogram definition. They will
1458     // be handled while processing variables.
1459     constructSubprogramArguments(SPDie, Args);
1460   }
1461
1462   if (SP.isArtificial())
1463     addFlag(SPDie, dwarf::DW_AT_artificial);
1464
1465   if (!SP.isLocalToUnit())
1466     addFlag(SPDie, dwarf::DW_AT_external);
1467
1468   if (SP.isOptimized())
1469     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1470
1471   if (unsigned isa = Asm->getISAEncoding()) {
1472     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1473   }
1474
1475   if (SP.isLValueReference())
1476     addFlag(SPDie, dwarf::DW_AT_reference);
1477
1478   if (SP.isRValueReference())
1479     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1480
1481   if (SP.isProtected())
1482     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1483             dwarf::DW_ACCESS_protected);
1484   else if (SP.isPrivate())
1485     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1486             dwarf::DW_ACCESS_private);
1487   else if (SP.isPublic())
1488     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1489             dwarf::DW_ACCESS_public);
1490
1491   if (SP.isExplicit())
1492     addFlag(SPDie, dwarf::DW_AT_explicit);
1493 }
1494
1495 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var,
1496                                         DIE &VariableDie) {
1497   StringRef Name = Var.getName();
1498   if (!Name.empty())
1499     addString(VariableDie, dwarf::DW_AT_name, Name);
1500   addSourceLine(VariableDie, Var.getVariable());
1501   addType(VariableDie, Var.getType());
1502   if (Var.isArtificial())
1503     addFlag(VariableDie, dwarf::DW_AT_artificial);
1504 }
1505
1506 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1507 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1508   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1509   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1510
1511   // The LowerBound value defines the lower bounds which is typically zero for
1512   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1513   // Count == -1 then the array is unbounded and we do not emit
1514   // DW_AT_lower_bound and DW_AT_count attributes.
1515   int64_t LowerBound = SR.getLo();
1516   int64_t DefaultLowerBound = getDefaultLowerBound();
1517   int64_t Count = SR.getCount();
1518
1519   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1520     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1521
1522   if (Count != -1)
1523     // FIXME: An unbounded array should reference the expression that defines
1524     // the array.
1525     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1526 }
1527
1528 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1529 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1530   if (CTy.isVector())
1531     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1532
1533   // Emit the element type.
1534   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1535
1536   // Get an anonymous type for index type.
1537   // FIXME: This type should be passed down from the front end
1538   // as different languages may have different sizes for indexes.
1539   DIE *IdxTy = getIndexTyDie();
1540   if (!IdxTy) {
1541     // Construct an integer type to use for indexes.
1542     IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1543     addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1544     addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1545     addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1546             dwarf::DW_ATE_unsigned);
1547     setIndexTyDie(IdxTy);
1548   }
1549
1550   // Add subranges to array type.
1551   DIArray Elements = CTy.getElements();
1552   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1553     DIDescriptor Element = Elements.getElement(i);
1554     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1555       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1556   }
1557 }
1558
1559 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1560 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1561   DIArray Elements = CTy.getElements();
1562
1563   // Add enumerators to enumeration type.
1564   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1565     DIEnumerator Enum(Elements.getElement(i));
1566     if (Enum.isEnumerator()) {
1567       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1568       StringRef Name = Enum.getName();
1569       addString(Enumerator, dwarf::DW_AT_name, Name);
1570       int64_t Value = Enum.getEnumValue();
1571       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1572               Value);
1573     }
1574   }
1575   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1576   if (DTy) {
1577     addType(Buffer, DTy);
1578     addFlag(Buffer, dwarf::DW_AT_enum_class);
1579   }
1580 }
1581
1582 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1583 /// vtables.
1584 void DwarfUnit::constructContainingTypeDIEs() {
1585   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1586                                                  CE = ContainingTypeMap.end();
1587        CI != CE; ++CI) {
1588     DIE &SPDie = *CI->first;
1589     DIDescriptor D(CI->second);
1590     if (!D)
1591       continue;
1592     DIE *NDie = getDIE(D);
1593     if (!NDie)
1594       continue;
1595     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1596   }
1597 }
1598
1599 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1600 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1601   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1602   StringRef Name = DT.getName();
1603   if (!Name.empty())
1604     addString(MemberDie, dwarf::DW_AT_name, Name);
1605
1606   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1607
1608   addSourceLine(MemberDie, DT);
1609
1610   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1611
1612     // For C++, virtual base classes are not at fixed offset. Use following
1613     // expression to extract appropriate offset from vtable.
1614     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1615
1616     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1617     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1618     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1619     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1620     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1621     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1622     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1623     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1624
1625     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1626   } else {
1627     uint64_t Size = DT.getSizeInBits();
1628     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1629     uint64_t OffsetInBytes;
1630
1631     if (Size != FieldSize) {
1632       // Handle bitfield, assume bytes are 8 bits.
1633       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1634       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1635
1636       uint64_t Offset = DT.getOffsetInBits();
1637       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1638       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1639       uint64_t FieldOffset = (HiMark - FieldSize);
1640       Offset -= FieldOffset;
1641
1642       // Maybe we need to work from the other end.
1643       if (Asm->getDataLayout().isLittleEndian())
1644         Offset = FieldSize - (Offset + Size);
1645       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1646
1647       // Here DW_AT_data_member_location points to the anonymous
1648       // field that includes this bit field.
1649       OffsetInBytes = FieldOffset >> 3;
1650     } else
1651       // This is not a bitfield.
1652       OffsetInBytes = DT.getOffsetInBits() >> 3;
1653
1654     if (DD->getDwarfVersion() <= 2) {
1655       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1656       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1657       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1658       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1659     } else
1660       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1661               OffsetInBytes);
1662   }
1663
1664   if (DT.isProtected())
1665     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1666             dwarf::DW_ACCESS_protected);
1667   else if (DT.isPrivate())
1668     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1669             dwarf::DW_ACCESS_private);
1670   // Otherwise C++ member and base classes are considered public.
1671   else if (DT.isPublic())
1672     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1673             dwarf::DW_ACCESS_public);
1674   if (DT.isVirtual())
1675     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1676             dwarf::DW_VIRTUALITY_virtual);
1677
1678   // Objective-C properties.
1679   if (MDNode *PNode = DT.getObjCProperty())
1680     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1681       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1682                          PropertyDie);
1683
1684   if (DT.isArtificial())
1685     addFlag(MemberDie, dwarf::DW_AT_artificial);
1686 }
1687
1688 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1689 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1690   if (!DT.Verify())
1691     return nullptr;
1692
1693   // Construct the context before querying for the existence of the DIE in case
1694   // such construction creates the DIE.
1695   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1696   assert(dwarf::isType(ContextDIE->getTag()) &&
1697          "Static member should belong to a type.");
1698
1699   if (DIE *StaticMemberDIE = getDIE(DT))
1700     return StaticMemberDIE;
1701
1702   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1703
1704   DIType Ty = resolve(DT.getTypeDerivedFrom());
1705
1706   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1707   addType(StaticMemberDIE, Ty);
1708   addSourceLine(StaticMemberDIE, DT);
1709   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1710   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1711
1712   // FIXME: We could omit private if the parent is a class_type, and
1713   // public if the parent is something else.
1714   if (DT.isProtected())
1715     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1716             dwarf::DW_ACCESS_protected);
1717   else if (DT.isPrivate())
1718     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1719             dwarf::DW_ACCESS_private);
1720   else if (DT.isPublic())
1721     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1722             dwarf::DW_ACCESS_public);
1723
1724   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1725     addConstantValue(StaticMemberDIE, CI, Ty);
1726   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1727     addConstantFPValue(StaticMemberDIE, CFP);
1728
1729   return &StaticMemberDIE;
1730 }
1731
1732 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1733   Asm->OutStreamer.AddComment("DWARF version number");
1734   Asm->EmitInt16(DD->getDwarfVersion());
1735   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1736   // We share one abbreviations table across all units so it's always at the
1737   // start of the section. Use a relocatable offset where needed to ensure
1738   // linking doesn't invalidate that offset.
1739   if (ASectionSym)
1740     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1741   else
1742     // Use a constant value when no symbol is provided.
1743     Asm->EmitInt32(0);
1744   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1745   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1746 }
1747
1748 void DwarfUnit::initSection(const MCSection *Section) {
1749   assert(!this->Section);
1750   this->Section = Section;
1751   this->LabelBegin =
1752       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
1753 }
1754
1755 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1756   DwarfUnit::emitHeader(ASectionSym);
1757   Asm->OutStreamer.AddComment("Type Signature");
1758   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1759   Asm->OutStreamer.AddComment("Type DIE Offset");
1760   // In a skeleton type unit there is no type DIE so emit a zero offset.
1761   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1762                                 sizeof(Ty->getOffset()));
1763 }
1764