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 /// isTypeSigned - Return true if the type is signed.
 749 static bool isTypeSigned(DwarfDebug *DD, DIType Ty) {
 750   if (Ty.isDerivedType())
 751     return isTypeSigned(DD,
 752                         DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
 753
 754   return Ty.isBasicType() &&
 755          (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
 756           DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char);
 757 }
 758
 759 /// Return true if type encoding is unsigned.
 760 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
 761   DIDerivedType DTy(Ty);
 762   if (DTy.isDerivedType())
 763     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
 764
 765   DIBasicType BTy(Ty);
 766   if (BTy.isBasicType()) {
 767     unsigned Encoding = BTy.getEncoding();
 768     if (Encoding == dwarf::DW_ATE_unsigned ||
 769         Encoding == dwarf::DW_ATE_unsigned_char ||
 770         Encoding == dwarf::DW_ATE_boolean)
 771       return true;
 772   }
 773   return false;
 774 }
 775
 776 /// If this type is derived from a base type then return base type size.
 777 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
 778   unsigned Tag = Ty.getTag();
 779
 780   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 781       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 782       Tag != dwarf::DW_TAG_restrict_type)
 783     return Ty.getSizeInBits();
 784
 785   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
 786
 787   // If this type is not derived from any type or the type is a declaration then
 788   // take conservative approach.
 789   if (!BaseType.isValid() || BaseType.isForwardDecl())
 790     return Ty.getSizeInBits();
 791
 792   // If this is a derived type, go ahead and get the base type, unless it's a
 793   // reference then it's just the size of the field. Pointer types have no need
 794   // of this since they're a different type of qualification on the type.
 795   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
 796       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
 797     return Ty.getSizeInBits();
 798
 799   if (BaseType.isDerivedType())
 800     return getBaseTypeSize(DD, DIDerivedType(BaseType));
 801
 802   return BaseType.getSizeInBits();
 803 }
 804
 805 /// addConstantFPValue - Add constant value entry in variable DIE.
 806 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 807   assert(MO.isFPImm() && "Invalid machine operand!");
 808   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 809   APFloat FPImm = MO.getFPImm()->getValueAPF();
 810
 811   // Get the raw data form of the floating point.
 812   const APInt FltVal = FPImm.bitcastToAPInt();
 813   const char *FltPtr = (const char *)FltVal.getRawData();
 814
 815   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 816   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 817   int Incr = (LittleEndian ? 1 : -1);
 818   int Start = (LittleEndian ? 0 : NumBytes - 1);
 819   int Stop = (LittleEndian ? NumBytes : -1);
 820
 821   // Output the constant to DWARF one byte at a time.
 822   for (; Start != Stop; Start += Incr)
 823     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 824
 825   addBlock(Die, dwarf::DW_AT_const_value, Block);
 826 }
 827
 828 /// addConstantFPValue - Add constant value entry in variable DIE.
 829 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 830   // Pass this down to addConstantValue as an unsigned bag of bits.
 831   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 832 }
 833
 834 /// addConstantValue - Add constant value entry in variable DIE.
 835 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 836                                  bool Unsigned) {
 837   addConstantValue(Die, CI->getValue(), Unsigned);
 838 }
 839
 840 /// addConstantValue - Add constant value entry in variable DIE.
 841 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 842                                  DIType Ty) {
 843   assert(MO.isImm() && "Invalid machine operand!");
 844
 845   addConstantValue(Die, isTypeSigned(DD, Ty), MO.getImm());
 846 }
 847
 848 void DwarfUnit::addConstantValue(DIE &Die, bool Signed, uint64_t Val) {
 849   // FIXME: This is a bit conservative/simple - it emits negative values always
 850   // sign extended to 64 bits rather than minimizing the number of bytes.
 851   addUInt(Die, dwarf::DW_AT_const_value,
 852           Signed ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata, Val);
 853 }
 854
 855 // addConstantValue - Add constant value entry in variable DIE.
 856 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 857   unsigned CIBitWidth = Val.getBitWidth();
 858   if (CIBitWidth <= 64) {
 859     addConstantValue(Die, !Unsigned, Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 860     return;
 861   }
 862
 863   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 864
 865   // Get the raw data form of the large APInt.
 866   const uint64_t *Ptr64 = Val.getRawData();
 867
 868   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 869   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 870
 871   // Output the constant to DWARF one byte at a time.
 872   for (int i = 0; i < NumBytes; i++) {
 873     uint8_t c;
 874     if (LittleEndian)
 875       c = Ptr64[i / 8] >> (8 * (i & 7));
 876     else
 877       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 878     addUInt(*Block, dwarf::DW_FORM_data1, c);
 879   }
 880
 881   addBlock(Die, dwarf::DW_AT_const_value, Block);
 882 }
 883
 884 /// addTemplateParams - Add template parameters into buffer.
 885 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 886   // Add template parameters.
 887   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 888     DIDescriptor Element = TParams.getElement(i);
 889     if (Element.isTemplateTypeParameter())
 890       constructTemplateTypeParameterDIE(Buffer,
 891                                         DITemplateTypeParameter(Element));
 892     else if (Element.isTemplateValueParameter())
 893       constructTemplateValueParameterDIE(Buffer,
 894                                          DITemplateValueParameter(Element));
 895   }
 896 }
 897
 898 /// getOrCreateContextDIE - Get context owner's DIE.
 899 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 900   if (!Context || Context.isFile())
 901     return &getUnitDie();
 902   if (Context.isType())
 903     return getOrCreateTypeDIE(DIType(Context));
 904   if (Context.isNameSpace())
 905     return getOrCreateNameSpace(DINameSpace(Context));
 906   if (Context.isSubprogram())
 907     return getOrCreateSubprogramDIE(DISubprogram(Context));
 908   return getDIE(Context);
 909 }
 910
 911 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
 912   DIScope Context = resolve(Ty.getContext());
 913   DIE *ContextDIE = getOrCreateContextDIE(Context);
 914
 915   if (DIE *TyDIE = getDIE(Ty))
 916     return TyDIE;
 917
 918   // Create new type.
 919   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 920
 921   constructTypeDIE(TyDIE, Ty);
 922
 923   updateAcceleratorTables(Context, Ty, TyDIE);
 924   return &TyDIE;
 925 }
 926
 927 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 928 /// given DIType.
 929 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 930   if (!TyNode)
 931     return nullptr;
 932
 933   DIType Ty(TyNode);
 934   assert(Ty.isType());
 935   assert(Ty == resolve(Ty.getRef()) &&
 936          "type was not uniqued, possible ODR violation.");
 937
 938   // DW_TAG_restrict_type is not supported in DWARF2
 939   if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 940     return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
 941
 942   // Construct the context before querying for the existence of the DIE in case
 943   // such construction creates the DIE.
 944   DIScope Context = resolve(Ty.getContext());
 945   DIE *ContextDIE = getOrCreateContextDIE(Context);
 946   assert(ContextDIE);
 947
 948   if (DIE *TyDIE = getDIE(Ty))
 949     return TyDIE;
 950
 951   // Create new type.
 952   DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 953
 954   updateAcceleratorTables(Context, Ty, TyDIE);
 955
 956   if (Ty.isBasicType())
 957     constructTypeDIE(TyDIE, DIBasicType(Ty));
 958   else if (Ty.isCompositeType()) {
 959     DICompositeType CTy(Ty);
 960     if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
 961       if (MDString *TypeId = CTy.getIdentifier()) {
 962         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 963         // Skip updating the accelerator tables since this is not the full type.
 964         return &TyDIE;
 965       }
 966     constructTypeDIE(TyDIE, CTy);
 967   } else {
 968     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 969     constructTypeDIE(TyDIE, DIDerivedType(Ty));
 970   }
 971
 972   return &TyDIE;
 973 }
 974
 975 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
 976                                         const DIE &TyDIE) {
 977   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 978     bool IsImplementation = 0;
 979     if (Ty.isCompositeType()) {
 980       DICompositeType CT(Ty);
 981       // A runtime language of 0 actually means C/C++ and that any
 982       // non-negative value is some version of Objective-C/C++.
 983       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
 984     }
 985     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 986     DD->addAccelType(Ty.getName(), TyDIE, Flags);
 987
 988     if ((!Context || Context.isCompileUnit() || Context.isFile() ||
 989          Context.isNameSpace()) &&
 990         getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
 991       GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
 992           &TyDIE;
 993   }
 994 }
 995
 996 /// addType - Add a new type attribute to the specified entity.
 997 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
 998   assert(Ty && "Trying to add a type that doesn't exist?");
 999
