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