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