lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

   1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for constructing a dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfAccelTable.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/DIBuilder.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DataLayout.h"
  23 #include "llvm/IR/GlobalVariable.h"
  24 #include "llvm/IR/Instructions.h"
  25 #include "llvm/MC/MCSection.h"
  26 #include "llvm/MC/MCStreamer.h"
  27 #include "llvm/Target/Mangler.h"
  28 #include "llvm/Target/TargetFrameLowering.h"
  29 #include "llvm/Target/TargetMachine.h"
  30 #include "llvm/Target/TargetLoweringObjectFile.h"
  31 #include "llvm/Target/TargetRegisterInfo.h"
  32
  33 using namespace llvm;
  34
  35 /// CompileUnit - Compile unit constructor.
  36 CompileUnit::CompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
  37                          AsmPrinter *A, DwarfDebug *DW, DwarfUnits *DWU)
  38     : UniqueID(UID), Node(Node), CUDie(D), Asm(A), DD(DW), DU(DWU),
  39       IndexTyDie(0), DebugInfoOffset(0) {
  40   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  41   insertDIE(Node, D);
  42 }
  43
  44 /// ~CompileUnit - Destructor for compile unit.
  45 CompileUnit::~CompileUnit() {
  46   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  47     DIEBlocks[j]->~DIEBlock();
  48 }
  49
  50 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  51 /// information entry.
  52 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
  53   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  54   return Value;
  55 }
  56
  57 /// getDefaultLowerBound - Return the default lower bound for an array. If the
  58 /// DWARF version doesn't handle the language, return -1.
  59 int64_t CompileUnit::getDefaultLowerBound() const {
  60   switch (getLanguage()) {
  61   default:
  62     break;
  63
  64   case dwarf::DW_LANG_C89:
  65   case dwarf::DW_LANG_C99:
  66   case dwarf::DW_LANG_C:
  67   case dwarf::DW_LANG_C_plus_plus:
  68   case dwarf::DW_LANG_ObjC:
  69   case dwarf::DW_LANG_ObjC_plus_plus:
  70     return 0;
  71
  72   case dwarf::DW_LANG_Fortran77:
  73   case dwarf::DW_LANG_Fortran90:
  74   case dwarf::DW_LANG_Fortran95:
  75     return 1;
  76
  77   // The languages below have valid values only if the DWARF version >= 4.
  78   case dwarf::DW_LANG_Java:
  79   case dwarf::DW_LANG_Python:
  80   case dwarf::DW_LANG_UPC:
  81   case dwarf::DW_LANG_D:
  82     if (dwarf::DWARF_VERSION >= 4)
  83       return 0;
  84     break;
  85
  86   case dwarf::DW_LANG_Ada83:
  87   case dwarf::DW_LANG_Ada95:
  88   case dwarf::DW_LANG_Cobol74:
  89   case dwarf::DW_LANG_Cobol85:
  90   case dwarf::DW_LANG_Modula2:
  91   case dwarf::DW_LANG_Pascal83:
  92   case dwarf::DW_LANG_PLI:
  93     if (dwarf::DWARF_VERSION >= 4)
  94       return 1;
  95     break;
  96   }
  97
  98   return -1;
  99 }
 100
 101 /// Check whether the DIE for this MDNode can be shared across CUs.
 102 static bool isShareableAcrossCUs(DIDescriptor D) {
 103   // When the MDNode can be part of the type system, the DIE can be
 104   // shared across CUs.
 105   return D.isType() ||
 106          (D.isSubprogram() && !DISubprogram(D).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(DIDescriptor D) const {
 114   if (isShareableAcrossCUs(D))
 115     return DD->getDIE(D);
 116   return MDNodeToDieMap.lookup(D);
 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(DIDescriptor Desc, DIE *D) {
 123   if (isShareableAcrossCUs(Desc)) {
 124     DD->insertDIE(Desc, D);
 125     return;
 126   }
 127   MDNodeToDieMap.insert(std::make_pair(Desc, 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, DIDescriptor N) {
 300   DIE *Die = new DIE(Tag);
 301   Parent.addChild(Die);
 302   if (N)
 303     insertDIE(N, 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;
 606   DIDescriptor forwardingField;
 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   assert(ContextDIE);
 890
 891   DIE *TyDIE = getDIE(Ty);
 892   if (TyDIE)
 893     return TyDIE;
 894
 895   // Create new type.
 896   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
 897
 898   if (Ty.isBasicType())
 899     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 900   else if (Ty.isCompositeType())
 901     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 902   else {
 903     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 904     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 905   }
 906   // If this is a named finished type then include it in the list of types
 907   // for the accelerator tables.
 908   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 909     bool IsImplementation = 0;
 910     if (Ty.isCompositeType()) {
 911       DICompositeType CT(Ty);
 912       // A runtime language of 0 actually means C/C++ and that any
 913       // non-negative value is some version of Objective-C/C++.
 914       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
 915     }
 916     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 917     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
 918   }
 919
 920   return TyDIE;
 921 }
 922
 923 /// addType - Add a new type attribute to the specified entity.
 924 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
 925   assert(Ty && "Trying to add a type that doesn't exist?");
 926
 927   // Check for pre-existence.
 928   DIEEntry *Entry = getDIEEntry(Ty);
 929   // If it exists then use the existing value.
 930   if (Entry) {
 931     addDIEEntry(Entity, Attribute, Entry);
 932     return;
 933   }
 934
 935   // Construct type.
 936   DIE *Buffer = getOrCreateTypeDIE(Ty);
 937
 938   // Set up proxy.
 939   Entry = createDIEEntry(Buffer);
 940   insertDIEEntry(Ty, Entry);
 941   addDIEEntry(Entity, Attribute, Entry);
 942
 943   // If this is a complete composite type then include it in the
 944   // list of global types.
 945   addGlobalType(Ty);
 946 }
 947
 948 // Accelerator table mutators - add each name along with its companion
 949 // DIE to the proper table while ensuring that the name that we're going
 950 // to reference is in the string table. We do this since the names we
 951 // add may not only be identical to the names in the DIE.
 952 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
 953   DU->getStringPoolEntry(Name);
 954   std::vector<DIE *> &DIEs = AccelNames[Name];
 955   DIEs.push_back(Die);
 956 }
 957
 958 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
 959   DU->getStringPoolEntry(Name);
 960   std::vector<DIE *> &DIEs = AccelObjC[Name];
 961   DIEs.push_back(Die);
 962 }
 963
 964 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
 965   DU->getStringPoolEntry(Name);
 966   std::vector<DIE *> &DIEs = AccelNamespace[Name];
 967   DIEs.push_back(Die);
 968 }
 969
 970 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
 971   DU->getStringPoolEntry(Name);
 972   std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
 973   DIEs.push_back(Die);
 974 }
 975
 976 /// addGlobalName - Add a new global name to the compile unit.
 977 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
 978   std::string FullName = getParentContextString(Context) + Name.str();
 979   GlobalNames[FullName] = Die;
 980 }
 981
 982 /// addGlobalType - Add a new global type to the compile unit.
 983 ///
 984 void CompileUnit::addGlobalType(DIType Ty) {
 985   DIScope Context = resolve(Ty.getContext());
 986   if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
 987       (!Context || Context.isCompileUnit() || Context.isFile() ||
 988        Context.isNameSpace()))
 989     if (DIEEntry *Entry = getDIEEntry(Ty)) {
 990       std::string FullName =
 991           getParentContextString(Context) + Ty.getName().str();
 992       GlobalTypes[FullName] = Entry->getEntry();
 993     }
 994 }
 995
 996 /// getParentContextString - Walks the metadata parent chain in a language
 997 /// specific manner (using the compile unit language) and returns
 998 /// it as a string. This is done at the metadata level because DIEs may
 999 /// not currently have been added to the parent context and walking the
