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