lib/CodeGen/AsmPrinter/DwarfUnit.cpp

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