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