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