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   constructTypeDIE(*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     constructTypeDIE(*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   // Add name if not anonymous or intermediate type.
1173   StringRef Name = CTy.getName();
1174
1175   uint64_t Size = CTy.getSizeInBits() >> 3;
1176   uint16_t Tag = Buffer.getTag();
1177
1178   switch (Tag) {
1179   case dwarf::DW_TAG_array_type:
1180     constructArrayTypeDIE(Buffer, CTy);
1181     break;
1182   case dwarf::DW_TAG_enumeration_type:
1183     constructEnumTypeDIE(Buffer, CTy);
1184     break;
1185   case dwarf::DW_TAG_subroutine_type: {
1186     // Add return type. A void return won't have a type.
1187     DIArray Elements = CTy.getTypeArray();
1188     DIType RTy(Elements.getElement(0));
1189     if (RTy)
1190       addType(&Buffer, RTy);
1191
1192     bool isPrototyped = true;
1193     // Add arguments.
1194     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1195       DIDescriptor Ty = Elements.getElement(i);
1196       if (Ty.isUnspecifiedParameter()) {
1197         createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1198         isPrototyped = false;
1199       } else {
1200         DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1201         addType(Arg, DIType(Ty));
1202         if (DIType(Ty).isArtificial())
1203           addFlag(Arg, dwarf::DW_AT_artificial);
1204       }
1205     }
1206     // Add prototype flag if we're dealing with a C language and the
1207     // function has been prototyped.
1208     uint16_t Language = getLanguage();
1209     if (isPrototyped &&
1210         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1211          Language == dwarf::DW_LANG_ObjC))
1212       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1213   } break;
1214   case dwarf::DW_TAG_structure_type:
1215   case dwarf::DW_TAG_union_type:
1216   case dwarf::DW_TAG_class_type: {
1217     // Add elements to structure type.
1218     DIArray Elements = CTy.getTypeArray();
1219     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1220       DIDescriptor Element = Elements.getElement(i);
1221       DIE *ElemDie = NULL;
1222       if (Element.isSubprogram()) {
1223         DISubprogram SP(Element);
1224         ElemDie = getOrCreateSubprogramDIE(SP);
1225         if (SP.isProtected())
1226           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1227                   dwarf::DW_ACCESS_protected);
1228         else if (SP.isPrivate())
1229           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1230                   dwarf::DW_ACCESS_private);
1231         else
1232           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1233                   dwarf::DW_ACCESS_public);
1234         if (SP.isExplicit())
1235           addFlag(ElemDie, dwarf::DW_AT_explicit);
1236       } else if (Element.isDerivedType()) {
1237         DIDerivedType DDTy(Element);
1238         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1239           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1240           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1241                   dwarf::DW_AT_friend);
1242         } else if (DDTy.isStaticMember()) {
1243           getOrCreateStaticMemberDIE(DDTy);
1244         } else {
1245           constructMemberDIE(Buffer, DDTy);
1246         }
1247       } else if (Element.isObjCProperty()) {
1248         DIObjCProperty Property(Element);
1249         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1250         StringRef PropertyName = Property.getObjCPropertyName();
1251         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1252         addType(ElemDie, Property.getType());
1253         addSourceLine(ElemDie, Property);
1254         StringRef GetterName = Property.getObjCPropertyGetterName();
1255         if (!GetterName.empty())
1256           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1257         StringRef SetterName = Property.getObjCPropertySetterName();
1258         if (!SetterName.empty())
1259           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1260         unsigned PropertyAttributes = 0;
1261         if (Property.isReadOnlyObjCProperty())
1262           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1263         if (Property.isReadWriteObjCProperty())
1264           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1265         if (Property.isAssignObjCProperty())
1266           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1267         if (Property.isRetainObjCProperty())
1268           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1269         if (Property.isCopyObjCProperty())
1270           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1271         if (Property.isNonAtomicObjCProperty())
1272           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1273         if (PropertyAttributes)
1274           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1275                   PropertyAttributes);
1276
1277         DIEEntry *Entry = getDIEEntry(Element);
1278         if (!Entry) {
1279           Entry = createDIEEntry(ElemDie);
1280           insertDIEEntry(Element, Entry);
1281         }
1282       } else
1283         continue;
1284     }
1285
1286     if (CTy.isAppleBlockExtension())
1287       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1288
1289     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1290     if (ContainingType)
1291       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1292                   getOrCreateTypeDIE(ContainingType));
1293
1294     if (CTy.isObjcClassComplete())
1295       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1296
1297     // Add template parameters to a class, structure or union types.
1298     // FIXME: The support isn't in the metadata for this yet.
1299     if (Tag == dwarf::DW_TAG_class_type ||
1300         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1301       addTemplateParams(Buffer, CTy.getTemplateParams());
1302
1303     break;
1304   }
1305   default:
1306     break;
1307   }
1308
1309   // Add name if not anonymous or intermediate type.
1310   if (!Name.empty())
1311     addString(&Buffer, dwarf::DW_AT_name, Name);
1312
1313   if (Tag == dwarf::DW_TAG_enumeration_type ||
1314       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1315       Tag == dwarf::DW_TAG_union_type) {
1316     // Add size if non-zero (derived types might be zero-sized.)
1317     // TODO: Do we care about size for enum forward declarations?
1318     if (Size)
1319       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1320     else if (!CTy.isForwardDecl())
1321       // Add zero size if it is not a forward declaration.
1322       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1323
1324     // If we're a forward decl, say so.
1325     if (CTy.isForwardDecl())
1326       addFlag(&Buffer, dwarf::DW_AT_declaration);
1327
1328     // Add source line info if available.
1329     if (!CTy.isForwardDecl())
1330       addSourceLine(&Buffer, CTy);
1331
1332     // No harm in adding the runtime language to the declaration.
1333     unsigned RLang = CTy.getRunTimeLang();
1334     if (RLang)
1335       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1336               RLang);
1337   }
1338 }
1339
1340 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1341 /// DITemplateTypeParameter.
1342 void
1343 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1344                                                DITemplateTypeParameter TP) {
1345   DIE *ParamDIE =
1346       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1347   // Add the type if it exists, it could be void and therefore no type.
1348   if (TP.getType())
1349     addType(ParamDIE, resolve(TP.getType()));
1350   if (!TP.getName().empty())
1351     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1352 }
1353
1354 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1355 /// DITemplateValueParameter.
1356 void
1357 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1358                                                 DITemplateValueParameter VP) {
1359   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1360
1361   // Add the type if there is one, template template and template parameter
1362   // packs will not have a type.
1363   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1364     addType(ParamDIE, resolve(VP.getType()));
1365   if (!VP.getName().empty())
1366     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1367   if (Value *Val = VP.getValue()) {
1368     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1369       addConstantValue(ParamDIE, CI,
1370                        isUnsignedDIType(DD, resolve(VP.getType())));
1371     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1372       // For declaration non-type template parameters (such as global values and
1373       // functions)
1374       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1375       addOpAddress(Block, Asm->getSymbol(GV));
1376       // Emit DW_OP_stack_value to use the address as the immediate value of the
1377       // parameter, rather than a pointer to it.
1378       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1379       addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1380     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1381       assert(isa<MDString>(Val));
1382       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1383                 cast<MDString>(Val)->getString());
1384     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1385       assert(isa<MDNode>(Val));
1386       DIArray A(cast<MDNode>(Val));
1387       addTemplateParams(*ParamDIE, A);
1388     }
1389   }
1390 }
1391
1392 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1393 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1394   // Construct the context before querying for the existence of the DIE in case
1395   // such construction creates the DIE.
1396   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1397
1398   DIE *NDie = getDIE(NS);
1399   if (NDie)
1400     return NDie;
1401   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1402
1403   if (!NS.getName().empty()) {
1404     addString(NDie, dwarf::DW_AT_name, NS.getName());
1405     addAccelNamespace(NS.getName(), NDie);
1406     addGlobalName(NS.getName(), NDie, NS.getContext());
1407   } else
1408     addAccelNamespace("(anonymous namespace)", NDie);
1409   addSourceLine(NDie, NS);
1410   return NDie;
1411 }
1412
1413 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1414 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1415   // Construct the context before querying for the existence of the DIE in case
1416   // such construction creates the DIE (as is the case for member function
1417   // declarations).
1418   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1419
1420   DIE *SPDie = getDIE(SP);
1421   if (SPDie)
1422     return SPDie;
1423
1424   DISubprogram SPDecl = SP.getFunctionDeclaration();
1425   if (SPDecl.isSubprogram())
1426     // Add subprogram definitions to the CU die directly.
1427     ContextDIE = CUDie.get();
1428
1429   // DW_TAG_inlined_subroutine may refer to this DIE.
1430   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1431
1432   DIE *DeclDie = NULL;
1433   if (SPDecl.isSubprogram())
1434     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1435
1436   // Add function template parameters.
1437   addTemplateParams(*SPDie, SP.getTemplateParams());
1438
1439   // If this DIE is going to refer declaration info using AT_specification
1440   // then there is no need to add other attributes.
1441   if (DeclDie) {
1442     // Refer function declaration directly.
1443     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1444
1445     return SPDie;
1446   }
1447
1448   // Add the linkage name if we have one.
1449   StringRef LinkageName = SP.getLinkageName();
1450   if (!LinkageName.empty())
1451     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1452               GlobalValue::getRealLinkageName(LinkageName));
1453
1454   // Constructors and operators for anonymous aggregates do not have names.
1455   if (!SP.getName().empty())
1456     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1457
1458   addSourceLine(SPDie, SP);
1459
1460   // Add the prototype if we have a prototype and we have a C like
1461   // language.
1462   uint16_t Language = getLanguage();
1463   if (SP.isPrototyped() &&
1464       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1465        Language == dwarf::DW_LANG_ObjC))
1466     addFlag(SPDie, dwarf::DW_AT_prototyped);
1467
1468   DICompositeType SPTy = SP.getType();
1469   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1470          "the type of a subprogram should be a subroutine");
1471
1472   DIArray Args = SPTy.getTypeArray();
1473   // Add a return type. If this is a type like a C/C++ void type we don't add a
1474   // return type.
1475   if (Args.getElement(0))
1476     addType(SPDie, DIType(Args.getElement(0)));
1477
1478   unsigned VK = SP.getVirtuality();
1479   if (VK) {
1480     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1481     DIEBlock *Block = getDIEBlock();
1482     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1483     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1484     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1485     ContainingTypeMap.insert(
1486         std::make_pair(SPDie, resolve(SP.getContainingType())));
1487   }
1488
1489   if (!SP.isDefinition()) {
1490     addFlag(SPDie, dwarf::DW_AT_declaration);
1491
1492     // Add arguments. Do not add arguments for subprogram definition. They will
1493     // be handled while processing variables.
1494     for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1495       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1496       DIType ATy(Args.getElement(i));
1497       addType(Arg, ATy);
1498       if (ATy.isArtificial())
1499         addFlag(Arg, dwarf::DW_AT_artificial);
1500     }
1501   }
1502
1503   if (SP.isArtificial())
1504     addFlag(SPDie, dwarf::DW_AT_artificial);
1505
1506   if (!SP.isLocalToUnit())
1507     addFlag(SPDie, dwarf::DW_AT_external);
1508
1509   if (SP.isOptimized())
1510     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1511
1512   if (unsigned isa = Asm->getISAEncoding()) {
1513     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1514   }
1515
1516   return SPDie;
1517 }
1518
1519 // Return const expression if value is a GEP to access merged global
1520 // constant. e.g.
1521 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1522 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1523   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1524   if (!CE || CE->getNumOperands() != 3 ||
1525       CE->getOpcode() != Instruction::GetElementPtr)
1526     return NULL;
1527
1528   // First operand points to a global struct.
1529   Value *Ptr = CE->getOperand(0);
1530   if (!isa<GlobalValue>(Ptr) ||
1531       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1532     return NULL;
1533
1534   // Second operand is zero.
1535   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1536   if (!CI || !CI->isZero())
1537     return NULL;
1538
1539   // Third operand is offset.
1540   if (!isa<ConstantInt>(CE->getOperand(2)))
1541     return NULL;
1542
1543   return CE;
1544 }
1545
1546 /// createGlobalVariableDIE - create global variable DIE.
1547 void CompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1548   // Check for pre-existence.
1549   if (getDIE(GV))
1550     return;
1551
1552   if (!GV.isGlobalVariable())
1553     return;
1554
1555   DIScope GVContext = GV.getContext();
1556   DIType GTy = GV.getType();
1557
1558   // If this is a static data member definition, some attributes belong
1559   // to the declaration DIE.
1560   DIE *VariableDIE = NULL;
1561   bool IsStaticMember = false;
1562   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1563   if (SDMDecl.Verify()) {
1564     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1565     // We need the declaration DIE that is in the static member's class.
1566     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1567     IsStaticMember = true;
1568   }
1569
1570   // If this is not a static data member definition, create the variable
1571   // DIE and add the initial set of attributes to it.
1572   if (!VariableDIE) {
1573     // Construct the context before querying for the existence of the DIE in
1574     // case such construction creates the DIE.
1575     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1576
1577     // Add to map.
1578     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1579
1580     // Add name and type.
1581     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1582     addType(VariableDIE, GTy);
1583
1584     // Add scoping info.
1585     if (!GV.isLocalToUnit())
1586       addFlag(VariableDIE, dwarf::DW_AT_external);
1587
1588     // Add line number info.
1589     addSourceLine(VariableDIE, GV);
1590   }
1591
1592   // Add location.
1593   bool addToAccelTable = false;
1594   DIE *VariableSpecDIE = NULL;
1595   bool isGlobalVariable = GV.getGlobal() != NULL;
1596   if (isGlobalVariable) {
1597     addToAccelTable = true;
1598     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1599     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1600     if (GV.getGlobal()->isThreadLocal()) {
1601       // FIXME: Make this work with -gsplit-dwarf.
1602       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1603       assert((PointerSize == 4 || PointerSize == 8) &&
1604              "Add support for other sizes if necessary");
1605       const MCExpr *Expr =
1606           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1607       // Based on GCC's support for TLS:
1608       if (!DD->useSplitDwarf()) {
1609         // 1) Start with a constNu of the appropriate pointer size
1610         addUInt(Block, dwarf::DW_FORM_data1,
1611                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1612         // 2) containing the (relocated) offset of the TLS variable
1613         //    within the module's TLS block.
1614         addExpr(Block, dwarf::DW_FORM_udata, Expr);
1615       } else {
1616         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1617         addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1618       }
1619       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1620       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1621     } else
1622       addOpAddress(Block, Sym);
1623     // Do not create specification DIE if context is either compile unit
1624     // or a subprogram.
1625     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1626         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1627       // Create specification DIE.
1628       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie);
1629       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1630       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1631       // A static member's declaration is already flagged as such.
1632       if (!SDMDecl.Verify())
1633         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1634     } else {
1635       addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1636     }
1637     // Add the linkage name.
1638     StringRef LinkageName = GV.getLinkageName();
1639     if (!LinkageName.empty())
1640       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1641       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1642       // TAG_variable.
1643       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1644                                                   : VariableDIE,
1645                 dwarf::DW_AT_MIPS_linkage_name,
1646                 GlobalValue::getRealLinkageName(LinkageName));
1647   } else if (const ConstantInt *CI =
1648                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1649     // AT_const_value was added when the static member was created. To avoid
1650     // emitting AT_const_value multiple times, we only add AT_const_value when
1651     // it is not a static member.
1652     if (!IsStaticMember)
1653       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1654   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1655     addToAccelTable = true;
1656     // GV is a merged global.
1657     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1658     Value *Ptr = CE->getOperand(0);
1659     addOpAddress(Block, Asm->getSymbol(cast<GlobalValue>(Ptr)));
1660     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1661     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1662     addUInt(Block, dwarf::DW_FORM_udata,
1663             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1664     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1665     addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1666   }
1667
1668   if (addToAccelTable) {
1669     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1670     addAccelName(GV.getName(), AddrDIE);
1671
1672     // If the linkage name is different than the name, go ahead and output
1673     // that as well into the name table.
1674     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1675       addAccelName(GV.getLinkageName(), AddrDIE);
1676   }
1677
1678   if (!GV.isLocalToUnit())
1679     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1680                   GV.getContext());
1681 }
1682
1683 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1684 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1685                                        DIE *IndexTy) {
1686   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1687   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1688
1689   // The LowerBound value defines the lower bounds which is typically zero for
1690   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1691   // Count == -1 then the array is unbounded and we do not emit
1692   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1693   // Count == 0, then the array has zero elements in which case we do not emit
1694   // an upper bound.
1695   int64_t LowerBound = SR.getLo();
1696   int64_t DefaultLowerBound = getDefaultLowerBound();
1697   int64_t Count = SR.getCount();
1698
1699   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1700     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1701
1702   if (Count != -1 && Count != 0)
1703     // FIXME: An unbounded array should reference the expression that defines
1704     // the array.
1705     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1706             LowerBound + Count - 1);
1707 }
1708
1709 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1710 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1711   if (CTy.isVector())
1712     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1713
1714   // Emit the element type.
1715   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1716
1717   // Get an anonymous type for index type.
1718   // FIXME: This type should be passed down from the front end
1719   // as different languages may have different sizes for indexes.
1720   DIE *IdxTy = getIndexTyDie();
1721   if (!IdxTy) {
1722     // Construct an anonymous type for index type.
1723     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
1724     addString(IdxTy, dwarf::DW_AT_name, "int");
1725     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1726     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1727             dwarf::DW_ATE_signed);
1728     setIndexTyDie(IdxTy);
1729   }
1730
1731   // Add subranges to array type.
1732   DIArray Elements = CTy.getTypeArray();
1733   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1734     DIDescriptor Element = Elements.getElement(i);
1735     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1736       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1737   }
1738 }
1739
1740 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1741 void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1742   DIArray Elements = CTy.getTypeArray();
1743
1744   // Add enumerators to enumeration type.
1745   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1746     DIEnumerator Enum(Elements.getElement(i));
1747     if (Enum.isEnumerator()) {
1748       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1749       StringRef Name = Enum.getName();
1750       addString(Enumerator, dwarf::DW_AT_name, Name);
1751       int64_t Value = Enum.getEnumValue();
1752       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1753               Value);
1754     }
1755   }
1756   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1757   if (DTy) {
1758     addType(&Buffer, DTy);
1759     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1760   }
1761 }
1762
1763 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1764 /// vtables.
1765 void CompileUnit::constructContainingTypeDIEs() {
1766   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1767                                                  CE = ContainingTypeMap.end();
1768        CI != CE; ++CI) {
1769     DIE *SPDie = CI->first;
1770     DIDescriptor D(CI->second);
1771     if (!D)
1772       continue;
1773     DIE *NDie = getDIE(D);
1774     if (!NDie)
1775       continue;
1776     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1777   }
1778 }
1779
1780 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1781 DIE *CompileUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1782   StringRef Name = DV.getName();
1783
1784   // Define variable debug information entry.
1785   DIE *VariableDie = new DIE(DV.getTag());
1786   DbgVariable *AbsVar = DV.getAbstractVariable();
1787   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1788   if (AbsDIE)
1789     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1790   else {
1791     if (!Name.empty())
1792       addString(VariableDie, dwarf::DW_AT_name, Name);
1793     addSourceLine(VariableDie, DV.getVariable());
1794     addType(VariableDie, DV.getType());
1795   }
1796
1797   if (DV.isArtificial())
1798     addFlag(VariableDie, dwarf::DW_AT_artificial);
1799
1800   if (isScopeAbstract) {
1801     DV.setDIE(VariableDie);
1802     return VariableDie;
1803   }
1804
1805   // Add variable address.
1806
1807   unsigned Offset = DV.getDotDebugLocOffset();
1808   if (Offset != ~0U) {
1809     addSectionLabel(VariableDie, dwarf::DW_AT_location,
1810                     Asm->GetTempSymbol("debug_loc", Offset));
1811     DV.setDIE(VariableDie);
1812     return VariableDie;
1813   }
1814
1815   // Check if variable is described by a DBG_VALUE instruction.
1816   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1817     assert(DVInsn->getNumOperands() == 3);
1818     if (DVInsn->getOperand(0).isReg()) {
1819       const MachineOperand RegOp = DVInsn->getOperand(0);
1820       // If the second operand is an immediate, this is an indirect value.
1821       if (DVInsn->getOperand(1).isImm()) {
1822         MachineLocation Location(RegOp.getReg(),
1823                                  DVInsn->getOperand(1).getImm());
1824         addVariableAddress(DV, VariableDie, Location);
1825       } else if (RegOp.getReg())
1826         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1827     } else if (DVInsn->getOperand(0).isImm())
1828       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1829     else if (DVInsn->getOperand(0).isFPImm())
1830       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1831     else if (DVInsn->getOperand(0).isCImm())
1832       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1833                        isUnsignedDIType(DD, DV.getType()));
1834
1835     DV.setDIE(VariableDie);
1836     return VariableDie;
1837   } else {
1838     // .. else use frame index.
1839     int FI = DV.getFrameIndex();
1840     if (FI != ~0) {
1841       unsigned FrameReg = 0;
1842       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1843       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1844       MachineLocation Location(FrameReg, Offset);
1845       addVariableAddress(DV, VariableDie, Location);
1846     }
1847   }
1848
1849   DV.setDIE(VariableDie);
1850   return VariableDie;
1851 }
1852
1853 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1854 void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1855   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1856   StringRef Name = DT.getName();
1857   if (!Name.empty())
1858     addString(MemberDie, dwarf::DW_AT_name, Name);
1859
1860   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1861
1862   addSourceLine(MemberDie, DT);
1863
1864   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1865   addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1866
1867   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1868
1869     // For C++, virtual base classes are not at fixed offset. Use following
1870     // expression to extract appropriate offset from vtable.
1871     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1872
1873     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1874     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1875     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1876     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1877     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1878     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1879     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1880     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1881
1882     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1883   } else {
1884     uint64_t Size = DT.getSizeInBits();
1885     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1886     uint64_t OffsetInBytes;
1887
1888     if (Size != FieldSize) {
1889       // Handle bitfield.
1890       addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1891               getBaseTypeSize(DD, DT) >> 3);
1892       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1893
1894       uint64_t Offset = DT.getOffsetInBits();
1895       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1896       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1897       uint64_t FieldOffset = (HiMark - FieldSize);
1898       Offset -= FieldOffset;
1899
1900       // Maybe we need to work from the other end.
1901       if (Asm->getDataLayout().isLittleEndian())
1902         Offset = FieldSize - (Offset + Size);
1903       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1904
1905       // Here WD_AT_data_member_location points to the anonymous
1906       // field that includes this bit field.
1907       OffsetInBytes = FieldOffset >> 3;
1908     } else
1909       // This is not a bitfield.
1910       OffsetInBytes = DT.getOffsetInBits() >> 3;
1911     addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1912   }
1913
1914   if (DT.isProtected())
1915     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1916             dwarf::DW_ACCESS_protected);
1917   else if (DT.isPrivate())
1918     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1919             dwarf::DW_ACCESS_private);
1920   // Otherwise C++ member and base classes are considered public.
1921   else
1922     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1923             dwarf::DW_ACCESS_public);
1924   if (DT.isVirtual())
1925     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1926             dwarf::DW_VIRTUALITY_virtual);
1927
1928   // Objective-C properties.
1929   if (MDNode *PNode = DT.getObjCProperty())
1930     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1931       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1932                           PropertyDie);
1933
1934   if (DT.isArtificial())
1935     addFlag(MemberDie, dwarf::DW_AT_artificial);
1936 }
1937
1938 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1939 DIE *CompileUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1940   if (!DT.Verify())
1941     return NULL;
1942
1943   // Construct the context before querying for the existence of the DIE in case
1944   // such construction creates the DIE.
1945   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1946   assert(dwarf::isType(ContextDIE->getTag()) &&
1947          "Static member should belong to a type.");
1948
1949   DIE *StaticMemberDIE = getDIE(DT);
1950   if (StaticMemberDIE)
1951     return StaticMemberDIE;
1952
1953   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1954
1955   DIType Ty = resolve(DT.getTypeDerivedFrom());
1956
1957   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1958   addType(StaticMemberDIE, Ty);
1959   addSourceLine(StaticMemberDIE, DT);
1960   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1961   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1962
1963   // FIXME: We could omit private if the parent is a class_type, and
1964   // public if the parent is something else.
1965   if (DT.isProtected())
1966     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1967             dwarf::DW_ACCESS_protected);
1968   else if (DT.isPrivate())
1969     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1970             dwarf::DW_ACCESS_private);
1971   else
1972     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1973             dwarf::DW_ACCESS_public);
1974
1975   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1976     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1977   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1978     addConstantFPValue(StaticMemberDIE, CFP);
1979
1980   return StaticMemberDIE;
1981 }
1982
1983 void CompileUnit::emitHeader(const MCSection *ASection,
1984                              const MCSymbol *ASectionSym) {
1985   Asm->OutStreamer.AddComment("DWARF version number");
1986   Asm->EmitInt16(DD->getDwarfVersion());
1987   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1988   Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1989                          ASectionSym);
1990   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1991   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1992 }