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