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