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