lib/CodeGen/AsmPrinter/DwarfUnit.cpp

   1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for constructing a dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15
  16 #include "DwarfUnit.h"
  17 #include "DwarfAccelTable.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/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/MCAsmInfo.h"
  26 #include "llvm/MC/MCSection.h"
  27 #include "llvm/MC/MCStreamer.h"
  28 #include "llvm/Target/Mangler.h"
  29 #include "llvm/Target/TargetFrameLowering.h"
  30 #include "llvm/Target/TargetMachine.h"
  31 #include "llvm/Target/TargetLoweringObjectFile.h"
  32 #include "llvm/Target/TargetRegisterInfo.h"
  33 #include "llvm/Support/CommandLine.h"
  34
  35 using namespace llvm;
  36
  37 static cl::opt<bool>
  38 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  39                        cl::desc("Generate DWARF4 type units."),
  40                        cl::init(false));
  41
  42 /// Unit - Unit constructor.
  43 DwarfUnit::DwarfUnit(unsigned UID, DIE *D, DICompileUnit Node, AsmPrinter *A,
  44                      DwarfDebug *DW, DwarfFile *DWU)
  45     : UniqueID(UID), Node(Node), UnitDie(D), DebugInfoOffset(0), Asm(A), DD(DW),
  46       DU(DWU), IndexTyDie(0), Section(0), Skeleton(0) {
  47   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  48 }
  49
  50 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
  51                                    AsmPrinter *A, DwarfDebug *DW,
  52                                    DwarfFile *DWU)
  53     : DwarfUnit(UID, D, Node, A, DW, DWU) {
  54   insertDIE(Node, D);
  55 }
  56
  57 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DIE *D, uint16_t Language,
  58                              AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
  59     : DwarfUnit(UID, D, DICompileUnit(), A, DW, DWU), Language(Language) {}
  60
  61 /// ~Unit - Destructor for compile unit.
  62 DwarfUnit::~DwarfUnit() {
  63   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  64     DIEBlocks[j]->~DIEBlock();
  65 }
  66
  67 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  68 /// information entry.
  69 DIEEntry *DwarfUnit::createDIEEntry(DIE *Entry) {
  70   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  71   return Value;
  72 }
  73
  74 /// getDefaultLowerBound - Return the default lower bound for an array. If the
  75 /// DWARF version doesn't handle the language, return -1.
  76 int64_t DwarfUnit::getDefaultLowerBound() const {
  77   switch (getLanguage()) {
  78   default:
  79     break;
  80
  81   case dwarf::DW_LANG_C89:
  82   case dwarf::DW_LANG_C99:
  83   case dwarf::DW_LANG_C:
  84   case dwarf::DW_LANG_C_plus_plus:
  85   case dwarf::DW_LANG_ObjC:
  86   case dwarf::DW_LANG_ObjC_plus_plus:
  87     return 0;
  88
  89   case dwarf::DW_LANG_Fortran77:
  90   case dwarf::DW_LANG_Fortran90:
  91   case dwarf::DW_LANG_Fortran95:
  92     return 1;
  93
  94   // The languages below have valid values only if the DWARF version >= 4.
  95   case dwarf::DW_LANG_Java:
  96   case dwarf::DW_LANG_Python:
  97   case dwarf::DW_LANG_UPC:
  98   case dwarf::DW_LANG_D:
  99     if (dwarf::DWARF_VERSION >= 4)
 100       return 0;
 101     break;
 102
 103   case dwarf::DW_LANG_Ada83:
 104   case dwarf::DW_LANG_Ada95:
 105   case dwarf::DW_LANG_Cobol74:
 106   case dwarf::DW_LANG_Cobol85:
 107   case dwarf::DW_LANG_Modula2:
 108   case dwarf::DW_LANG_Pascal83:
 109   case dwarf::DW_LANG_PLI:
 110     if (dwarf::DWARF_VERSION >= 4)
 111       return 1;
 112     break;
 113   }
 114
 115   return -1;
 116 }
 117
 118 /// Check whether the DIE for this MDNode can be shared across CUs.
 119 static bool isShareableAcrossCUs(DIDescriptor D) {
 120   // When the MDNode can be part of the type system, the DIE can be shared
 121   // across CUs.
 122   // Combining type units and cross-CU DIE sharing is lower value (since
 123   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 124   // level already) but may be implementable for some value in projects
 125   // building multiple independent libraries with LTO and then linking those
 126   // together.
 127   return (D.isType() ||
 128           (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
 129          !GenerateDwarfTypeUnits;
 130 }
 131
 132 /// getDIE - Returns the debug information entry map slot for the
 133 /// specified debug variable. We delegate the request to DwarfDebug
 134 /// when the DIE for this MDNode can be shared across CUs. The mappings
 135 /// will be kept in DwarfDebug for shareable DIEs.
 136 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
 137   if (isShareableAcrossCUs(D))
 138     return DD->getDIE(D);
 139   return MDNodeToDieMap.lookup(D);
 140 }
 141
 142 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
 143 /// when the DIE for this MDNode can be shared across CUs. The mappings
 144 /// will be kept in DwarfDebug for shareable DIEs.
 145 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
 146   if (isShareableAcrossCUs(Desc)) {
 147     DD->insertDIE(Desc, D);
 148     return;
 149   }
 150   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 151 }
 152
 153 /// addFlag - Add a flag that is true.
 154 void DwarfUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
 155   if (DD->getDwarfVersion() >= 4)
 156     Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
 157   else
 158     Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
 159 }
 160
 161 /// addUInt - Add an unsigned integer attribute data and value.
 162 ///
 163 void DwarfUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
 164                         Optional<dwarf::Form> Form, uint64_t Integer) {
 165   if (!Form)
 166     Form = DIEInteger::BestForm(false, Integer);
 167   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
 168                         DIEInteger(Integer);
 169   Die->addValue(Attribute, *Form, Value);
 170 }
 171
 172 void DwarfUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
 173   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 174 }
 175
 176 /// addSInt - Add an signed integer attribute data and value.
 177 ///
 178 void DwarfUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
 179                         Optional<dwarf::Form> Form, int64_t Integer) {
 180   if (!Form)
 181     Form = DIEInteger::BestForm(true, Integer);
 182   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 183   Die->addValue(Attribute, *Form, Value);
 184 }
 185
 186 void DwarfUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
 187                         int64_t Integer) {
 188   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 189 }
 190
 191 /// addString - Add a string attribute data and value. We always emit a
 192 /// reference to the string pool instead of immediate strings so that DIEs have
 193 /// more predictable sizes. In the case of split dwarf we emit an index
 194 /// into another table which gets us the static offset into the string
 195 /// table.
 196 void DwarfUnit::addString(DIE *Die, dwarf::Attribute Attribute,
 197                           StringRef String) {
 198
 199   if (!DD->useSplitDwarf())
 200     return addLocalString(Die, Attribute, String);
 201
 202   unsigned idx = DU->getStringPoolIndex(String);
 203   DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
 204   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 205   Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
 206 }
 207
 208 /// addLocalString - Add a string attribute data and value. This is guaranteed
 209 /// to be in the local string pool instead of indirected.
 210 void DwarfUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
 211                                StringRef String) {
 212   MCSymbol *Symb = DU->getStringPoolEntry(String);
 213   DIEValue *Value;
 214   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 215     Value = new (DIEValueAllocator) DIELabel(Symb);
 216   else {
 217     MCSymbol *StringPool = DU->getStringPoolSym();
 218     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
 219   }
 220   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 221   Die->addValue(Attribute, dwarf::DW_FORM_strp, Str);
 222 }
 223
 224 /// addExpr - Add a Dwarf expression attribute data and value.
 225 ///
 226 void DwarfUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
 227   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
 228   Die->addValue((dwarf::Attribute)0, Form, Value);
 229 }
 230
 231 /// addLabel - Add a Dwarf label attribute data and value.
 232 ///
 233 void DwarfUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
 234                          const MCSymbol *Label) {
 235   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 236   Die->addValue(Attribute, Form, Value);
 237 }
 238
 239 void DwarfUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
 240                          const MCSymbol *Label) {
 241   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 242 }
 243
 244 /// addSectionLabel - Add a Dwarf section label attribute data and value.
 245 ///
 246 void DwarfUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
 247                                 const MCSymbol *Label) {
 248   if (DD->getDwarfVersion() >= 4)
 249     addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
 250   else
 251     addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
 252 }
 253
 254 /// addSectionOffset - Add an offset into a section attribute data and value.
 255 ///
 256 void DwarfUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
 257                                  uint64_t Integer) {
 258   if (DD->getDwarfVersion() >= 4)
 259     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 260   else
 261     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 262 }
 263
 264 /// addLabelAddress - Add a dwarf label attribute data and value using
 265 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
 266 ///
 267 void DwarfCompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
 268                                        MCSymbol *Label) {
 269   if (Label)
 270     DD->addArangeLabel(SymbolCU(this, Label));
 271
 272   if (!DD->useSplitDwarf()) {
 273     if (Label) {
 274       DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 275       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
 276     } else {
 277       DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
 278       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
 279     }
 280   } else {
 281     unsigned idx = DU->getAddrPoolIndex(Label);
 282     DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
 283     Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
 284   }
 285 }
 286
 287 /// addOpAddress - Add a dwarf op address data and value using the
 288 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
 289 ///
 290 void DwarfUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
 291   if (!DD->useSplitDwarf()) {
 292     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 293     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 294   } else {
 295     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 296     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
 297   }
 298 }
 299
 300 /// addSectionDelta - Add a section label delta attribute data and value.
 301 ///
 302 void DwarfUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
 303                                 const MCSymbol *Hi, const MCSymbol *Lo) {
 304   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 305   if (DD->getDwarfVersion() >= 4)
 306     Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
 307   else
 308     Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
 309 }
 310
 311 /// addDIEEntry - Add a DIE attribute data and value.
 312 ///
 313 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
 314   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
 315 }
 316
 317 void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
 318   Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
 319                 new (DIEValueAllocator) DIETypeSignature(Type));
 320 }
 321
 322 void DwarfUnit::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 = getUnitDie();
 329   if (!EntryCU)
 330     EntryCU = getUnitDie();
 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 *DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DbgVariable, starting
 528 /// from the starting location.  Add the DWARF information to the die.
 529 ///
 530 void DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
 903   if (!Context || Context.isFile())
 904     return getUnitDie();
 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 *DwarfUnit::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 isDwarfTypeUnitScoped(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 shouldCreateDwarfTypeUnit(DICompositeType CTy,
 946                                       const DwarfDebug *DD) {
 947   if (!GenerateDwarfTypeUnits)
 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() && isDwarfTypeUnitScoped(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 *DwarfUnit::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 (shouldCreateDwarfTypeUnit(CTy, DD)) {
 993       DD->addDwarfTypeUnitType(getLanguage(), 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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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 DwarfUnit::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
1214     if (CTy.isLValueReference())
1215       addFlag(&Buffer, dwarf::DW_AT_reference);
1216
1217     if (CTy.isRValueReference())
1218       addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
1219   } break;
1220   case dwarf::DW_TAG_structure_type:
1221   case dwarf::DW_TAG_union_type:
1222   case dwarf::DW_TAG_class_type: {
1223     // Add elements to structure type.
1224     DIArray Elements = CTy.getTypeArray();
1225     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1226       DIDescriptor Element = Elements.getElement(i);
1227       DIE *ElemDie = NULL;
1228       if (Element.isSubprogram()) {
1229         DISubprogram SP(Element);
1230         ElemDie = getOrCreateSubprogramDIE(SP);
1231         if (SP.isProtected())
1232           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1233                   dwarf::DW_ACCESS_protected);
1234         else if (SP.isPrivate())
1235           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1236                   dwarf::DW_ACCESS_private);
1237         else
1238           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1239                   dwarf::DW_ACCESS_public);
1240         if (SP.isExplicit())
1241           addFlag(ElemDie, dwarf::DW_AT_explicit);
1242       } else if (Element.isDerivedType()) {
1243         DIDerivedType DDTy(Element);
1244         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1245           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1246           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1247                   dwarf::DW_AT_friend);
1248         } else if (DDTy.isStaticMember()) {
1249           getOrCreateStaticMemberDIE(DDTy);
1250         } else {
1251           constructMemberDIE(Buffer, DDTy);
1252         }
1253       } else if (Element.isObjCProperty()) {
1254         DIObjCProperty Property(Element);
1255         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1256         StringRef PropertyName = Property.getObjCPropertyName();
1257         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1258         addType(ElemDie, Property.getType());
1259         addSourceLine(ElemDie, Property);
1260         StringRef GetterName = Property.getObjCPropertyGetterName();
1261         if (!GetterName.empty())
1262           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1263         StringRef SetterName = Property.getObjCPropertySetterName();
1264         if (!SetterName.empty())
1265           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1266         unsigned PropertyAttributes = 0;
1267         if (Property.isReadOnlyObjCProperty())
1268           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1269         if (Property.isReadWriteObjCProperty())
1270           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1271         if (Property.isAssignObjCProperty())
1272           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1273         if (Property.isRetainObjCProperty())
1274           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1275         if (Property.isCopyObjCProperty())
1276           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1277         if (Property.isNonAtomicObjCProperty())
1278           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1279         if (PropertyAttributes)
1280           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1281                   PropertyAttributes);
1282
1283         DIEEntry *Entry = getDIEEntry(Element);
1284         if (!Entry) {
1285           Entry = createDIEEntry(ElemDie);
1286           insertDIEEntry(Element, Entry);
1287         }
1288       } else
1289         continue;
1290     }
1291
1292     if (CTy.isAppleBlockExtension())
1293       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1294
1295     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1296     if (ContainingType)
1297       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1298                   getOrCreateTypeDIE(ContainingType));
1299
1300     if (CTy.isObjcClassComplete())
1301       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1302
1303     // Add template parameters to a class, structure or union types.
1304     // FIXME: The support isn't in the metadata for this yet.
1305     if (Tag == dwarf::DW_TAG_class_type ||
1306         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1307       addTemplateParams(Buffer, CTy.getTemplateParams());
1308
1309     break;
1310   }
1311   default:
1312     break;
1313   }
1314
1315   // Add name if not anonymous or intermediate type.
1316   if (!Name.empty())
1317     addString(&Buffer, dwarf::DW_AT_name, Name);
1318
1319   if (Tag == dwarf::DW_TAG_enumeration_type ||
1320       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1321       Tag == dwarf::DW_TAG_union_type) {
1322     // Add size if non-zero (derived types might be zero-sized.)
1323     // TODO: Do we care about size for enum forward declarations?
1324     if (Size)
1325       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1326     else if (!CTy.isForwardDecl())
1327       // Add zero size if it is not a forward declaration.
1328       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1329
1330     // If we're a forward decl, say so.
1331     if (CTy.isForwardDecl())
1332       addFlag(&Buffer, dwarf::DW_AT_declaration);
1333
1334     // Add source line info if available.
1335     if (!CTy.isForwardDecl())
1336       addSourceLine(&Buffer, CTy);
1337
1338     // No harm in adding the runtime language to the declaration.
1339     unsigned RLang = CTy.getRunTimeLang();
1340     if (RLang)
1341       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1342               RLang);
1343   }
1344 }
1345
1346 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1347 /// DITemplateTypeParameter.
1348 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1349                                                   DITemplateTypeParameter TP) {
1350   DIE *ParamDIE =
1351       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1352   // Add the type if it exists, it could be void and therefore no type.
1353   if (TP.getType())
1354     addType(ParamDIE, resolve(TP.getType()));
1355   if (!TP.getName().empty())
1356     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1357 }
1358
1359 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1360 /// DITemplateValueParameter.
1361 void
1362 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1363                                               DITemplateValueParameter VP) {
1364   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1365
1366   // Add the type if there is one, template template and template parameter
1367   // packs will not have a type.
1368   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1369     addType(ParamDIE, resolve(VP.getType()));
1370   if (!VP.getName().empty())
1371     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1372   if (Value *Val = VP.getValue()) {
1373     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1374       addConstantValue(ParamDIE, CI,
1375                        isUnsignedDIType(DD, resolve(VP.getType())));
1376     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1377       // For declaration non-type template parameters (such as global values and
1378       // functions)
1379       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1380       addOpAddress(Block, Asm->getSymbol(GV));
1381       // Emit DW_OP_stack_value to use the address as the immediate value of the
1382       // parameter, rather than a pointer to it.
1383       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1384       addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1385     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1386       assert(isa<MDString>(Val));
1387       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1388                 cast<MDString>(Val)->getString());
1389     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1390       assert(isa<MDNode>(Val));
1391       DIArray A(cast<MDNode>(Val));
1392       addTemplateParams(*ParamDIE, A);
1393     }
1394   }
1395 }
1396
1397 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1398 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1399   // Construct the context before querying for the existence of the DIE in case
1400   // such construction creates the DIE.
1401   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1402
1403   DIE *NDie = getDIE(NS);
1404   if (NDie)
1405     return NDie;
1406   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1407
1408   if (!NS.getName().empty()) {
1409     addString(NDie, dwarf::DW_AT_name, NS.getName());
1410     addAccelNamespace(NS.getName(), NDie);
1411     addGlobalName(NS.getName(), NDie, NS.getContext());
1412   } else
1413     addAccelNamespace("(anonymous namespace)", NDie);
1414   addSourceLine(NDie, NS);
1415   return NDie;
1416 }
1417
1418 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1419 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1420   // Construct the context before querying for the existence of the DIE in case
1421   // such construction creates the DIE (as is the case for member function
1422   // declarations).
1423   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1424
1425   DIE *SPDie = getDIE(SP);
1426   if (SPDie)
1427     return SPDie;
1428
1429   DISubprogram SPDecl = SP.getFunctionDeclaration();
1430   if (SPDecl.isSubprogram())
1431     // Add subprogram definitions to the CU die directly.
1432     ContextDIE = UnitDie.get();
1433
1434   // DW_TAG_inlined_subroutine may refer to this DIE.
1435   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1436
1437   DIE *DeclDie = NULL;
1438   if (SPDecl.isSubprogram())
1439     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1440
1441   // Add function template parameters.
1442   addTemplateParams(*SPDie, SP.getTemplateParams());
1443
1444   // If this DIE is going to refer declaration info using AT_specification
1445   // then there is no need to add other attributes.
1446   if (DeclDie) {
1447     // Refer function declaration directly.
1448     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1449
1450     return SPDie;
1451   }
1452
1453   // Add the linkage name if we have one.
1454   StringRef LinkageName = SP.getLinkageName();
1455   if (!LinkageName.empty())
1456     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1457               GlobalValue::getRealLinkageName(LinkageName));
1458
1459   // Constructors and operators for anonymous aggregates do not have names.
1460   if (!SP.getName().empty())
1461     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1462
1463   addSourceLine(SPDie, SP);
1464
1465   // Add the prototype if we have a prototype and we have a C like
1466   // language.
1467   uint16_t Language = getLanguage();
1468   if (SP.isPrototyped() &&
1469       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1470        Language == dwarf::DW_LANG_ObjC))
1471     addFlag(SPDie, dwarf::DW_AT_prototyped);
1472
1473   DICompositeType SPTy = SP.getType();
1474   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1475          "the type of a subprogram should be a subroutine");
1476
1477   DIArray Args = SPTy.getTypeArray();
1478   // Add a return type. If this is a type like a C/C++ void type we don't add a
1479   // return type.
1480   if (Args.getElement(0))
1481     addType(SPDie, DIType(Args.getElement(0)));
1482
1483   unsigned VK = SP.getVirtuality();
1484   if (VK) {
1485     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1486     DIEBlock *Block = getDIEBlock();
1487     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1488     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1489     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1490     ContainingTypeMap.insert(
1491         std::make_pair(SPDie, resolve(SP.getContainingType())));
1492   }
1493
1494   if (!SP.isDefinition()) {
1495     addFlag(SPDie, dwarf::DW_AT_declaration);
1496
1497     // Add arguments. Do not add arguments for subprogram definition. They will
1498     // be handled while processing variables.
1499     for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1500       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1501       DIType ATy(Args.getElement(i));
1502       addType(Arg, ATy);
1503       if (ATy.isArtificial())
1504         addFlag(Arg, dwarf::DW_AT_artificial);
1505     }
1506   }
1507
1508   if (SP.isArtificial())
1509     addFlag(SPDie, dwarf::DW_AT_artificial);
1510
1511   if (!SP.isLocalToUnit())
1512     addFlag(SPDie, dwarf::DW_AT_external);
1513
1514   if (SP.isOptimized())
1515     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1516
1517   if (unsigned isa = Asm->getISAEncoding()) {
1518     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1519   }
1520
1521   if (SP.isLValueReference())
1522     addFlag(SPDie, dwarf::DW_AT_reference);
1523
1524   if (SP.isRValueReference())
1525     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1526
1527   return SPDie;
1528 }
1529
1530 // Return const expression if value is a GEP to access merged global
1531 // constant. e.g.
1532 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1533 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1534   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1535   if (!CE || CE->getNumOperands() != 3 ||
1536       CE->getOpcode() != Instruction::GetElementPtr)
1537     return NULL;
1538
1539   // First operand points to a global struct.
1540   Value *Ptr = CE->getOperand(0);
1541   if (!isa<GlobalValue>(Ptr) ||
1542       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1543     return NULL;
1544
1545   // Second operand is zero.
1546   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1547   if (!CI || !CI->isZero())
1548     return NULL;
1549
1550   // Third operand is offset.
1551   if (!isa<ConstantInt>(CE->getOperand(2)))
1552     return NULL;
1553
1554   return CE;
1555 }
1556
1557 /// createGlobalVariableDIE - create global variable DIE.
1558 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1559   // Check for pre-existence.
1560   if (getDIE(GV))
1561     return;
1562
1563   if (!GV.isGlobalVariable())
1564     return;
1565
1566   DIScope GVContext = GV.getContext();
1567   DIType GTy = GV.getType();
1568
1569   // If this is a static data member definition, some attributes belong
1570   // to the declaration DIE.
1571   DIE *VariableDIE = NULL;
1572   bool IsStaticMember = false;
1573   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1574   if (SDMDecl.Verify()) {
1575     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1576     // We need the declaration DIE that is in the static member's class.
1577     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1578     IsStaticMember = true;
1579   }
1580
1581   // If this is not a static data member definition, create the variable
1582   // DIE and add the initial set of attributes to it.
1583   if (!VariableDIE) {
1584     // Construct the context before querying for the existence of the DIE in
1585     // case such construction creates the DIE.
1586     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1587
1588     // Add to map.
1589     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1590
1591     // Add name and type.
1592     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1593     addType(VariableDIE, GTy);
1594
1595     // Add scoping info.
1596     if (!GV.isLocalToUnit())
1597       addFlag(VariableDIE, dwarf::DW_AT_external);
1598
1599     // Add line number info.
1600     addSourceLine(VariableDIE, GV);
1601   }
1602
1603   // Add location.
1604   bool addToAccelTable = false;
1605   DIE *VariableSpecDIE = NULL;
1606   bool isGlobalVariable = GV.getGlobal() != NULL;
1607   if (isGlobalVariable) {
1608     addToAccelTable = true;
1609     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1610     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1611     if (GV.getGlobal()->isThreadLocal()) {
1612       // FIXME: Make this work with -gsplit-dwarf.
1613       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1614       assert((PointerSize == 4 || PointerSize == 8) &&
1615              "Add support for other sizes if necessary");
1616       const MCExpr *Expr =
1617           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1618       // Based on GCC's support for TLS:
1619       if (!DD->useSplitDwarf()) {
1620         // 1) Start with a constNu of the appropriate pointer size
1621         addUInt(Block, dwarf::DW_FORM_data1,
1622                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1623         // 2) containing the (relocated) offset of the TLS variable
1624         //    within the module's TLS block.
1625         addExpr(Block, dwarf::DW_FORM_udata, Expr);
1626       } else {
1627         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1628         addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1629       }
1630       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1631       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1632     } else {
1633       DD->addArangeLabel(SymbolCU(this, Sym));
1634       addOpAddress(Block, Sym);
1635     }
1636     // Do not create specification DIE if context is either compile unit
1637     // or a subprogram.
1638     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1639         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1640       // Create specification DIE.
1641       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1642       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1643       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1644       // A static member's declaration is already flagged as such.
1645       if (!SDMDecl.Verify())
1646         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1647     } else {
1648       addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1649     }
1650     // Add the linkage name.
1651     StringRef LinkageName = GV.getLinkageName();
1652     if (!LinkageName.empty())
1653       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1654       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1655       // TAG_variable.
1656       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1657                                                   : VariableDIE,
1658                 dwarf::DW_AT_MIPS_linkage_name,
1659                 GlobalValue::getRealLinkageName(LinkageName));
1660   } else if (const ConstantInt *CI =
1661                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1662     // AT_const_value was added when the static member was created. To avoid
1663     // emitting AT_const_value multiple times, we only add AT_const_value when
1664     // it is not a static member.
1665     if (!IsStaticMember)
1666       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1667   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1668     addToAccelTable = true;
1669     // GV is a merged global.
1670     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1671     Value *Ptr = CE->getOperand(0);
1672     MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1673     DD->addArangeLabel(SymbolCU(this, Sym));
1674     addOpAddress(Block, Sym);
1675     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1676     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1677     addUInt(Block, dwarf::DW_FORM_udata,
1678             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1679     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1680     addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1681   }
1682
1683   if (addToAccelTable) {
1684     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1685     addAccelName(GV.getName(), AddrDIE);
1686
1687     // If the linkage name is different than the name, go ahead and output
1688     // that as well into the name table.
1689     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1690       addAccelName(GV.getLinkageName(), AddrDIE);
1691   }
1692
1693   if (!GV.isLocalToUnit())
1694     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1695                   GV.getContext());
1696 }
1697
1698 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1699 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1700   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1701   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1702
1703   // The LowerBound value defines the lower bounds which is typically zero for
1704   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1705   // Count == -1 then the array is unbounded and we do not emit
1706   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1707   // Count == 0, then the array has zero elements in which case we do not emit
1708   // an upper bound.
1709   int64_t LowerBound = SR.getLo();
1710   int64_t DefaultLowerBound = getDefaultLowerBound();
1711   int64_t Count = SR.getCount();
1712
1713   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1714     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1715
1716   if (Count != -1 && Count != 0)
1717     // FIXME: An unbounded array should reference the expression that defines
1718     // the array.
1719     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1720             LowerBound + Count - 1);
1721 }
1722
1723 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1724 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1725   if (CTy.isVector())
1726     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1727
1728   // Emit the element type.
1729   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1730
1731   // Get an anonymous type for index type.
1732   // FIXME: This type should be passed down from the front end
1733   // as different languages may have different sizes for indexes.
1734   DIE *IdxTy = getIndexTyDie();
1735   if (!IdxTy) {
1736     // Construct an anonymous type for index type.
1737     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1738     addString(IdxTy, dwarf::DW_AT_name, "int");
1739     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1740     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1741             dwarf::DW_ATE_signed);
1742     setIndexTyDie(IdxTy);
1743   }
1744
1745   // Add subranges to array type.
1746   DIArray Elements = CTy.getTypeArray();
1747   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1748     DIDescriptor Element = Elements.getElement(i);
1749     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1750       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1751   }
1752 }
1753
1754 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1755 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1756   DIArray Elements = CTy.getTypeArray();
1757
1758   // Add enumerators to enumeration type.
1759   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1760     DIEnumerator Enum(Elements.getElement(i));
1761     if (Enum.isEnumerator()) {
1762       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1763       StringRef Name = Enum.getName();
1764       addString(Enumerator, dwarf::DW_AT_name, Name);
1765       int64_t Value = Enum.getEnumValue();
1766       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1767               Value);
1768     }
1769   }
1770   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1771   if (DTy) {
1772     addType(&Buffer, DTy);
1773     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1774   }
1775 }
1776
1777 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1778 /// vtables.
1779 void DwarfUnit::constructContainingTypeDIEs() {
1780   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1781                                                  CE = ContainingTypeMap.end();
1782        CI != CE; ++CI) {
1783     DIE *SPDie = CI->first;
1784     DIDescriptor D(CI->second);
1785     if (!D)
1786       continue;
1787     DIE *NDie = getDIE(D);
1788     if (!NDie)
1789       continue;
1790     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1791   }
1792 }
1793
1794 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1795 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1796   StringRef Name = DV.getName();
1797
1798   // Define variable debug information entry.
1799   DIE *VariableDie = new DIE(DV.getTag());
1800   DbgVariable *AbsVar = DV.getAbstractVariable();
1801   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1802   if (AbsDIE)
1803     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1804   else {
1805     if (!Name.empty())
1806       addString(VariableDie, dwarf::DW_AT_name, Name);
1807     addSourceLine(VariableDie, DV.getVariable());
1808     addType(VariableDie, DV.getType());
1809   }
1810
1811   if (DV.isArtificial())
1812     addFlag(VariableDie, dwarf::DW_AT_artificial);
1813
1814   if (isScopeAbstract) {
1815     DV.setDIE(VariableDie);
1816     return VariableDie;
1817   }
1818
1819   // Add variable address.
1820
1821   unsigned Offset = DV.getDotDebugLocOffset();
1822   if (Offset != ~0U) {
1823     addSectionLabel(VariableDie, dwarf::DW_AT_location,
1824                     Asm->GetTempSymbol("debug_loc", Offset));
1825     DV.setDIE(VariableDie);
1826     return VariableDie;
1827   }
1828
1829   // Check if variable is described by a DBG_VALUE instruction.
1830   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1831     assert(DVInsn->getNumOperands() == 3);
1832     if (DVInsn->getOperand(0).isReg()) {
1833       const MachineOperand RegOp = DVInsn->getOperand(0);
1834       // If the second operand is an immediate, this is an indirect value.
1835       if (DVInsn->getOperand(1).isImm()) {
1836         MachineLocation Location(RegOp.getReg(),
1837                                  DVInsn->getOperand(1).getImm());
1838         addVariableAddress(DV, VariableDie, Location);
1839       } else if (RegOp.getReg())
1840         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1841     } else if (DVInsn->getOperand(0).isImm())
1842       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1843     else if (DVInsn->getOperand(0).isFPImm())
1844       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1845     else if (DVInsn->getOperand(0).isCImm())
1846       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1847                        isUnsignedDIType(DD, DV.getType()));
1848
1849     DV.setDIE(VariableDie);
1850     return VariableDie;
1851   } else {
1852     // .. else use frame index.
1853     int FI = DV.getFrameIndex();
1854     if (FI != ~0) {
1855       unsigned FrameReg = 0;
1856       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1857       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1858       MachineLocation Location(FrameReg, Offset);
1859       addVariableAddress(DV, VariableDie, Location);
1860     }
1861   }
1862
1863   DV.setDIE(VariableDie);
1864   return VariableDie;
1865 }
1866
1867 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1868 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1869   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1870   StringRef Name = DT.getName();
1871   if (!Name.empty())
1872     addString(MemberDie, dwarf::DW_AT_name, Name);
1873
1874   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1875
1876   addSourceLine(MemberDie, DT);
1877
1878   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1879   addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1880
1881   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1882
1883     // For C++, virtual base classes are not at fixed offset. Use following
1884     // expression to extract appropriate offset from vtable.
1885     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1886
1887     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1888     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1889     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1890     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1891     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1892     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1893     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1894     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1895
1896     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1897   } else {
1898     uint64_t Size = DT.getSizeInBits();
1899     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1900     uint64_t OffsetInBytes;
1901
1902     if (Size != FieldSize) {
1903       // Handle bitfield.
1904       addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1905               getBaseTypeSize(DD, DT) >> 3);
1906       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1907
1908       uint64_t Offset = DT.getOffsetInBits();
1909       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1910       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1911       uint64_t FieldOffset = (HiMark - FieldSize);
1912       Offset -= FieldOffset;
1913
1914       // Maybe we need to work from the other end.
1915       if (Asm->getDataLayout().isLittleEndian())
1916         Offset = FieldSize - (Offset + Size);
1917       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1918
1919       // Here WD_AT_data_member_location points to the anonymous
1920       // field that includes this bit field.
1921       OffsetInBytes = FieldOffset >> 3;
1922     } else
1923       // This is not a bitfield.
1924       OffsetInBytes = DT.getOffsetInBits() >> 3;
1925     addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1926   }
1927
1928   if (DT.isProtected())
1929     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1930             dwarf::DW_ACCESS_protected);
1931   else if (DT.isPrivate())
1932     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1933             dwarf::DW_ACCESS_private);
1934   // Otherwise C++ member and base classes are considered public.
1935   else
1936     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1937             dwarf::DW_ACCESS_public);
1938   if (DT.isVirtual())
1939     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1940             dwarf::DW_VIRTUALITY_virtual);
1941
1942   // Objective-C properties.
1943   if (MDNode *PNode = DT.getObjCProperty())
1944     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1945       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1946                           PropertyDie);
1947
1948   if (DT.isArtificial())
1949     addFlag(MemberDie, dwarf::DW_AT_artificial);
1950 }
1951
1952 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1953 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1954   if (!DT.Verify())
1955     return NULL;
1956
1957   // Construct the context before querying for the existence of the DIE in case
1958   // such construction creates the DIE.
1959   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1960   assert(dwarf::isType(ContextDIE->getTag()) &&
1961          "Static member should belong to a type.");
1962
1963   DIE *StaticMemberDIE = getDIE(DT);
1964   if (StaticMemberDIE)
1965     return StaticMemberDIE;
1966
1967   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1968
1969   DIType Ty = resolve(DT.getTypeDerivedFrom());
1970
1971   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1972   addType(StaticMemberDIE, Ty);
1973   addSourceLine(StaticMemberDIE, DT);
1974   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1975   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1976
1977   // FIXME: We could omit private if the parent is a class_type, and
1978   // public if the parent is something else.
1979   if (DT.isProtected())
1980     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1981             dwarf::DW_ACCESS_protected);
1982   else if (DT.isPrivate())
1983     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1984             dwarf::DW_ACCESS_private);
1985   else
1986     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1987             dwarf::DW_ACCESS_public);
1988
1989   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1990     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1991   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1992     addConstantFPValue(StaticMemberDIE, CFP);
1993
1994   return StaticMemberDIE;
1995 }
1996
1997 void DwarfUnit::emitHeader(const MCSection *ASection,
1998                            const MCSymbol *ASectionSym) const {
1999   Asm->OutStreamer.AddComment("DWARF version number");
2000   Asm->EmitInt16(DD->getDwarfVersion());
2001   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2002   // We share one abbreviations table across all units so it's always at the
2003   // start of the section. Use a relocatable offset where needed to ensure
2004   // linking doesn't invalidate that offset.
2005   Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2006   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2007   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2008 }
2009
2010 DwarfCompileUnit::~DwarfCompileUnit() {}
2011 DwarfTypeUnit::~DwarfTypeUnit() {}
2012
2013 void DwarfTypeUnit::emitHeader(const MCSection *ASection,
2014                                const MCSymbol *ASectionSym) const {
2015   DwarfUnit::emitHeader(ASection, ASectionSym);
2016   Asm->OutStreamer.AddComment("Type Signature");
2017   Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2018   Asm->OutStreamer.AddComment("Type DIE Offset");
2019   Asm->OutStreamer.EmitIntValue(Ty->getOffset(), sizeof(Ty->getOffset()));
2020 }
2021
2022 void DwarfTypeUnit::initSection(const MCSection *Section) {
2023   assert(!this->Section);
2024   this->Section = Section;
2025   // Since each type unit is contained in its own COMDAT section, the begin
2026   // label and the section label are the same. Using the begin label emission in
2027   // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2028   // the only other alternative of lazily constructing start-of-section labels
2029   // and storing a mapping in DwarfDebug (or AsmPrinter).
2030   this->SectionSym = this->LabelBegin =
2031       Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2032   this->LabelEnd =
2033       Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2034   this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());
2035 }