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