lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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