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