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