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