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