1000   // Check for pre-existence.
1001   DIEEntry *Entry = getDIEEntry(Ty);
1002   // If it exists then use the existing value.
1003   if (Entry) {
1004     addDIEEntry(Entity, Attribute, Entry);
1005     return;
1006   }
1007
1008   // Construct type.
1009   DIE *Buffer = getOrCreateTypeDIE(Ty);
1010
1011   // Set up proxy.
1012   Entry = createDIEEntry(*Buffer);
1013   insertDIEEntry(Ty, Entry);
1014   addDIEEntry(Entity, Attribute, Entry);
1015 }
1016
1017 /// addGlobalName - Add a new global name to the compile unit.
1018 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1019   if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1020     return;
1021   std::string FullName = getParentContextString(Context) + Name.str();
1022   GlobalNames[FullName] = &Die;
1023 }
1024
1025 /// getParentContextString - Walks the metadata parent chain in a language
1026 /// specific manner (using the compile unit language) and returns
1027 /// it as a string. This is done at the metadata level because DIEs may
1028 /// not currently have been added to the parent context and walking the
1029 /// DIEs looking for names is more expensive than walking the metadata.
1030 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1031   if (!Context)
1032     return "";
1033
1034   // FIXME: Decide whether to implement this for non-C++ languages.
1035   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1036     return "";
1037
1038   std::string CS;
1039   SmallVector<DIScope, 1> Parents;
1040   while (!Context.isCompileUnit()) {
1041     Parents.push_back(Context);
1042     if (Context.getContext())
1043       Context = resolve(Context.getContext());
1044     else
1045       // Structure, etc types will have a NULL context if they're at the top
1046       // level.
1047       break;
1048   }
1049
1050   // Reverse iterate over our list to go from the outermost construct to the
1051   // innermost.
1052   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1053                                                   E = Parents.rend();
1054        I != E; ++I) {
1055     DIScope Ctx = *I;
1056     StringRef Name = Ctx.getName();
1057     if (!Name.empty()) {
1058       CS += Name;
1059       CS += "::";
1060     }
1061   }
1062   return CS;
1063 }
1064
1065 /// constructTypeDIE - Construct basic type die from DIBasicType.
1066 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1067   // Get core information.
1068   StringRef Name = BTy.getName();
1069   // Add name if not anonymous or intermediate type.
1070   if (!Name.empty())
1071     addString(Buffer, dwarf::DW_AT_name, Name);
1072
1073   // An unspecified type only has a name attribute.
1074   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1075     return;
1076
1077   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1078           BTy.getEncoding());
1079
1080   uint64_t Size = BTy.getSizeInBits() >> 3;
1081   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1082 }
1083
1084 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1085 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1086   // Get core information.
1087   StringRef Name = DTy.getName();
1088   uint64_t Size = DTy.getSizeInBits() >> 3;
1089   uint16_t Tag = Buffer.getTag();
1090
1091   // Map to main type, void will not have a type.
1092   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1093   if (FromTy)
1094     addType(Buffer, FromTy);
1095
1096   // Add name if not anonymous or intermediate type.
1097   if (!Name.empty())
1098     addString(Buffer, dwarf::DW_AT_name, Name);
1099
1100   // Add size if non-zero (derived types might be zero-sized.)
1101   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1102     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1103
1104   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1105     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1106                 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1107   // Add source line info if available and TyDesc is not a forward declaration.
1108   if (!DTy.isForwardDecl())
1109     addSourceLine(Buffer, DTy);
1110 }
1111
1112 /// constructSubprogramArguments - Construct function argument DIEs.
1113 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1114   for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1115     DIDescriptor Ty = Args.getElement(i);
1116     if (Ty.isUnspecifiedParameter()) {
1117       assert(i == N-1 && "Unspecified parameter must be the last argument");
1118       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1119     } else {
1120       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1121       addType(Arg, DIType(Ty));
1122       if (DIType(Ty).isArtificial())
1123         addFlag(Arg, dwarf::DW_AT_artificial);
1124     }
1125   }
1126 }
1127
1128 /// constructTypeDIE - Construct type DIE from DICompositeType.
1129 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1130   // Add name if not anonymous or intermediate type.
1131   StringRef Name = CTy.getName();
1132
1133   uint64_t Size = CTy.getSizeInBits() >> 3;
1134   uint16_t Tag = Buffer.getTag();
1135
1136   switch (Tag) {
1137   case dwarf::DW_TAG_array_type:
1138     constructArrayTypeDIE(Buffer, CTy);
1139     break;
1140   case dwarf::DW_TAG_enumeration_type:
1141     constructEnumTypeDIE(Buffer, CTy);
1142     break;
1143   case dwarf::DW_TAG_subroutine_type: {
1144     // Add return type. A void return won't have a type.
1145     DIArray Elements = CTy.getTypeArray();
1146     DIType RTy(Elements.getElement(0));
1147     if (RTy)
1148       addType(Buffer, RTy);
1149
1150     bool isPrototyped = true;
1151     if (Elements.getNumElements() == 2 &&
1152         Elements.getElement(1).isUnspecifiedParameter())
1153       isPrototyped = false;
1154
1155     constructSubprogramArguments(Buffer, Elements);
1156
1157     // Add prototype flag if we're dealing with a C language and the
1158     // function has been prototyped.
1159     uint16_t Language = getLanguage();
1160     if (isPrototyped &&
1161         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1162          Language == dwarf::DW_LANG_ObjC))
1163       addFlag(Buffer, dwarf::DW_AT_prototyped);
1164
1165     if (CTy.isLValueReference())
1166       addFlag(Buffer, dwarf::DW_AT_reference);
1167
1168     if (CTy.isRValueReference())
1169       addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1170   } break;
1171   case dwarf::DW_TAG_structure_type:
1172   case dwarf::DW_TAG_union_type:
1173   case dwarf::DW_TAG_class_type: {
1174     // Add elements to structure type.
1175     DIArray Elements = CTy.getTypeArray();
1176     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1177       DIDescriptor Element = Elements.getElement(i);
1178       if (Element.isSubprogram())
1179         getOrCreateSubprogramDIE(DISubprogram(Element));
1180       else if (Element.isDerivedType()) {
1181         DIDerivedType DDTy(Element);
1182         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1183           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1184           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1185                   dwarf::DW_AT_friend);
1186         } else if (DDTy.isStaticMember()) {
1187           getOrCreateStaticMemberDIE(DDTy);
1188         } else {
1189           constructMemberDIE(Buffer, DDTy);
1190         }
1191       } else if (Element.isObjCProperty()) {
1192         DIObjCProperty Property(Element);
1193         DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1194         StringRef PropertyName = Property.getObjCPropertyName();
1195         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1196         if (Property.getType())
1197           addType(ElemDie, Property.getType());
1198         addSourceLine(ElemDie, Property);
1199         StringRef GetterName = Property.getObjCPropertyGetterName();
1200         if (!GetterName.empty())
1201           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1202         StringRef SetterName = Property.getObjCPropertySetterName();
1203         if (!SetterName.empty())
1204           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1205         unsigned PropertyAttributes = 0;
1206         if (Property.isReadOnlyObjCProperty())
1207           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1208         if (Property.isReadWriteObjCProperty())
1209           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1210         if (Property.isAssignObjCProperty())
1211           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1212         if (Property.isRetainObjCProperty())
1213           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1214         if (Property.isCopyObjCProperty())
1215           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1216         if (Property.isNonAtomicObjCProperty())
1217           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1218         if (PropertyAttributes)
1219           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1220                   PropertyAttributes);
1221
1222         DIEEntry *Entry = getDIEEntry(Element);
1223         if (!Entry) {
1224           Entry = createDIEEntry(ElemDie);
1225           insertDIEEntry(Element, Entry);
1226         }
1227       } else
1228         continue;
1229     }
1230
1231     if (CTy.isAppleBlockExtension())
1232       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1233
1234     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1235     if (ContainingType)
1236       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1237                   *getOrCreateTypeDIE(ContainingType));
1238
1239     if (CTy.isObjcClassComplete())
1240       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1241
1242     // Add template parameters to a class, structure or union types.
1243     // FIXME: The support isn't in the metadata for this yet.
1244     if (Tag == dwarf::DW_TAG_class_type ||
1245         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1246       addTemplateParams(Buffer, CTy.getTemplateParams());
1247
1248     break;
1249   }
1250   default:
1251     break;
1252   }
1253
1254   // Add name if not anonymous or intermediate type.
1255   if (!Name.empty())
1256     addString(Buffer, dwarf::DW_AT_name, Name);
1257
1258   if (Tag == dwarf::DW_TAG_enumeration_type ||
1259       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1260       Tag == dwarf::DW_TAG_union_type) {
1261     // Add size if non-zero (derived types might be zero-sized.)
1262     // TODO: Do we care about size for enum forward declarations?
1263     if (Size)
1264       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1265     else if (!CTy.isForwardDecl())
1266       // Add zero size if it is not a forward declaration.
1267       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1268
1269     // If we're a forward decl, say so.
1270     if (CTy.isForwardDecl())
1271       addFlag(Buffer, dwarf::DW_AT_declaration);
1272
1273     // Add source line info if available.
1274     if (!CTy.isForwardDecl())
1275       addSourceLine(Buffer, CTy);
1276
1277     // No harm in adding the runtime language to the declaration.
1278     unsigned RLang = CTy.getRunTimeLang();
1279     if (RLang)
1280       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1281               RLang);
1282   }
1283 }
1284
1285 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1286 /// DITemplateTypeParameter.
1287 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1288                                                   DITemplateTypeParameter TP) {
1289   DIE &ParamDIE =
1290       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1291   // Add the type if it exists, it could be void and therefore no type.
1292   if (TP.getType())
1293     addType(ParamDIE, resolve(TP.getType()));
1294   if (!TP.getName().empty())
1295     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1296 }
1297
1298 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1299 /// DITemplateValueParameter.
1300 void
1301 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1302                                               DITemplateValueParameter VP) {
1303   DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1304
1305   // Add the type if there is one, template template and template parameter
1306   // packs will not have a type.
1307   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1308     addType(ParamDIE, resolve(VP.getType()));
1309   if (!VP.getName().empty())
1310     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1311   if (Value *Val = VP.getValue()) {
1312     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1313       addConstantValue(ParamDIE, CI,
1314                        isUnsignedDIType(DD, resolve(VP.getType())));
1315     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1316       // For declaration non-type template parameters (such as global values and
1317       // functions)
1318       DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1319       addOpAddress(*Loc, Asm->getSymbol(GV));
1320       // Emit DW_OP_stack_value to use the address as the immediate value of the
1321       // parameter, rather than a pointer to it.
1322       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1323       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1324     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1325       assert(isa<MDString>(Val));
1326       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1327                 cast<MDString>(Val)->getString());
1328     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1329       assert(isa<MDNode>(Val));
1330       DIArray A(cast<MDNode>(Val));
1331       addTemplateParams(ParamDIE, A);
1332     }
1333   }
1334 }
1335
1336 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1337 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1338   // Construct the context before querying for the existence of the DIE in case
1339   // such construction creates the DIE.
1340   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1341
1342   if (DIE *NDie = getDIE(NS))
1343     return NDie;
1344   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1345
1346   if (!NS.getName().empty()) {
1347     addString(NDie, dwarf::DW_AT_name, NS.getName());
1348     DD->addAccelNamespace(NS.getName(), NDie);
1349     addGlobalName(NS.getName(), NDie, NS.getContext());
1350   } else
1351     DD->addAccelNamespace("(anonymous namespace)", NDie);
1352   addSourceLine(NDie, NS);
1353   return &NDie;
1354 }
1355
1356 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1357 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1358   // Construct the context before querying for the existence of the DIE in case
1359   // such construction creates the DIE (as is the case for member function
1360   // declarations).
1361   DIScope Context = resolve(SP.getContext());
1362   DIE *ContextDIE = getOrCreateContextDIE(Context);
1363
1364   // Unique declarations based on the ODR, where applicable.
1365   SP = DISubprogram(DD->resolve(SP.getRef()));
1366   assert(SP.Verify());
1367
1368   if (DIE *SPDie = getDIE(SP))
1369     return SPDie;
1370
1371   DISubprogram SPDecl = SP.getFunctionDeclaration();
1372   if (SPDecl.isSubprogram())
1373     // Add subprogram definitions to the CU die directly.
1374     ContextDIE = &getUnitDie();
1375
1376   // DW_TAG_inlined_subroutine may refer to this DIE.
1377   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1378
1379   DIE *DeclDie = nullptr;
1380   if (SPDecl.isSubprogram())
1381     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1382
1383   // Add function template parameters.
1384   addTemplateParams(SPDie, SP.getTemplateParams());
1385
1386   if (DeclDie)
1387     // Refer function declaration directly.
1388     addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1389
1390   // Add the linkage name if we have one and it isn't in the Decl.
1391   StringRef LinkageName = SP.getLinkageName();
1392   if (!LinkageName.empty()) {
1393     if (SPDecl.isSubprogram() && !SPDecl.getLinkageName().empty())
1394       assert(SPDecl.getLinkageName() == SP.getLinkageName() &&
1395              "decl has a linkage name and it is different");
1396     else
1397       addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1398                 GlobalValue::getRealLinkageName(LinkageName));
1399   }
1400
1401   // If this DIE is going to refer declaration info using AT_specification
1402   // then there is no need to add other attributes.
1403   if (DeclDie)
1404     return &SPDie;
1405
1406   // Constructors and operators for anonymous aggregates do not have names.
1407   if (!SP.getName().empty())
1408     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1409
1410   addSourceLine(SPDie, SP);
1411
1412   // Add the prototype if we have a prototype and we have a C like
1413   // language.
1414   uint16_t Language = getLanguage();
1415   if (SP.isPrototyped() &&
1416       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1417        Language == dwarf::DW_LANG_ObjC))
1418     addFlag(SPDie, dwarf::DW_AT_prototyped);
1419
1420   DICompositeType SPTy = SP.getType();
1421   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1422          "the type of a subprogram should be a subroutine");
1423
1424   DIArray Args = SPTy.getTypeArray();
1425   // Add a return type. If this is a type like a C/C++ void type we don't add a
1426   // return type.
1427   if (Args.getElement(0))
1428     addType(SPDie, DIType(Args.getElement(0)));
1429
1430   unsigned VK = SP.getVirtuality();
1431   if (VK) {
1432     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1433     DIELoc *Block = getDIELoc();
1434     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1435     addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1436     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1437     ContainingTypeMap.insert(
1438         std::make_pair(&SPDie, resolve(SP.getContainingType())));
1439   }
1440
1441   if (!SP.isDefinition()) {
1442     addFlag(SPDie, dwarf::DW_AT_declaration);
1443
1444     // Add arguments. Do not add arguments for subprogram definition. They will
1445     // be handled while processing variables.
1446     constructSubprogramArguments(SPDie, Args);
1447   }
1448
1449   if (SP.isArtificial())
1450     addFlag(SPDie, dwarf::DW_AT_artificial);
1451
1452   if (!SP.isLocalToUnit())
1453     addFlag(SPDie, dwarf::DW_AT_external);
1454
1455   if (SP.isOptimized())
1456     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1457
1458   if (unsigned isa = Asm->getISAEncoding()) {
1459     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1460   }
1461
1462   if (SP.isLValueReference())
1463     addFlag(SPDie, dwarf::DW_AT_reference);
1464
1465   if (SP.isRValueReference())
1466     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1467
1468   if (SP.isProtected())
1469     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1470             dwarf::DW_ACCESS_protected);
1471   else if (SP.isPrivate())
1472     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1473             dwarf::DW_ACCESS_private);
1474   else
1475     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1476             dwarf::DW_ACCESS_public);
1477
1478   if (SP.isExplicit())
1479     addFlag(SPDie, dwarf::DW_AT_explicit);
1480
1481   return &SPDie;
1482 }
1483
1484 // Return const expression if value is a GEP to access merged global
1485 // constant. e.g.
1486 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1487 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1488   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1489   if (!CE || CE->getNumOperands() != 3 ||
1490       CE->getOpcode() != Instruction::GetElementPtr)
1491     return nullptr;
1492
1493   // First operand points to a global struct.
1494   Value *Ptr = CE->getOperand(0);
1495   if (!isa<GlobalValue>(Ptr) ||
1496       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1497     return nullptr;
1498
1499   // Second operand is zero.
1500   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1501   if (!CI || !CI->isZero())
1502     return nullptr;
1503
1504   // Third operand is offset.
1505   if (!isa<ConstantInt>(CE->getOperand(2)))
1506     return nullptr;
1507
1508   return CE;
1509 }
1510
1511 /// createGlobalVariableDIE - create global variable DIE.
1512 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1513   // Check for pre-existence.
1514   if (getDIE(GV))
1515     return;
1516
1517   assert(GV.isGlobalVariable());
1518
1519   DIScope GVContext = GV.getContext();
1520   DIType GTy = DD->resolve(GV.getType());
1521
1522   // If this is a static data member definition, some attributes belong
1523   // to the declaration DIE.
1524   DIE *VariableDIE = nullptr;
1525   bool IsStaticMember = false;
1526   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1527   if (SDMDecl.Verify()) {
1528     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1529     // We need the declaration DIE that is in the static member's class.
1530     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1531     IsStaticMember = true;
1532   }
1533
1534   // If this is not a static data member definition, create the variable
1535   // DIE and add the initial set of attributes to it.
1536   if (!VariableDIE) {
1537     // Construct the context before querying for the existence of the DIE in
1538     // case such construction creates the DIE.
1539     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1540
1541     // Add to map.
1542     VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1543
1544     // Add name and type.
1545     addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1546     addType(*VariableDIE, GTy);
1547
1548     // Add scoping info.
1549     if (!GV.isLocalToUnit())
1550       addFlag(*VariableDIE, dwarf::DW_AT_external);
1551
1552     // Add line number info.
1553     addSourceLine(*VariableDIE, GV);
1554   }
1555
1556   // Add location.
1557   bool addToAccelTable = false;
1558   DIE *VariableSpecDIE = nullptr;
1559   bool isGlobalVariable = GV.getGlobal() != nullptr;
1560   if (isGlobalVariable) {
1561     addToAccelTable = true;
1562     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1563     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1564     if (GV.getGlobal()->isThreadLocal()) {
1565       // FIXME: Make this work with -gsplit-dwarf.
1566       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1567       assert((PointerSize == 4 || PointerSize == 8) &&
1568              "Add support for other sizes if necessary");
1569       // Based on GCC's support for TLS:
1570       if (!DD->useSplitDwarf()) {
1571         // 1) Start with a constNu of the appropriate pointer size
1572         addUInt(*Loc, dwarf::DW_FORM_data1,
1573                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1574         // 2) containing the (relocated) offset of the TLS variable
1575         //    within the module's TLS block.
1576         addExpr(*Loc, dwarf::DW_FORM_udata,
1577                 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1578       } else {
1579         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1580         addUInt(*Loc, dwarf::DW_FORM_udata,
1581                 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
1582       }
1583       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1584       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1585     } else {
1586       DD->addArangeLabel(SymbolCU(this, Sym));
1587       addOpAddress(*Loc, Sym);
1588     }
1589     // Do not create specification DIE if context is either compile unit
1590     // or a subprogram.
1591     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1592         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1593       // Create specification DIE.
1594       VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie);
1595       addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE);
1596       addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc);
1597       // A static member's declaration is already flagged as such.
1598       if (!SDMDecl.Verify())
1599         addFlag(*VariableDIE, dwarf::DW_AT_declaration);
1600     } else {
1601       addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1602     }
1603     // Add the linkage name.
1604     StringRef LinkageName = GV.getLinkageName();
1605     if (!LinkageName.empty())
1606       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1607       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1608       // TAG_variable.
1609       addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE
1610                                                   : *VariableDIE,
1611                 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1612                                            : dwarf::DW_AT_MIPS_linkage_name,
1613                 GlobalValue::getRealLinkageName(LinkageName));
1614   } else if (const ConstantInt *CI =
1615                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1616     // AT_const_value was added when the static member was created. To avoid
1617     // emitting AT_const_value multiple times, we only add AT_const_value when
1618     // it is not a static member.
1619     if (!IsStaticMember)
1620       addConstantValue(*VariableDIE, CI, isUnsignedDIType(DD, GTy));
1621   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1622     addToAccelTable = true;
1623     // GV is a merged global.
1624     DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1625     Value *Ptr = CE->getOperand(0);
1626     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1627     DD->addArangeLabel(SymbolCU(this, Sym));
1628     addOpAddress(*Loc, Sym);
1629     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1630     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1631     addUInt(*Loc, dwarf::DW_FORM_udata,
1632             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1633     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1634     addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1635   }
1636
1637   if (addToAccelTable) {
1638     DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE;
1639     DD->addAccelName(GV.getName(), AddrDIE);
1640
1641     // If the linkage name is different than the name, go ahead and output
1642     // that as well into the name table.
1643     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1644       DD->addAccelName(GV.getLinkageName(), AddrDIE);
1645   }
1646
1647   if (!GV.isLocalToUnit())
1648     addGlobalName(GV.getName(),
1649                   VariableSpecDIE ? *VariableSpecDIE : *VariableDIE,
1650                   GV.getContext());
1651 }
1652
1653 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1654 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1655   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1656   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1657
1658   // The LowerBound value defines the lower bounds which is typically zero for
1659   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1660   // Count == -1 then the array is unbounded and we do not emit
1661   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1662   // Count == 0, then the array has zero elements in which case we do not emit
1663   // an upper bound.
1664   int64_t LowerBound = SR.getLo();
1665   int64_t DefaultLowerBound = getDefaultLowerBound();
1666   int64_t Count = SR.getCount();
1667
1668   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1669     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1670
1671   if (Count != -1 && Count != 0)
1672     // FIXME: An unbounded array should reference the expression that defines
1673     // the array.
1674     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1675             LowerBound + Count - 1);
1676 }
1677
1678 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1679 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1680   if (CTy.isVector())
1681     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1682
1683   // Emit the element type.
1684   addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1685
1686   // Get an anonymous type for index type.
1687   // FIXME: This type should be passed down from the front end
1688   // as different languages may have different sizes for indexes.
1689   DIE *IdxTy = getIndexTyDie();
1690   if (!IdxTy) {
1691     // Construct an integer type to use for indexes.
1692     IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1693     addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1694     addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1695     addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1696             dwarf::DW_ATE_unsigned);
1697     setIndexTyDie(IdxTy);
1698   }
1699
1700   // Add subranges to array type.
1701   DIArray Elements = CTy.getTypeArray();
1702   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1703     DIDescriptor Element = Elements.getElement(i);
1704     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1705       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1706   }
1707 }
1708
1709 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1710 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1711   DIArray Elements = CTy.getTypeArray();
1712
1713   // Add enumerators to enumeration type.
1714   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1715     DIEnumerator Enum(Elements.getElement(i));
1716     if (Enum.isEnumerator()) {
1717       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1718       StringRef Name = Enum.getName();
1719       addString(Enumerator, dwarf::DW_AT_name, Name);
1720       int64_t Value = Enum.getEnumValue();
1721       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1722               Value);
1723     }
1724   }
1725   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1726   if (DTy) {
1727     addType(Buffer, DTy);
1728     addFlag(Buffer, dwarf::DW_AT_enum_class);
1729   }
1730 }
1731
1732 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1733 /// vtables.
1734 void DwarfUnit::constructContainingTypeDIEs() {
1735   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1736                                                  CE = ContainingTypeMap.end();
1737        CI != CE; ++CI) {
1738     DIE &SPDie = *CI->first;
1739     DIDescriptor D(CI->second);
1740     if (!D)
1741       continue;
1742     DIE *NDie = getDIE(D);
1743     if (!NDie)
1744       continue;
1745     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1746   }
1747 }
1748
1749 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1750 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
1751                                                      AbstractOrInlined AbsIn) {
1752   auto D = constructVariableDIEImpl(DV, AbsIn);
1753   DV.setDIE(*D);
1754   return D;
1755 }
1756
1757 std::unique_ptr<DIE>
1758 DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
1759                                     AbstractOrInlined AbsIn) {
1760   StringRef Name = DV.getName();
1761
1762   // Define variable debug information entry.
1763   auto VariableDie = make_unique<DIE>(DV.getTag());
1764   DbgVariable *AbsVar = DV.getAbstractVariable();
1765   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : nullptr;
1766   if (AbsDIE)
1767     addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, *AbsDIE);
1768   else {
1769     if (!Name.empty())
1770       addString(*VariableDie, dwarf::DW_AT_name, Name);
1771     addSourceLine(*VariableDie, DV.getVariable());
1772     addType(*VariableDie, DV.getType());
1773   }
1774
1775   if (AbsIn != AOI_Inlined && DV.isArtificial())
1776     addFlag(*VariableDie, dwarf::DW_AT_artificial);
1777
1778   if (AbsIn == AOI_Abstract)
1779     return VariableDie;
1780
1781   // Add variable address.
1782
1783   unsigned Offset = DV.getDotDebugLocOffset();
1784   if (Offset != ~0U) {
1785     addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
1786     return VariableDie;
1787   }
1788
1789   // Check if variable is described by a DBG_VALUE instruction.
1790   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1791     assert(DVInsn->getNumOperands() == 3);
1792     if (DVInsn->getOperand(0).isReg()) {
1793       const MachineOperand RegOp = DVInsn->getOperand(0);
1794       // If the second operand is an immediate, this is an indirect value.
1795       if (DVInsn->getOperand(1).isImm()) {
1796         MachineLocation Location(RegOp.getReg(),
1797                                  DVInsn->getOperand(1).getImm());
1798         addVariableAddress(DV, *VariableDie, Location);
1799       } else if (RegOp.getReg())
1800         addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
1801     } else if (DVInsn->getOperand(0).isImm())
1802       addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
1803     else if (DVInsn->getOperand(0).isFPImm())
1804       addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
1805     else if (DVInsn->getOperand(0).isCImm())
1806       addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
1807                        isUnsignedDIType(DD, DV.getType()));
1808
1809     return VariableDie;
1810   }
1811
1812   // .. else use frame index.
1813   int FI = DV.getFrameIndex();
1814   if (FI != ~0) {
1815     unsigned FrameReg = 0;
1816     const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1817     int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1818     MachineLocation Location(FrameReg, Offset);
1819     addVariableAddress(DV, *VariableDie, Location);
1820   }
1821
1822   return VariableDie;
1823 }
1824
1825 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1826 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1827   DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1828   StringRef Name = DT.getName();
1829   if (!Name.empty())
1830     addString(MemberDie, dwarf::DW_AT_name, Name);
1831
1832   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1833
1834   addSourceLine(MemberDie, DT);
1835
1836   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1837
1838     // For C++, virtual base classes are not at fixed offset. Use following
1839     // expression to extract appropriate offset from vtable.
1840     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1841
1842     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1843     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1844     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1845     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1846     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1847     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1848     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1849     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1850
1851     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1852   } else {
1853     uint64_t Size = DT.getSizeInBits();
1854     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1855     uint64_t OffsetInBytes;
1856
1857     if (Size != FieldSize) {
1858       // Handle bitfield, assume bytes are 8 bits.
1859       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1860       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1861
1862       uint64_t Offset = DT.getOffsetInBits();
1863       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1864       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1865       uint64_t FieldOffset = (HiMark - FieldSize);
1866       Offset -= FieldOffset;
1867
1868       // Maybe we need to work from the other end.
1869       if (Asm->getDataLayout().isLittleEndian())
1870         Offset = FieldSize - (Offset + Size);
1871       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1872
1873       // Here DW_AT_data_member_location points to the anonymous
1874       // field that includes this bit field.
1875       OffsetInBytes = FieldOffset >> 3;
1876     } else
1877       // This is not a bitfield.
1878       OffsetInBytes = DT.getOffsetInBits() >> 3;
1879
1880     if (DD->getDwarfVersion() <= 2) {
1881       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1882       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1883       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1884       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1885     } else
1886       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1887               OffsetInBytes);
1888   }
1889
1890   if (DT.isProtected())
1891     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1892             dwarf::DW_ACCESS_protected);
1893   else if (DT.isPrivate())
1894     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1895             dwarf::DW_ACCESS_private);
1896   // Otherwise C++ member and base classes are considered public.
1897   else
1898     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1899             dwarf::DW_ACCESS_public);
1900   if (DT.isVirtual())
1901     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1902             dwarf::DW_VIRTUALITY_virtual);
1903
1904   // Objective-C properties.
1905   if (MDNode *PNode = DT.getObjCProperty())
1906     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1907       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1908                          PropertyDie);
1909
1910   if (DT.isArtificial())
1911     addFlag(MemberDie, dwarf::DW_AT_artificial);
1912 }
1913
1914 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1915 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1916   if (!DT.Verify())
1917     return nullptr;
1918
1919   // Construct the context before querying for the existence of the DIE in case
1920   // such construction creates the DIE.
1921   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1922   assert(dwarf::isType(ContextDIE->getTag()) &&
1923          "Static member should belong to a type.");
1924
1925   if (DIE *StaticMemberDIE = getDIE(DT))
1926     return StaticMemberDIE;
1927
1928   DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1929
1930   DIType Ty = resolve(DT.getTypeDerivedFrom());
1931
1932   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1933   addType(StaticMemberDIE, Ty);
1934   addSourceLine(StaticMemberDIE, DT);
1935   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1936   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1937
1938   // FIXME: We could omit private if the parent is a class_type, and
1939   // public if the parent is something else.
1940   if (DT.isProtected())
1941     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1942             dwarf::DW_ACCESS_protected);
1943   else if (DT.isPrivate())
1944     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1945             dwarf::DW_ACCESS_private);
1946   else
1947     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1948             dwarf::DW_ACCESS_public);
1949
1950   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1951     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1952   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1953     addConstantFPValue(StaticMemberDIE, CFP);
1954
1955   return &StaticMemberDIE;
1956 }
1957
1958 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1959   Asm->OutStreamer.AddComment("DWARF version number");
1960   Asm->EmitInt16(DD->getDwarfVersion());
1961   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1962   // We share one abbreviations table across all units so it's always at the
1963   // start of the section. Use a relocatable offset where needed to ensure
1964   // linking doesn't invalidate that offset.
1965   if (ASectionSym)
1966     Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1967   else
1968     // Use a constant value when no symbol is provided.
1969     Asm->EmitInt32(0);
1970   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1971   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1972 }
1973
1974 void DwarfUnit::addRange(RangeSpan Range) {
1975   // Only add a range for this unit if we're emitting full debug.
1976   if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
1977     // If we have no current ranges just add the range and return, otherwise,
1978     // check the current section and CU against the previous section and CU we
1979     // emitted into and the subprogram was contained within. If these are the
1980     // same then extend our current range, otherwise add this as a new range.
1981     if (CURanges.size() == 0 ||
1982         this != DD->getPrevCU() ||
1983         Asm->getCurrentSection() != DD->getPrevSection()) {
1984       CURanges.push_back(Range);
1985       return;
1986     }
1987
1988     assert(&(CURanges.back().getEnd()->getSection()) ==
1989                &(Range.getEnd()->getSection()) &&
1990            "We can only append to a range in the same section!");
1991     CURanges.back().setEnd(Range.getEnd());
1992   }
1993 }
1994
1995 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
1996   // Define start line table label for each Compile Unit.
1997   MCSymbol *LineTableStartSym =
1998       Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
1999
2000   stmtListIndex = UnitDie.getValues().size();
2001
2002   // DW_AT_stmt_list is a offset of line number information for this
2003   // compile unit in debug_line section. For split dwarf this is
2004   // left in the skeleton CU and so not included.
2005   // The line table entries are not always emitted in assembly, so it
2006   // is not okay to use line_table_start here.
2007   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2008     addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym);
2009   else
2010     addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
2011                     DwarfLineSectionSym);
2012 }
2013
2014 void DwarfCompileUnit::applyStmtList(DIE &D) {
2015   D.addValue(dwarf::DW_AT_stmt_list,
2016              UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
2017              UnitDie.getValues()[stmtListIndex]);
2018 }
2019
2020 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2021   DwarfUnit::emitHeader(ASectionSym);
2022   Asm->OutStreamer.AddComment("Type Signature");
2023   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2024   Asm->OutStreamer.AddComment("Type DIE Offset");
2025   // In a skeleton type unit there is no type DIE so emit a zero offset.
2026   Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2027                                 sizeof(Ty->getOffset()));
2028 }
2029
2030 void DwarfTypeUnit::initSection(const MCSection *Section) {
2031   assert(!this->Section);
2032   this->Section = Section;
2033   // Since each type unit is contained in its own COMDAT section, the begin
2034   // label and the section label are the same. Using the begin label emission in
2035   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2036   // the only other alternative of lazily constructing start-of-section labels
2037   // and storing a mapping in DwarfDebug (or AsmPrinter).
2038   this->SectionSym = this->LabelBegin =
2039       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2040   this->LabelEnd =
2041       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2042 }