lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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