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