lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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