lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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