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       // From dwarf-4: DIE to which DW_AT_linkage_name may apply include:
1353       // TAG_commono_block, TAG_constant, TAG_entry_point, TAG_subporgram and
1354       // TAG_variable. For static member variables, gcc 4.7 puts
1355       // MIPS_linkage_name on the definition DIE only, but Darwin gdb needs
1356       // MIPS_linkage_name at both places.
1357       // Per discussion with Eric, for static member variables, we put
1358       // MIPS_linkage_name on the definition DIE (TAG_variable) and conditionaly
1359       // put MIPS_linkage_name on TAG_member when DarwinGDBCompat is on.
1360       addString(IsStaticMember && VariableSpecDIE ?
1361                 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1362                 getRealLinkageName(LinkageName));
1363       if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat())
1364         addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1365                   getRealLinkageName(LinkageName));
1366     }
1367   } else if (const ConstantInt *CI =
1368              dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1369     // AT_const_value was added when the static memeber was created. To avoid
1370     // emitting AT_const_value multiple times, we only add AT_const_value when
1371     // it is not a static member.
1372     if (!IsStaticMember)
1373       addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1374   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1375     addToAccelTable = true;
1376     // GV is a merged global.
1377     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1378     Value *Ptr = CE->getOperand(0);
1379     addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1380     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1381     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1382     addUInt(Block, 0, dwarf::DW_FORM_udata,
1383                    Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1384     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1385     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1386   }
1387
1388   if (addToAccelTable) {
1389     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1390     addAccelName(GV.getName(), AddrDIE);
1391
1392     // If the linkage name is different than the name, go ahead and output
1393     // that as well into the name table.
1394     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1395       addAccelName(GV.getLinkageName(), AddrDIE);
1396   }
1397
1398   return;
1399 }
1400
1401 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1402 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1403                                        DIE *IndexTy) {
1404   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1405   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1406
1407   // The LowerBound value defines the lower bounds which is typically zero for
1408   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1409   // Count == -1 then the array is unbounded and we do not emit
1410   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1411   // Count == 0, then the array has zero elements in which case we do not emit
1412   // an upper bound.
1413   int64_t LowerBound = SR.getLo();
1414   int64_t DefaultLowerBound = getDefaultLowerBound();
1415   int64_t Count = SR.getCount();
1416
1417   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1418     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1419
1420   if (Count != -1 && Count != 0)
1421     // FIXME: An unbounded array should reference the expression that defines
1422     // the array.
1423     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1424
1425   Buffer.addChild(DW_Subrange);
1426 }
1427
1428 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1429 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1430                                         DICompositeType *CTy) {
1431   Buffer.setTag(dwarf::DW_TAG_array_type);
1432   if (CTy->isVector())
1433     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1434
1435   // Emit derived type.
1436   addType(&Buffer, CTy->getTypeDerivedFrom());
1437   DIArray Elements = CTy->getTypeArray();
1438
1439   // Get an anonymous type for index type.
1440   // FIXME: This type should be passed down from the front end
1441   // as different languages may have different sizes for indexes.
1442   DIE *IdxTy = getIndexTyDie();
1443   if (!IdxTy) {
1444     // Construct an anonymous type for index type.
1445     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1446     addString(IdxTy, dwarf::DW_AT_name, "int");
1447     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1448     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1449             dwarf::DW_ATE_signed);
1450     addDie(IdxTy);
1451     setIndexTyDie(IdxTy);
1452   }
1453
1454   // Add subranges to array type.
1455   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1456     DIDescriptor Element = Elements.getElement(i);
1457     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1458       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1459   }
1460 }
1461
1462 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1463 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1464   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1465   StringRef Name = ETy.getName();
1466   addString(Enumerator, dwarf::DW_AT_name, Name);
1467   int64_t Value = ETy.getEnumValue();
1468   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1469   return Enumerator;
1470 }
1471
1472 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1473 /// vtables.
1474 void CompileUnit::constructContainingTypeDIEs() {
1475   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1476          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1477     DIE *SPDie = CI->first;
1478     const MDNode *N = CI->second;
1479     if (!N) continue;
1480     DIE *NDie = getDIE(N);
1481     if (!NDie) continue;
1482     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1483   }
1484 }
1485
1486 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1487 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1488   StringRef Name = DV->getName();
1489
1490   // Translate tag to proper Dwarf tag.
1491   unsigned Tag = DV->getTag();
1492
1493   // Define variable debug information entry.
1494   DIE *VariableDie = new DIE(Tag);
1495   DbgVariable *AbsVar = DV->getAbstractVariable();
1496   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1497   if (AbsDIE)
1498     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1499                             dwarf::DW_FORM_ref4, AbsDIE);
1500   else {
1501     addString(VariableDie, dwarf::DW_AT_name, Name);
1502     addSourceLine(VariableDie, DV->getVariable());
1503     addType(VariableDie, DV->getType());
1504   }
1505
1506   if (DV->isArtificial())
1507     addFlag(VariableDie, dwarf::DW_AT_artificial);
1508
1509   if (isScopeAbstract) {
1510     DV->setDIE(VariableDie);
1511     return VariableDie;
1512   }
1513
1514   // Add variable address.
1515
1516   unsigned Offset = DV->getDotDebugLocOffset();
1517   if (Offset != ~0U) {
1518     addLabel(VariableDie, dwarf::DW_AT_location,
1519                          dwarf::DW_FORM_data4,
1520                          Asm->GetTempSymbol("debug_loc", Offset));
1521     DV->setDIE(VariableDie);
1522     return VariableDie;
1523   }
1524
1525   // Check if variable is described by a DBG_VALUE instruction.
1526   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1527     bool updated = false;
1528     if (DVInsn->getNumOperands() == 3) {
1529       if (DVInsn->getOperand(0).isReg()) {
1530         const MachineOperand RegOp = DVInsn->getOperand(0);
1531         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1532         if (DVInsn->getOperand(1).isImm() &&
1533             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1534           unsigned FrameReg = 0;
1535           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1536           int Offset =
1537             TFI->getFrameIndexReference(*Asm->MF,
1538                                         DVInsn->getOperand(1).getImm(),
1539                                         FrameReg);
1540           MachineLocation Location(FrameReg, Offset);
1541           addVariableAddress(DV, VariableDie, Location);
1542
1543         } else if (RegOp.getReg())
1544           addVariableAddress(DV, VariableDie,
1545                                          MachineLocation(RegOp.getReg()));
1546         updated = true;
1547       }
1548       else if (DVInsn->getOperand(0).isImm())
1549         updated =
1550           addConstantValue(VariableDie, DVInsn->getOperand(0),
1551                                        DV->getType());
1552       else if (DVInsn->getOperand(0).isFPImm())
1553         updated =
1554           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1555       else if (DVInsn->getOperand(0).isCImm())
1556         updated =
1557           addConstantValue(VariableDie,
1558                                        DVInsn->getOperand(0).getCImm(),
1559                                        DV->getType().isUnsignedDIType());
1560     } else {
1561       addVariableAddress(DV, VariableDie,
1562                                      Asm->getDebugValueLocation(DVInsn));
1563       updated = true;
1564     }
1565     if (!updated) {
1566       // If variableDie is not updated then DBG_VALUE instruction does not
1567       // have valid variable info.
1568       delete VariableDie;
1569       return NULL;
1570     }
1571     DV->setDIE(VariableDie);
1572     return VariableDie;
1573   } else {
1574     // .. else use frame index.
1575     int FI = DV->getFrameIndex();
1576     if (FI != ~0) {
1577       unsigned FrameReg = 0;
1578       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1579       int Offset =
1580         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1581       MachineLocation Location(FrameReg, Offset);
1582       addVariableAddress(DV, VariableDie, Location);
1583     }
1584   }
1585
1586   DV->setDIE(VariableDie);
1587   return VariableDie;
1588 }
1589
1590 /// createMemberDIE - Create new member DIE.
1591 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1592   DIE *MemberDie = new DIE(DT.getTag());
1593   StringRef Name = DT.getName();
1594   if (!Name.empty())
1595     addString(MemberDie, dwarf::DW_AT_name, Name);
1596
1597   addType(MemberDie, DT.getTypeDerivedFrom());
1598
1599   addSourceLine(MemberDie, DT);
1600
1601   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1602   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1603
1604   uint64_t Size = DT.getSizeInBits();
1605   uint64_t FieldSize = DT.getOriginalTypeSize();
1606
1607   if (Size != FieldSize) {
1608     // Handle bitfield.
1609     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1610     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1611
1612     uint64_t Offset = DT.getOffsetInBits();
1613     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1614     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1615     uint64_t FieldOffset = (HiMark - FieldSize);
1616     Offset -= FieldOffset;
1617
1618     // Maybe we need to work from the other end.
1619     if (Asm->getDataLayout().isLittleEndian())
1620       Offset = FieldSize - (Offset + Size);
1621     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1622
1623     // Here WD_AT_data_member_location points to the anonymous
1624     // field that includes this bit field.
1625     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1626
1627   } else
1628     // This is not a bitfield.
1629     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1630
1631   if (DT.getTag() == dwarf::DW_TAG_inheritance
1632       && DT.isVirtual()) {
1633
1634     // For C++, virtual base classes are not at fixed offset. Use following
1635     // expression to extract appropriate offset from vtable.
1636     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1637
1638     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1639     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1640     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1641     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1642     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1643     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1644     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1645     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1646
1647     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1648              VBaseLocationDie);
1649   } else
1650     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1651
1652   if (DT.isProtected())
1653     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1654             dwarf::DW_ACCESS_protected);
1655   else if (DT.isPrivate())
1656     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1657             dwarf::DW_ACCESS_private);
1658   // Otherwise C++ member and base classes are considered public.
1659   else
1660     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1661             dwarf::DW_ACCESS_public);
1662   if (DT.isVirtual())
1663     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1664             dwarf::DW_VIRTUALITY_virtual);
1665
1666   // Objective-C properties.
1667   if (MDNode *PNode = DT.getObjCProperty())
1668     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1669       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1670                           PropertyDie);
1671
1672   if (DT.isArtificial())
1673     addFlag(MemberDie, dwarf::DW_AT_artificial);
1674
1675   // This is only for backward compatibility.
1676   StringRef PropertyName = DT.getObjCPropertyName();
1677   if (!PropertyName.empty()) {
1678     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1679     StringRef GetterName = DT.getObjCPropertyGetterName();
1680     if (!GetterName.empty())
1681       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1682     StringRef SetterName = DT.getObjCPropertySetterName();
1683     if (!SetterName.empty())
1684       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1685     unsigned PropertyAttributes = 0;
1686     if (DT.isReadOnlyObjCProperty())
1687       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1688     if (DT.isReadWriteObjCProperty())
1689       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1690     if (DT.isAssignObjCProperty())
1691       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1692     if (DT.isRetainObjCProperty())
1693       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1694     if (DT.isCopyObjCProperty())
1695       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1696     if (DT.isNonAtomicObjCProperty())
1697       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1698     if (PropertyAttributes)
1699       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1700               PropertyAttributes);
1701   }
1702   return MemberDie;
1703 }
1704
1705 /// createStaticMemberDIE - Create new DIE for C++ static member.
1706 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1707   if (!DT.Verify())
1708     return NULL;
1709
1710   DIE *StaticMemberDIE = new DIE(DT.getTag());
1711   DIType Ty = DT.getTypeDerivedFrom();
1712
1713   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1714   addType(StaticMemberDIE, Ty);
1715   addSourceLine(StaticMemberDIE, DT);
1716   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1717   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1718
1719   // FIXME: We could omit private if the parent is a class_type, and
1720   // public if the parent is something else.
1721   if (DT.isProtected())
1722     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1723             dwarf::DW_ACCESS_protected);
1724   else if (DT.isPrivate())
1725     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1726             dwarf::DW_ACCESS_private);
1727   else
1728     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1729             dwarf::DW_ACCESS_public);
1730
1731   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1732     addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1733   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1734     addConstantFPValue(StaticMemberDIE, CFP);
1735
1736   insertDIE(DT, StaticMemberDIE);
1737   return StaticMemberDIE;
1738 }