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