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