1000 /// DIEs looking for names is more expensive than walking the metadata.
1001 std::string CompileUnit::getParentContextString(DIScope Context) const {
1002   if (!Context)
1003     return "";
1004
1005   // FIXME: Decide whether to implement this for non-C++ languages.
1006   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1007     return "";
1008
1009   std::string CS;
1010   SmallVector<DIScope, 1> Parents;
1011   while (!Context.isCompileUnit()) {
1012     Parents.push_back(Context);
1013     if (Context.getContext())
1014       Context = resolve(Context.getContext());
1015     else
1016       // Structure, etc types will have a NULL context if they're at the top
1017       // level.
1018       break;
1019   }
1020
1021   // Reverse iterate over our list to go from the outermost construct to the
1022   // innermost.
1023   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1024                                                   E = Parents.rend();
1025        I != E; ++I) {
1026     DIScope Ctx = *I;
1027     StringRef Name = Ctx.getName();
1028     if (!Name.empty()) {
1029       CS += Name;
1030       CS += "::";
1031     }
1032   }
1033   return CS;
1034 }
1035
1036 /// addPubTypes - Add subprogram argument types for pubtypes section.
1037 void CompileUnit::addPubTypes(DISubprogram SP) {
1038   DICompositeType SPTy = SP.getType();
1039   uint16_t SPTag = SPTy.getTag();
1040   if (SPTag != dwarf::DW_TAG_subroutine_type)
1041     return;
1042
1043   DIArray Args = SPTy.getTypeArray();
1044   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1045     DIType ATy(Args.getElement(i));
1046     if (!ATy.isType())
1047       continue;
1048     addGlobalType(ATy);
1049   }
1050 }
1051
1052 /// constructTypeDIE - Construct basic type die from DIBasicType.
1053 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1054   // Get core information.
1055   StringRef Name = BTy.getName();
1056   // Add name if not anonymous or intermediate type.
1057   if (!Name.empty())
1058     addString(&Buffer, dwarf::DW_AT_name, Name);
1059
1060   // An unspecified type only has a name attribute.
1061   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1062     return;
1063
1064   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1065           BTy.getEncoding());
1066
1067   uint64_t Size = BTy.getSizeInBits() >> 3;
1068   addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1069 }
1070
1071 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1072 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1073   // Get core information.
1074   StringRef Name = DTy.getName();
1075   uint64_t Size = DTy.getSizeInBits() >> 3;
1076   uint16_t Tag = Buffer.getTag();
1077
1078   // Map to main type, void will not have a type.
1079   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1080   if (FromTy)
1081     addType(&Buffer, FromTy);
1082
1083   // Add name if not anonymous or intermediate type.
1084   if (!Name.empty())
1085     addString(&Buffer, dwarf::DW_AT_name, Name);
1086
1087   // Add size if non-zero (derived types might be zero-sized.)
1088   if (Size && Tag != dwarf::DW_TAG_pointer_type)
1089     addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1090
1091   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1092     addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1093                 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1094   // Add source line info if available and TyDesc is not a forward declaration.
1095   if (!DTy.isForwardDecl())
1096     addSourceLine(&Buffer, DTy);
1097 }
1098
1099 /// Return true if the type is appropriately scoped to be contained inside
1100 /// its own type unit.
1101 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1102   DIScope Parent = DD->resolve(Ty.getContext());
1103   while (Parent) {
1104     // Don't generate a hash for anything scoped inside a function.
1105     if (Parent.isSubprogram())
1106       return false;
1107     Parent = DD->resolve(Parent.getContext());
1108   }
1109   return true;
1110 }
1111
1112 /// Return true if the type should be split out into a type unit.
1113 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1114   uint16_t Tag = CTy.getTag();
1115
1116   switch (Tag) {
1117   case dwarf::DW_TAG_structure_type:
1118   case dwarf::DW_TAG_union_type:
1119   case dwarf::DW_TAG_enumeration_type:
1120   case dwarf::DW_TAG_class_type:
1121     // If this is a class, structure, union, or enumeration type
1122     // that is a definition (not a declaration), and not scoped
1123     // inside a function then separate this out as a type unit.
1124     return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1125   default:
1126     return false;
1127   }
1128 }
1129
1130 /// constructTypeDIE - Construct type DIE from DICompositeType.
1131 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1132   // Get core information.
1133   StringRef Name = CTy.getName();
1134
1135   uint64_t Size = CTy.getSizeInBits() >> 3;
1136   uint16_t Tag = Buffer.getTag();
1137
1138   switch (Tag) {
1139   case dwarf::DW_TAG_array_type:
1140     constructArrayTypeDIE(Buffer, CTy);
1141     break;
1142   case dwarf::DW_TAG_enumeration_type:
1143     constructEnumTypeDIE(Buffer, CTy);
1144     break;
1145   case dwarf::DW_TAG_subroutine_type: {
1146     // Add return type. A void return won't have a type.
1147     DIArray Elements = CTy.getTypeArray();
1148     DIDescriptor RTy = Elements.getElement(0);
1149     if (RTy)
1150       addType(&Buffer, DIType(RTy));
1151
1152     bool isPrototyped = true;
1153     // Add arguments.
1154     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1155       DIDescriptor Ty = Elements.getElement(i);
1156       if (Ty.isUnspecifiedParameter()) {
1157         createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1158         isPrototyped = false;
1159       } else {
1160         DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1161         addType(Arg, DIType(Ty));
1162         if (DIType(Ty).isArtificial())
1163           addFlag(Arg, dwarf::DW_AT_artificial);
1164       }
1165     }
1166     // Add prototype flag if we're dealing with a C language and the
1167     // function has been prototyped.
1168     uint16_t Language = getLanguage();
1169     if (isPrototyped &&
1170         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1171          Language == dwarf::DW_LANG_ObjC))
1172       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1173   } break;
1174   case dwarf::DW_TAG_structure_type:
1175   case dwarf::DW_TAG_union_type:
1176   case dwarf::DW_TAG_class_type: {
1177     // Add elements to structure type.
1178     DIArray Elements = CTy.getTypeArray();
1179     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1180       DIDescriptor Element = Elements.getElement(i);
1181       DIE *ElemDie = NULL;
1182       if (Element.isSubprogram()) {
1183         DISubprogram SP(Element);
1184         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1185         if (SP.isProtected())
1186           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1187                   dwarf::DW_ACCESS_protected);
1188         else if (SP.isPrivate())
1189           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1190                   dwarf::DW_ACCESS_private);
1191         else
1192           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1193                   dwarf::DW_ACCESS_public);
1194         if (SP.isExplicit())
1195           addFlag(ElemDie, dwarf::DW_AT_explicit);
1196       } else if (Element.isDerivedType()) {
1197         DIDerivedType DDTy(Element);
1198         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1199           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1200           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1201                   dwarf::DW_AT_friend);
1202         } else if (DDTy.isStaticMember()) {
1203           getOrCreateStaticMemberDIE(DDTy);
1204         } else {
1205           constructMemberDIE(Buffer, DDTy);
1206         }
1207       } else if (Element.isObjCProperty()) {
1208         DIObjCProperty Property(Element);
1209         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1210         StringRef PropertyName = Property.getObjCPropertyName();
1211         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1212         addType(ElemDie, Property.getType());
1213         addSourceLine(ElemDie, Property);
1214         StringRef GetterName = Property.getObjCPropertyGetterName();
1215         if (!GetterName.empty())
1216           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1217         StringRef SetterName = Property.getObjCPropertySetterName();
1218         if (!SetterName.empty())
1219           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1220         unsigned PropertyAttributes = 0;
1221         if (Property.isReadOnlyObjCProperty())
1222           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1223         if (Property.isReadWriteObjCProperty())
1224           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1225         if (Property.isAssignObjCProperty())
1226           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1227         if (Property.isRetainObjCProperty())
1228           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1229         if (Property.isCopyObjCProperty())
1230           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1231         if (Property.isNonAtomicObjCProperty())
1232           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1233         if (PropertyAttributes)
1234           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1235                   PropertyAttributes);
1236
1237         DIEEntry *Entry = getDIEEntry(Element);
1238         if (!Entry) {
1239           Entry = createDIEEntry(ElemDie);
1240           insertDIEEntry(Element, Entry);
1241         }
1242       } else
1243         continue;
1244     }
1245
1246     if (CTy.isAppleBlockExtension())
1247       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1248
1249     DICompositeType ContainingType(resolve(CTy.getContainingType()));
1250     if (DIDescriptor(ContainingType).isCompositeType())
1251       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1252                   getOrCreateTypeDIE(DIType(ContainingType)));
1253
1254     if (CTy.isObjcClassComplete())
1255       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1256
1257     // Add template parameters to a class, structure or union types.
1258     // FIXME: The support isn't in the metadata for this yet.
1259     if (Tag == dwarf::DW_TAG_class_type ||
1260         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1261       addTemplateParams(Buffer, CTy.getTemplateParams());
1262
1263     break;
1264   }
1265   default:
1266     break;
1267   }
1268
1269   // Add name if not anonymous or intermediate type.
1270   if (!Name.empty())
1271     addString(&Buffer, dwarf::DW_AT_name, Name);
1272
1273   if (Tag == dwarf::DW_TAG_enumeration_type ||
1274       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1275       Tag == dwarf::DW_TAG_union_type) {
1276     // Add size if non-zero (derived types might be zero-sized.)
1277     // TODO: Do we care about size for enum forward declarations?
1278     if (Size)
1279       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1280     else if (!CTy.isForwardDecl())
1281       // Add zero size if it is not a forward declaration.
1282       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1283
1284     // If we're a forward decl, say so.
1285     if (CTy.isForwardDecl())
1286       addFlag(&Buffer, dwarf::DW_AT_declaration);
1287
1288     // Add source line info if available.
1289     if (!CTy.isForwardDecl())
1290       addSourceLine(&Buffer, CTy);
1291
1292     // No harm in adding the runtime language to the declaration.
1293     unsigned RLang = CTy.getRunTimeLang();
1294     if (RLang)
1295       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1296               RLang);
1297   }
1298   // If this is a type applicable to a type unit it then add it to the
1299   // list of types we'll compute a hash for later.
1300   if (shouldCreateTypeUnit(CTy, DD))
1301     DD->addTypeUnitType(&Buffer);
1302 }
1303
1304 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1305 /// DITemplateTypeParameter.
1306 void
1307 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1308                                                DITemplateTypeParameter TP) {
1309   DIE *ParamDIE =
1310       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1311   // Add the type if it exists, it could be void and therefore no type.
1312   if (TP.getType())
1313     addType(ParamDIE, resolve(TP.getType()));
1314   if (!TP.getName().empty())
1315     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1316 }
1317
1318 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1319 /// DITemplateValueParameter.
1320 void
1321 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1322                                                 DITemplateValueParameter VP) {
1323   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1324
1325   // Add the type if there is one, template template and template parameter
1326   // packs will not have a type.
1327   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1328     addType(ParamDIE, resolve(VP.getType()));
1329   if (!VP.getName().empty())
1330     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1331   if (Value *Val = VP.getValue()) {
1332     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1333       addConstantValue(ParamDIE, CI,
1334                        isUnsignedDIType(DD, resolve(VP.getType())));
1335     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1336       // For declaration non-type template parameters (such as global values and
1337       // functions)
1338       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1339       addOpAddress(Block, Asm->getSymbol(GV));
1340       // Emit DW_OP_stack_value to use the address as the immediate value of the
1341       // parameter, rather than a pointer to it.
1342       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1343       addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1344     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1345       assert(isa<MDString>(Val));
1346       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1347                 cast<MDString>(Val)->getString());
1348     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1349       assert(isa<MDNode>(Val));
1350       DIArray A(cast<MDNode>(Val));
1351       addTemplateParams(*ParamDIE, A);
1352     }
1353   }
1354 }
1355
1356 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1357 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1358   // Construct the context before querying for the existence of the DIE in case
1359   // such construction creates the DIE.
1360   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1361
1362   DIE *NDie = getDIE(NS);
1363   if (NDie)
1364     return NDie;
1365   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1366
1367   if (!NS.getName().empty()) {
1368     addString(NDie, dwarf::DW_AT_name, NS.getName());
1369     addAccelNamespace(NS.getName(), NDie);
1370     addGlobalName(NS.getName(), NDie, NS.getContext());
1371   } else
1372     addAccelNamespace("(anonymous namespace)", NDie);
1373   addSourceLine(NDie, NS);
1374   return NDie;
1375 }
1376
1377 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1378 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1379   // Construct the context before querying for the existence of the DIE in case
1380   // such construction creates the DIE (as is the case for member function
1381   // declarations).
1382   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1383
1384   DIE *SPDie = getDIE(SP);
1385   if (SPDie)
1386     return SPDie;
1387
1388   DISubprogram SPDecl = SP.getFunctionDeclaration();
1389   if (SPDecl.isSubprogram())
1390     // Add subprogram definitions to the CU die directly.
1391     ContextDIE = CUDie.get();
1392
1393   // DW_TAG_inlined_subroutine may refer to this DIE.
1394   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1395
1396   DIE *DeclDie = NULL;
1397   if (SPDecl.isSubprogram())
1398     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1399
1400   // Add function template parameters.
1401   addTemplateParams(*SPDie, SP.getTemplateParams());
1402
1403   // If this DIE is going to refer declaration info using AT_specification
1404   // then there is no need to add other attributes.
1405   if (DeclDie) {
1406     // Refer function declaration directly.
1407     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1408
1409     return SPDie;
1410   }
1411
1412   // Add the linkage name if we have one.
1413   StringRef LinkageName = SP.getLinkageName();
1414   if (!LinkageName.empty())
1415     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1416               GlobalValue::getRealLinkageName(LinkageName));
1417
1418   // Constructors and operators for anonymous aggregates do not have names.
1419   if (!SP.getName().empty())
1420     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1421
1422   addSourceLine(SPDie, SP);
1423
1424   // Add the prototype if we have a prototype and we have a C like
1425   // language.
1426   uint16_t Language = getLanguage();
1427   if (SP.isPrototyped() &&
1428       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1429        Language == dwarf::DW_LANG_ObjC))
1430     addFlag(SPDie, dwarf::DW_AT_prototyped);
1431
1432   DICompositeType SPTy = SP.getType();
1433   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1434          "the type of a subprogram should be a subroutine");
1435
1436   DIArray Args = SPTy.getTypeArray();
1437   // Add a return type. If this is a type like a C/C++ void type we don't add a
1438   // return type.
1439   if (Args.getElement(0))
1440     addType(SPDie, DIType(Args.getElement(0)));
1441
1442   unsigned VK = SP.getVirtuality();
1443   if (VK) {
1444     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1445     DIEBlock *Block = getDIEBlock();
1446     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1447     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1448     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1449     ContainingTypeMap.insert(
1450         std::make_pair(SPDie, resolve(SP.getContainingType())));
1451   }
1452
1453   if (!SP.isDefinition()) {
1454     addFlag(SPDie, dwarf::DW_AT_declaration);
1455
1456     // Add arguments. Do not add arguments for subprogram definition. They will
1457     // be handled while processing variables.
1458     for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1459       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1460       DIType ATy = DIType(Args.getElement(i));
1461       addType(Arg, ATy);
1462       if (ATy.isArtificial())
1463         addFlag(Arg, dwarf::DW_AT_artificial);
1464     }
1465   }
1466
1467   if (SP.isArtificial())
1468     addFlag(SPDie, dwarf::DW_AT_artificial);
1469
1470   if (!SP.isLocalToUnit())
1471     addFlag(SPDie, dwarf::DW_AT_external);
1472
1473   if (SP.isOptimized())
1474     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1475
1476   if (unsigned isa = Asm->getISAEncoding()) {
1477     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1478   }
1479
1480   return SPDie;
1481 }
1482
1483 // Return const expression if value is a GEP to access merged global
1484 // constant. e.g.
1485 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1486 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1487   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1488   if (!CE || CE->getNumOperands() != 3 ||
1489       CE->getOpcode() != Instruction::GetElementPtr)
1490     return NULL;
1491
1492   // First operand points to a global struct.
1493   Value *Ptr = CE->getOperand(0);
1494   if (!isa<GlobalValue>(Ptr) ||
1495       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1496     return NULL;
1497
1498   // Second operand is zero.
1499   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1500   if (!CI || !CI->isZero())
1501     return NULL;
1502
1503   // Third operand is offset.
1504   if (!isa<ConstantInt>(CE->getOperand(2)))
1505     return NULL;
1506
1507   return CE;
1508 }
1509
1510 /// createGlobalVariableDIE - create global variable DIE.
1511 void CompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1512
1513   // Check for pre-existence.
1514   if (getDIE(GV))
1515     return;
1516
1517   if (!GV.isGlobalVariable())
1518     return;
1519
1520   DIScope GVContext = GV.getContext();
1521   DIType GTy = GV.getType();
1522
1523   // If this is a static data member definition, some attributes belong
1524   // to the declaration DIE.
1525   DIE *VariableDIE = NULL;
1526   bool IsStaticMember = false;
1527   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1528   if (SDMDecl.Verify()) {
1529     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1530     // We need the declaration DIE that is in the static member's class.
1531     VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1532     IsStaticMember = true;
1533   }
1534
1535   // If this is not a static data member definition, create the variable
1536   // DIE and add the initial set of attributes to it.
1537   if (!VariableDIE) {
1538     // Construct the context before querying for the existence of the DIE in
1539     // case such construction creates the DIE.
1540     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1541
1542     // Add to map.
1543     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1544
1545     // Add name and type.
1546     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1547     addType(VariableDIE, GTy);
1548
1549     // Add scoping info.
1550     if (!GV.isLocalToUnit())
1551       addFlag(VariableDIE, dwarf::DW_AT_external);
1552
1553     // Add line number info.
1554     addSourceLine(VariableDIE, GV);
1555   }
1556
1557   // Add location.
1558   bool addToAccelTable = false;
1559   DIE *VariableSpecDIE = NULL;
1560   bool isGlobalVariable = GV.getGlobal() != NULL;
1561   if (isGlobalVariable) {
1562     addToAccelTable = true;
1563     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1564     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1565     if (GV.getGlobal()->isThreadLocal()) {
1566       // FIXME: Make this work with -gsplit-dwarf.
1567       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1568       assert((PointerSize == 4 || PointerSize == 8) &&
1569              "Add support for other sizes if necessary");
1570       const MCExpr *Expr =
1571           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1572       // Based on GCC's support for TLS:
1573       if (!DD->useSplitDwarf()) {
1574         // 1) Start with a constNu of the appropriate pointer size
1575         addUInt(Block, dwarf::DW_FORM_data1,
1576                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1577         // 2) containing the (relocated) offset of the TLS variable
1578         //    within the module's TLS block.
1579         addExpr(Block, dwarf::DW_FORM_udata, Expr);
1580       } else {
1581         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1582         addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1583       }
1584       // 3) followed by a custom OP to make the debugger do a TLS lookup.
1585       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1586     } else
1587       addOpAddress(Block, Sym);
1588     // Do not create specification DIE if context is either compile unit
1589     // or a subprogram.
1590     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1591         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1592       // Create specification DIE.
1593       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie);
1594       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1595       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1596       // A static member's declaration is already flagged as such.
1597       if (!SDMDecl.Verify())
1598         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1599     } else {
1600       addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1601     }
1602     // Add the linkage name.
1603     StringRef LinkageName = GV.getLinkageName();
1604     if (!LinkageName.empty())
1605       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1606       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1607       // TAG_variable.
1608       addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1609                                                   : VariableDIE,
1610                 dwarf::DW_AT_MIPS_linkage_name,
1611                 GlobalValue::getRealLinkageName(LinkageName));
1612   } else if (const ConstantInt *CI =
1613                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1614     // AT_const_value was added when the static member was created. To avoid
1615     // emitting AT_const_value multiple times, we only add AT_const_value when
1616     // it is not a static member.
1617     if (!IsStaticMember)
1618       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1619   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1620     addToAccelTable = true;
1621     // GV is a merged global.
1622     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1623     Value *Ptr = CE->getOperand(0);
1624     addOpAddress(Block, Asm->getSymbol(cast<GlobalValue>(Ptr)));
1625     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1626     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1627     addUInt(Block, dwarf::DW_FORM_udata,
1628             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1629     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1630     addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1631   }
1632
1633   if (addToAccelTable) {
1634     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1635     addAccelName(GV.getName(), AddrDIE);
1636
1637     // If the linkage name is different than the name, go ahead and output
1638     // that as well into the name table.
1639     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1640       addAccelName(GV.getLinkageName(), AddrDIE);
1641   }
1642
1643   if (!GV.isLocalToUnit())
1644     addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1645                   GV.getContext());
1646 }
1647
1648 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1649 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1650                                        DIE *IndexTy) {
1651   DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1652   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1653
1654   // The LowerBound value defines the lower bounds which is typically zero for
1655   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1656   // Count == -1 then the array is unbounded and we do not emit
1657   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1658   // Count == 0, then the array has zero elements in which case we do not emit
1659   // an upper bound.
1660   int64_t LowerBound = SR.getLo();
1661   int64_t DefaultLowerBound = getDefaultLowerBound();
1662   int64_t Count = SR.getCount();
1663
1664   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1665     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1666
1667   if (Count != -1 && Count != 0)
1668     // FIXME: An unbounded array should reference the expression that defines
1669     // the array.
1670     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1671             LowerBound + Count - 1);
1672 }
1673
1674 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1675 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1676   if (CTy.isVector())
1677     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1678
1679   // Emit the element type.
1680   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1681
1682   // Get an anonymous type for index type.
1683   // FIXME: This type should be passed down from the front end
1684   // as different languages may have different sizes for indexes.
1685   DIE *IdxTy = getIndexTyDie();
1686   if (!IdxTy) {
1687     // Construct an anonymous type for index type.
1688     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
1689     addString(IdxTy, dwarf::DW_AT_name, "int");
1690     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1691     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1692             dwarf::DW_ATE_signed);
1693     setIndexTyDie(IdxTy);
1694   }
1695
1696   // Add subranges to array type.
1697   DIArray Elements = CTy.getTypeArray();
1698   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1699     DIDescriptor Element = Elements.getElement(i);
1700     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1701       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1702   }
1703 }
1704
1705 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1706 void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1707   DIArray Elements = CTy.getTypeArray();
1708
1709   // Add enumerators to enumeration type.
1710   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1711     DIDescriptor Enum(Elements.getElement(i));
1712     DIEnumerator ETy = DIEnumerator(Enum);
1713     if (Enum.isEnumerator()) {
1714       DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1715       StringRef Name = ETy.getName();
1716       addString(Enumerator, dwarf::DW_AT_name, Name);
1717       int64_t Value = ETy.getEnumValue();
1718       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1719     }
1720   }
1721   DIType DTy = resolve(CTy.getTypeDerivedFrom());
1722   if (DTy) {
1723     addType(&Buffer, DTy);
1724     addFlag(&Buffer, dwarf::DW_AT_enum_class);
1725   }
1726 }
1727
1728 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1729 /// vtables.
1730 void CompileUnit::constructContainingTypeDIEs() {
1731   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1732                                                  CE = ContainingTypeMap.end();
1733        CI != CE; ++CI) {
1734     DIE *SPDie = CI->first;
1735     DIDescriptor D(CI->second);
1736     if (!D)
1737       continue;
1738     DIE *NDie = getDIE(D);
1739     if (!NDie)
1740       continue;
1741     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1742   }
1743 }
1744
1745 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1746 DIE *CompileUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1747   StringRef Name = DV.getName();
1748
1749   // Define variable debug information entry.
1750   DIE *VariableDie = new DIE(DV.getTag());
1751   DbgVariable *AbsVar = DV.getAbstractVariable();
1752   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1753   if (AbsDIE)
1754     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1755   else {
1756     if (!Name.empty())
1757       addString(VariableDie, dwarf::DW_AT_name, Name);
1758     addSourceLine(VariableDie, DV.getVariable());
1759     addType(VariableDie, DV.getType());
1760   }
1761
1762   if (DV.isArtificial())
1763     addFlag(VariableDie, dwarf::DW_AT_artificial);
1764
1765   if (isScopeAbstract) {
1766     DV.setDIE(VariableDie);
1767     return VariableDie;
1768   }
1769
1770   // Add variable address.
1771
1772   unsigned Offset = DV.getDotDebugLocOffset();
1773   if (Offset != ~0U) {
1774     addLabel(VariableDie, dwarf::DW_AT_location,
1775              DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1776                                         : dwarf::DW_FORM_data4,
1777              Asm->GetTempSymbol("debug_loc", Offset));
1778     DV.setDIE(VariableDie);
1779     return VariableDie;
1780   }
1781
1782   // Check if variable is described by a DBG_VALUE instruction.
1783   if (const MachineInstr *DVInsn = DV.getMInsn()) {
1784     assert(DVInsn->getNumOperands() == 3);
1785     if (DVInsn->getOperand(0).isReg()) {
1786       const MachineOperand RegOp = DVInsn->getOperand(0);
1787       // If the second operand is an immediate, this is an indirect value.
1788       if (DVInsn->getOperand(1).isImm()) {
1789         MachineLocation Location(RegOp.getReg(),
1790                                  DVInsn->getOperand(1).getImm());
1791         addVariableAddress(DV, VariableDie, Location);
1792       } else if (RegOp.getReg())
1793         addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1794     } else if (DVInsn->getOperand(0).isImm())
1795       addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1796     else if (DVInsn->getOperand(0).isFPImm())
1797       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1798     else if (DVInsn->getOperand(0).isCImm())
1799       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1800                        isUnsignedDIType(DD, DV.getType()));
1801
1802     DV.setDIE(VariableDie);
1803     return VariableDie;
1804   } else {
1805     // .. else use frame index.
1806     int FI = DV.getFrameIndex();
1807     if (FI != ~0) {
1808       unsigned FrameReg = 0;
1809       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1810       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1811       MachineLocation Location(FrameReg, Offset);
1812       addVariableAddress(DV, VariableDie, Location);
1813     }
1814   }
1815
1816   DV.setDIE(VariableDie);
1817   return VariableDie;
1818 }
1819
1820 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1821 void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1822   DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1823   StringRef Name = DT.getName();
1824   if (!Name.empty())
1825     addString(MemberDie, dwarf::DW_AT_name, Name);
1826
1827   addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1828
1829   addSourceLine(MemberDie, DT);
1830
1831   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1832   addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1833
1834   if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1835
1836     // For C++, virtual base classes are not at fixed offset. Use following
1837     // expression to extract appropriate offset from vtable.
1838     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1839
1840     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1841     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1842     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1843     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1844     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1845     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1846     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1847     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1848
1849     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1850   } else {
1851     uint64_t Size = DT.getSizeInBits();
1852     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1853     uint64_t OffsetInBytes;
1854
1855     if (Size != FieldSize) {
1856       // Handle bitfield.
1857       addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1858               getBaseTypeSize(DD, DT) >> 3);
1859       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1860
1861       uint64_t Offset = DT.getOffsetInBits();
1862       uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1863       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1864       uint64_t FieldOffset = (HiMark - FieldSize);
1865       Offset -= FieldOffset;
1866
1867       // Maybe we need to work from the other end.
1868       if (Asm->getDataLayout().isLittleEndian())
1869         Offset = FieldSize - (Offset + Size);
1870       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1871
1872       // Here WD_AT_data_member_location points to the anonymous
1873       // field that includes this bit field.
1874       OffsetInBytes = FieldOffset >> 3;
1875     } else
1876       // This is not a bitfield.
1877       OffsetInBytes = DT.getOffsetInBits() >> 3;
1878     addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1879   }
1880
1881   if (DT.isProtected())
1882     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1883             dwarf::DW_ACCESS_protected);
1884   else if (DT.isPrivate())
1885     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1886             dwarf::DW_ACCESS_private);
1887   // Otherwise C++ member and base classes are considered public.
1888   else
1889     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1890             dwarf::DW_ACCESS_public);
1891   if (DT.isVirtual())
1892     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1893             dwarf::DW_VIRTUALITY_virtual);
1894
1895   // Objective-C properties.
1896   if (MDNode *PNode = DT.getObjCProperty())
1897     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1898       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1899                           PropertyDie);
1900
1901   if (DT.isArtificial())
1902     addFlag(MemberDie, dwarf::DW_AT_artificial);
1903 }
1904
1905 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1906 DIE *CompileUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1907   if (!DT.Verify())
1908     return NULL;
1909
1910   // Construct the context before querying for the existence of the DIE in case
1911   // such construction creates the DIE.
1912   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1913   assert(dwarf::isType(ContextDIE->getTag()) &&
1914          "Static member should belong to a type.");
1915
1916   DIE *StaticMemberDIE = getDIE(DT);
1917   if (StaticMemberDIE)
1918     return StaticMemberDIE;
1919
1920   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1921
1922   DIType Ty = resolve(DT.getTypeDerivedFrom());
1923
1924   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1925   addType(StaticMemberDIE, Ty);
1926   addSourceLine(StaticMemberDIE, DT);
1927   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1928   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1929
1930   // FIXME: We could omit private if the parent is a class_type, and
1931   // public if the parent is something else.
1932   if (DT.isProtected())
1933     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1934             dwarf::DW_ACCESS_protected);
1935   else if (DT.isPrivate())
1936     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1937             dwarf::DW_ACCESS_private);
1938   else
1939     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1940             dwarf::DW_ACCESS_public);
1941
1942   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1943     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1944   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1945     addConstantFPValue(StaticMemberDIE, CFP);
1946
1947   return StaticMemberDIE;
1948 }
1949
1950 void CompileUnit::emitHeader(const MCSection *ASection,
1951                              const MCSymbol *ASectionSym) {
1952   Asm->OutStreamer.AddComment("DWARF version number");
1953   Asm->EmitInt16(DD->getDwarfVersion());
1954   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1955   Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1956                          ASectionSym);
1957   Asm->OutStreamer.AddComment("Address Size (in bytes)");
1958   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1959 }