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