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