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