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   DD->addDIEEntry(Die, 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 = DD->resolve(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(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
 605   if (Ty.isDerivedType())
 606     return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
 607                         SizeInBits);
 608   if (Ty.isBasicType())
 609     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
 610         || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
 611       *SizeInBits = Ty.getSizeInBits();
 612       return true;
 613     }
 614   return false;
 615 }
 616
 617 /// Return true if type encoding is unsigned.
 618 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
 619   DIDerivedType DTy(Ty);
 620   if (DTy.isDerivedType())
 621     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
 622
 623   DIBasicType BTy(Ty);
 624   if (BTy.isBasicType()) {
 625     unsigned Encoding = BTy.getEncoding();
 626     if (Encoding == dwarf::DW_ATE_unsigned ||
 627         Encoding == dwarf::DW_ATE_unsigned_char ||
 628         Encoding == dwarf::DW_ATE_boolean)
 629       return true;
 630   }
 631   return false;
 632 }
 633
 634 /// If this type is derived from a base type then return base type size.
 635 static uint64_t getOriginalTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
 636   unsigned Tag = Ty.getTag();
 637
 638   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 639       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 640       Tag != dwarf::DW_TAG_restrict_type)
 641     return Ty.getSizeInBits();
 642
 643   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
 644
 645   // If this type is not derived from any type then take conservative approach.
 646   if (!BaseType.isValid())
 647     return Ty.getSizeInBits();
 648
 649   // If this is a derived type, go ahead and get the base type, unless it's a
 650   // reference then it's just the size of the field. Pointer types have no need
 651   // of this since they're a different type of qualification on the type.
 652   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
 653       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
 654     return Ty.getSizeInBits();
 655
 656   if (BaseType.isDerivedType())
 657     return getOriginalTypeSize(DD, DIDerivedType(BaseType));
 658
 659   return BaseType.getSizeInBits();
 660 }
 661
 662 /// addConstantValue - Add constant value entry in variable DIE.
 663 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
 664                                    DIType Ty) {
 665   // FIXME: This is a bit conservative/simple - it emits negative values at
 666   // their maximum bit width which is a bit unfortunate (& doesn't prefer
 667   // udata/sdata over dataN as suggested by the DWARF spec)
 668   assert(MO.isImm() && "Invalid machine operand!");
 669   int SizeInBits = -1;
 670   bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
 671   uint16_t Form;
 672
 673   // If we're a signed constant definitely use sdata.
 674   if (SignedConstant) {
 675     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
 676     return;
 677   }
 678
 679   // Else use data for now unless it's larger than we can deal with.
 680   switch (SizeInBits) {
 681   case 8:
 682     Form = dwarf::DW_FORM_data1;
 683     break;
 684   case 16:
 685     Form = dwarf::DW_FORM_data2;
 686     break;
 687   case 32:
 688     Form = dwarf::DW_FORM_data4;
 689     break;
 690   case 64:
 691     Form = dwarf::DW_FORM_data8;
 692     break;
 693   default:
 694     Form = dwarf::DW_FORM_udata;
 695     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
 696     return;
 697   }
 698   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
 699 }
 700
 701 /// addConstantFPValue - Add constant value entry in variable DIE.
 702 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
 703   assert (MO.isFPImm() && "Invalid machine operand!");
 704   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 705   APFloat FPImm = MO.getFPImm()->getValueAPF();
 706
 707   // Get the raw data form of the floating point.
 708   const APInt FltVal = FPImm.bitcastToAPInt();
 709   const char *FltPtr = (const char*)FltVal.getRawData();
 710
 711   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 712   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 713   int Incr = (LittleEndian ? 1 : -1);
 714   int Start = (LittleEndian ? 0 : NumBytes - 1);
 715   int Stop = (LittleEndian ? NumBytes : -1);
 716
 717   // Output the constant to DWARF one byte at a time.
 718   for (; Start != Stop; Start += Incr)
 719     addUInt(Block, 0, dwarf::DW_FORM_data1,
 720             (unsigned char)0xFF & FltPtr[Start]);
 721
 722   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 723 }
 724
 725 /// addConstantFPValue - Add constant value entry in variable DIE.
 726 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
 727   // Pass this down to addConstantValue as an unsigned bag of bits.
 728   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 729 }
 730
 731 /// addConstantValue - Add constant value entry in variable DIE.
 732 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
 733                                    bool Unsigned) {
 734   addConstantValue(Die, CI->getValue(), Unsigned);
 735 }
 736
 737 // addConstantValue - Add constant value entry in variable DIE.
 738 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
 739   unsigned CIBitWidth = Val.getBitWidth();
 740   if (CIBitWidth <= 64) {
 741     // If we're a signed constant definitely use sdata.
 742     if (!Unsigned) {
 743       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
 744               Val.getSExtValue());
 745       return;
 746     }
 747
 748     // Else use data for now unless it's larger than we can deal with.
 749     uint16_t Form;
 750     switch (CIBitWidth) {
 751     case 8:
 752       Form = dwarf::DW_FORM_data1;
 753       break;
 754     case 16:
 755       Form = dwarf::DW_FORM_data2;
 756       break;
 757     case 32:
 758       Form = dwarf::DW_FORM_data4;
 759       break;
 760     case 64:
 761       Form = dwarf::DW_FORM_data8;
 762       break;
 763     default:
 764       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 765               Val.getZExtValue());
 766       return;
 767     }
 768     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
 769     return;
 770   }
 771
 772   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 773
 774   // Get the raw data form of the large APInt.
 775   const uint64_t *Ptr64 = Val.getRawData();
 776
 777   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 778   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 779
 780   // Output the constant to DWARF one byte at a time.
 781   for (int i = 0; i < NumBytes; i++) {
 782     uint8_t c;
 783     if (LittleEndian)
 784       c = Ptr64[i / 8] >> (8 * (i & 7));
 785     else
 786       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 787     addUInt(Block, 0, dwarf::DW_FORM_data1, c);
 788   }
 789
 790   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 791 }
 792
 793 /// addTemplateParams - Add template parameters into buffer.
 794 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 795   // Add template parameters.
 796   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 797     DIDescriptor Element = TParams.getElement(i);
 798     if (Element.isTemplateTypeParameter())
 799       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 800                         DITemplateTypeParameter(Element)));
 801     else if (Element.isTemplateValueParameter())
 802       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 803                         DITemplateValueParameter(Element)));
 804   }
 805 }
 806
 807 /// getOrCreateContextDIE - Get context owner's DIE.
 808 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) {
 809   if (Context.isType())
 810     return getOrCreateTypeDIE(DIType(Context));
 811   else if (Context.isNameSpace())
 812     return getOrCreateNameSpace(DINameSpace(Context));
 813   else if (Context.isSubprogram())
 814     return getOrCreateSubprogramDIE(DISubprogram(Context));
 815   else
 816     return getDIE(Context);
 817 }
 818
 819 /// addToContextOwner - Add Die into the list of its context owner's children.
 820 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 821   if (DIE *ContextDIE = getOrCreateContextDIE(Context))
 822     ContextDIE->addChild(Die);
 823   else
 824     addDie(Die);
 825 }
 826
 827 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 828 /// given DIType.
 829 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 830   DIType Ty(TyNode);
 831   if (!Ty.isType())
 832     return NULL;
 833   DIE *TyDIE = DD->getTypeDIE(Ty);
 834   if (TyDIE)
 835     return TyDIE;
 836
 837   // Create new type.
 838   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 839   DD->insertTypeDIE(Ty, TyDIE);
 840   if (Ty.isBasicType())
 841     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 842   else if (Ty.isCompositeType())
 843     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 844   else {
 845     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 846     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 847   }
 848   // If this is a named finished type then include it in the list of types
 849   // for the accelerator tables.
 850   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 851     bool IsImplementation = 0;
 852     if (Ty.isCompositeType()) {
 853       DICompositeType CT(Ty);
 854       // A runtime language of 0 actually means C/C++ and that any
 855       // non-negative value is some version of Objective-C/C++.
 856       IsImplementation = (CT.getRunTimeLang() == 0) ||
 857         CT.isObjcClassComplete();
 858     }
 859     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 860     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
 861   }
 862
 863   addToContextOwner(TyDIE, DD->resolve(Ty.getContext()));
 864   return TyDIE;
 865 }
 866
 867 /// addType - Add a new type attribute to the specified entity.
 868 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
 869   assert(Ty && "Trying to add a type that doesn't exist?");
 870
 871   // Check for pre-existence.
 872   DIEEntry *Entry = getDIEEntry(Ty);
 873   // If it exists then use the existing value.
 874   if (Entry) {
 875     DD->addDIEEntry(Entity, Attribute, dwarf::DW_FORM_ref4, Entry);
 876     return;
 877   }
 878
 879   // Construct type.
 880   DIE *Buffer = getOrCreateTypeDIE(Ty);
 881
 882   // Set up proxy.
 883   Entry = createDIEEntry(Buffer);
 884   insertDIEEntry(Ty, Entry);
 885   DD->addDIEEntry(Entity, Attribute, dwarf::DW_FORM_ref4, Entry);
 886
 887   // If this is a complete composite type then include it in the
 888   // list of global types.
 889   addGlobalType(Ty);
 890 }
 891
 892 // Accelerator table mutators - add each name along with its companion
 893 // DIE to the proper table while ensuring that the name that we're going
 894 // to reference is in the string table. We do this since the names we
 895 // add may not only be identical to the names in the DIE.
 896 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
 897   DU->getStringPoolEntry(Name);
 898   std::vector<DIE *> &DIEs = AccelNames[Name];
 899   DIEs.push_back(Die);
 900 }
 901
 902 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
 903   DU->getStringPoolEntry(Name);
 904   std::vector<DIE *> &DIEs = AccelObjC[Name];
 905   DIEs.push_back(Die);
 906 }
 907
 908 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
 909   DU->getStringPoolEntry(Name);
 910   std::vector<DIE *> &DIEs = AccelNamespace[Name];
 911   DIEs.push_back(Die);
 912 }
 913
 914 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
 915   DU->getStringPoolEntry(Name);
 916   std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
 917   DIEs.push_back(Die);
 918 }
 919
 920 /// addGlobalName - Add a new global name to the compile unit.
 921 void CompileUnit::addGlobalName(StringRef Name, DIE *Die) {
 922   GlobalNames[Name] = Die;
 923 }
 924
 925 /// addGlobalType - Add a new global type to the compile unit.
 926 ///
 927 void CompileUnit::addGlobalType(DIType Ty) {
 928   DIDescriptor Context = DD->resolve(Ty.getContext());
 929   if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
 930       (!Context || Context.isCompileUnit() || Context.isFile() ||
 931        Context.isNameSpace()))
 932     if (DIEEntry *Entry = getDIEEntry(Ty))
 933       GlobalTypes[Ty.getName()] = Entry->getEntry();
 934 }
 935
 936 /// addPubTypes - Add type for pubtypes section.
 937 void CompileUnit::addPubTypes(DISubprogram SP) {
 938   DICompositeType SPTy = SP.getType();
 939   uint16_t SPTag = SPTy.getTag();
 940   if (SPTag != dwarf::DW_TAG_subroutine_type)
 941     return;
 942
 943   DIArray Args = SPTy.getTypeArray();
 944   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 945     DIType ATy(Args.getElement(i));
 946     if (!ATy.isType())
 947       continue;
 948     addGlobalType(ATy);
 949   }
 950 }
 951
 952 /// constructTypeDIE - Construct basic type die from DIBasicType.
 953 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 954   // Get core information.
 955   StringRef Name = BTy.getName();
 956   // Add name if not anonymous or intermediate type.
 957   if (!Name.empty())
 958     addString(&Buffer, dwarf::DW_AT_name, Name);
 959
 960   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 961     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 962     // An unspecified type only has a name attribute.
 963     return;
 964   }
 965
 966   Buffer.setTag(dwarf::DW_TAG_base_type);
 967   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 968           BTy.getEncoding());
 969
 970   uint64_t Size = BTy.getSizeInBits() >> 3;
 971   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 972 }
 973
 974 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 975 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 976   // Get core information.
 977   StringRef Name = DTy.getName();
 978   uint64_t Size = DTy.getSizeInBits() >> 3;
 979   uint16_t Tag = DTy.getTag();
 980
 981   // FIXME - Workaround for templates.
 982   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 983
 984   Buffer.setTag(Tag);
 985
 986   // Map to main type, void will not have a type.
 987   DIType FromTy = DD->resolve(DTy.getTypeDerivedFrom());
 988   if (FromTy)
 989     addType(&Buffer, FromTy);
 990
 991   // Add name if not anonymous or intermediate type.
 992   if (!Name.empty())
 993     addString(&Buffer, dwarf::DW_AT_name, Name);
 994
 995   // Add size if non-zero (derived types might be zero-sized.)
 996   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 997     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 998
 999   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1000       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1001                   getOrCreateTypeDIE(DD->resolve(DTy.getClassType())));
1002   // Add source line info if available and TyDesc is not a forward declaration.
1003   if (!DTy.isForwardDecl())
1004     addSourceLine(&Buffer, DTy);
1005 }
1006
1007 /// Return true if the type is appropriately scoped to be contained inside
1008 /// its own type unit.
1009 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1010   DIScope Parent = DD->resolve(Ty.getContext());
1011   while (Parent) {
1012     // Don't generate a hash for anything scoped inside a function.
1013     if (Parent.isSubprogram())
1014       return false;
1015     Parent = DD->resolve(Parent.getContext());
1016   }
1017   return true;
1018 }
1019
1020 /// Return true if the type should be split out into a type unit.
1021 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1022   uint16_t Tag = CTy.getTag();
1023
1024   switch (Tag) {
1025   case dwarf::DW_TAG_structure_type:
1026   case dwarf::DW_TAG_union_type:
1027   case dwarf::DW_TAG_enumeration_type:
1028   case dwarf::DW_TAG_class_type:
1029     // If this is a class, structure, union, or enumeration type
1030     // that is not a declaration, is a type definition, and not scoped
1031     // inside a function then separate this out as a type unit.
1032     if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy, DD))
1033       return 0;
1034     return 1;
1035   default:
1036     return 0;
1037   }
1038 }
1039
1040 /// constructTypeDIE - Construct type DIE from DICompositeType.
1041 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1042   // Get core information.
1043   StringRef Name = CTy.getName();
1044
1045   uint64_t Size = CTy.getSizeInBits() >> 3;
1046   uint16_t Tag = CTy.getTag();
1047   Buffer.setTag(Tag);
1048
1049   switch (Tag) {
1050   case dwarf::DW_TAG_array_type:
1051     constructArrayTypeDIE(Buffer, &CTy);
1052     break;
1053   case dwarf::DW_TAG_enumeration_type: {
1054     DIArray Elements = CTy.getTypeArray();
1055
1056     // Add enumerators to enumeration type.
1057     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1058       DIE *ElemDie = NULL;
1059       DIDescriptor Enum(Elements.getElement(i));
1060       if (Enum.isEnumerator()) {
1061         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1062         Buffer.addChild(ElemDie);
1063       }
1064     }
1065     DIType DTy = DD->resolve(CTy.getTypeDerivedFrom());
1066     if (DTy) {
1067       addType(&Buffer, DTy);
1068       addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
1069     }
1070   }
1071     break;
1072   case dwarf::DW_TAG_subroutine_type: {
1073     // Add return type. A void return won't have a type.
1074     DIArray Elements = CTy.getTypeArray();
1075     DIDescriptor RTy = Elements.getElement(0);
1076     if (RTy)
1077       addType(&Buffer, DIType(RTy));
1078
1079     bool isPrototyped = true;
1080     // Add arguments.
1081     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1082       DIDescriptor Ty = Elements.getElement(i);
1083       if (Ty.isUnspecifiedParameter()) {
1084         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1085         Buffer.addChild(Arg);
1086         isPrototyped = false;
1087       } else {
1088         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1089         addType(Arg, DIType(Ty));
1090         if (DIType(Ty).isArtificial())
1091           addFlag(Arg, dwarf::DW_AT_artificial);
1092         Buffer.addChild(Arg);
1093       }
1094     }
1095     // Add prototype flag if we're dealing with a C language and the
1096     // function has been prototyped.
1097     uint16_t Language = DICompileUnit(Node).getLanguage();
1098     if (isPrototyped &&
1099         (Language == dwarf::DW_LANG_C89 ||
1100          Language == dwarf::DW_LANG_C99 ||
1101          Language == dwarf::DW_LANG_ObjC))
1102       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1103   }
1104     break;
1105   case dwarf::DW_TAG_structure_type:
1106   case dwarf::DW_TAG_union_type:
1107   case dwarf::DW_TAG_class_type: {
1108     // Add elements to structure type.
1109     DIArray Elements = CTy.getTypeArray();
1110     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1111       DIDescriptor Element = Elements.getElement(i);
1112       DIE *ElemDie = NULL;
1113       if (Element.isSubprogram()) {
1114         DISubprogram SP(Element);
1115         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1116         if (SP.isProtected())
1117           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1118                   dwarf::DW_ACCESS_protected);
1119         else if (SP.isPrivate())
1120           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1121                   dwarf::DW_ACCESS_private);
1122         else
1123           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1124             dwarf::DW_ACCESS_public);
1125         if (SP.isExplicit())
1126           addFlag(ElemDie, dwarf::DW_AT_explicit);
1127       } else if (Element.isDerivedType()) {
1128         DIDerivedType DDTy(Element);
1129         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1130           ElemDie = new DIE(dwarf::DW_TAG_friend);
1131           addType(ElemDie, DD->resolve(DDTy.getTypeDerivedFrom()),
1132                   dwarf::DW_AT_friend);
1133         } else if (DDTy.isStaticMember())
1134           ElemDie = createStaticMemberDIE(DDTy);
1135         else
1136           ElemDie = createMemberDIE(DDTy);
1137       } else if (Element.isObjCProperty()) {
1138         DIObjCProperty Property(Element);
1139         ElemDie = new DIE(Property.getTag());
1140         StringRef PropertyName = Property.getObjCPropertyName();
1141         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1142         addType(ElemDie, Property.getType());
1143         addSourceLine(ElemDie, Property);
1144         StringRef GetterName = Property.getObjCPropertyGetterName();
1145         if (!GetterName.empty())
1146           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1147         StringRef SetterName = Property.getObjCPropertySetterName();
1148         if (!SetterName.empty())
1149           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1150         unsigned PropertyAttributes = 0;
1151         if (Property.isReadOnlyObjCProperty())
1152           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1153         if (Property.isReadWriteObjCProperty())
1154           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1155         if (Property.isAssignObjCProperty())
1156           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1157         if (Property.isRetainObjCProperty())
1158           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1159         if (Property.isCopyObjCProperty())
1160           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1161         if (Property.isNonAtomicObjCProperty())
1162           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1163         if (PropertyAttributes)
1164           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1165                  PropertyAttributes);
1166
1167         DIEEntry *Entry = getDIEEntry(Element);
1168         if (!Entry) {
1169           Entry = createDIEEntry(ElemDie);
1170           insertDIEEntry(Element, Entry);
1171         }
1172       } else
1173         continue;
1174       Buffer.addChild(ElemDie);
1175     }
1176
1177     if (CTy.isAppleBlockExtension())
1178       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1179
1180     DICompositeType ContainingType(DD->resolve(CTy.getContainingType()));
1181     if (DIDescriptor(ContainingType).isCompositeType())
1182       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1183                   getOrCreateTypeDIE(DIType(ContainingType)));
1184     else
1185       addToContextOwner(&Buffer, DD->resolve(CTy.getContext()));
1186
1187     if (CTy.isObjcClassComplete())
1188       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1189
1190     // Add template parameters to a class, structure or union types.
1191     // FIXME: The support isn't in the metadata for this yet.
1192     if (Tag == dwarf::DW_TAG_class_type ||
1193         Tag == dwarf::DW_TAG_structure_type ||
1194         Tag == dwarf::DW_TAG_union_type)
1195       addTemplateParams(Buffer, CTy.getTemplateParams());
1196
1197     break;
1198   }
1199   default:
1200     break;
1201   }
1202
1203   // Add name if not anonymous or intermediate type.
1204   if (!Name.empty())
1205     addString(&Buffer, dwarf::DW_AT_name, Name);
1206
1207   if (Tag == dwarf::DW_TAG_enumeration_type ||
1208       Tag == dwarf::DW_TAG_class_type ||
1209       Tag == dwarf::DW_TAG_structure_type ||
1210       Tag == dwarf::DW_TAG_union_type) {
1211     // Add size if non-zero (derived types might be zero-sized.)
1212     // TODO: Do we care about size for enum forward declarations?
1213     if (Size)
1214       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1215     else if (!CTy.isForwardDecl())
1216       // Add zero size if it is not a forward declaration.
1217       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1218
1219     // If we're a forward decl, say so.
1220     if (CTy.isForwardDecl())
1221       addFlag(&Buffer, dwarf::DW_AT_declaration);
1222
1223     // Add source line info if available.
1224     if (!CTy.isForwardDecl())
1225       addSourceLine(&Buffer, CTy);
1226
1227     // No harm in adding the runtime language to the declaration.
1228     unsigned RLang = CTy.getRunTimeLang();
1229     if (RLang)
1230       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1231               dwarf::DW_FORM_data1, RLang);
1232   }
1233   // If this is a type applicable to a type unit it then add it to the
1234   // list of types we'll compute a hash for later.
1235   if (shouldCreateTypeUnit(CTy, DD))
1236     DD->addTypeUnitType(&Buffer);
1237 }
1238
1239 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1240 /// for the given DITemplateTypeParameter.
1241 DIE *
1242 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1243   DIE *ParamDIE = getDIE(TP);
1244   if (ParamDIE)
1245     return ParamDIE;
1246
1247   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1248   // Add the type if it exists, it could be void and therefore no type.
1249   if (TP.getType())
1250     addType(ParamDIE, TP.getType());
1251   if (!TP.getName().empty())
1252     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1253   return ParamDIE;
1254 }
1255
1256 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1257 /// for the given DITemplateValueParameter.
1258 DIE *
1259 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1260   DIE *ParamDIE = getDIE(VP);
1261   if (ParamDIE)
1262     return ParamDIE;
1263
1264   ParamDIE = new DIE(VP.getTag());
1265
1266   // Add the type if there is one, template template and template parameter
1267   // packs will not have a type.
1268   if (VP.getType())
1269     addType(ParamDIE, VP.getType());
1270   if (!VP.getName().empty())
1271     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1272   if (Value *Val = VP.getValue()) {
1273     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1274       addConstantValue(ParamDIE, CI, isUnsignedDIType(DD, VP.getType()));
1275     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1276       // For declaration non-type template parameters (such as global values and
1277       // functions)
1278       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1279       addOpAddress(Block, Asm->Mang->getSymbol(GV));
1280       // Emit DW_OP_stack_value to use the address as the immediate value of the
1281       // parameter, rather than a pointer to it.
1282       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1283       addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1284     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1285       assert(isa<MDString>(Val));
1286       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1287                 cast<MDString>(Val)->getString());
1288     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1289       assert(isa<MDNode>(Val));
1290       DIArray A(cast<MDNode>(Val));
1291       addTemplateParams(*ParamDIE, A);
1292     }
1293   }
1294
1295   return ParamDIE;
1296 }
1297
1298 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1299 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1300   DIE *NDie = getDIE(NS);
1301   if (NDie)
1302     return NDie;
1303   NDie = new DIE(dwarf::DW_TAG_namespace);
1304   insertDIE(NS, NDie);
1305   if (!NS.getName().empty()) {
1306     addString(NDie, dwarf::DW_AT_name, NS.getName());
1307     addAccelNamespace(NS.getName(), NDie);
1308     addGlobalName(NS.getName(), NDie);
1309   } else
1310     addAccelNamespace("(anonymous namespace)", NDie);
1311   addSourceLine(NDie, NS);
1312   addToContextOwner(NDie, NS.getContext());
1313   return NDie;
1314 }
1315
1316 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1317 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1318   DIE *SPDie = DD->getSPDIE(SP);
1319   if (SPDie)
1320     return SPDie;
1321
1322   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1323
1324   // DW_TAG_inlined_subroutine may refer to this DIE.
1325   DD->insertSPDIE(SP, SPDie);
1326
1327   DISubprogram SPDecl = SP.getFunctionDeclaration();
1328   DIE *DeclDie = NULL;
1329   if (SPDecl.isSubprogram()) {
1330     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1331   }
1332
1333   // Add to context owner.
1334   addToContextOwner(SPDie, SP.getContext());
1335
1336   // Add function template parameters.
1337   addTemplateParams(*SPDie, SP.getTemplateParams());
1338
1339   // If this DIE is going to refer declaration info using AT_specification
1340   // then there is no need to add other attributes.
1341   if (DeclDie) {
1342     // Refer function declaration directly.
1343     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1344                 DeclDie);
1345
1346     return SPDie;
1347   }
1348
1349   // Add the linkage name if we have one.
1350   StringRef LinkageName = SP.getLinkageName();
1351   if (!LinkageName.empty())
1352     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1353               GlobalValue::getRealLinkageName(LinkageName));
1354
1355   // Constructors and operators for anonymous aggregates do not have names.
1356   if (!SP.getName().empty())
1357     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1358
1359   addSourceLine(SPDie, SP);
1360
1361   // Add the prototype if we have a prototype and we have a C like
1362   // language.
1363   uint16_t Language = DICompileUnit(Node).getLanguage();
1364   if (SP.isPrototyped() &&
1365       (Language == dwarf::DW_LANG_C89 ||
1366        Language == dwarf::DW_LANG_C99 ||
1367        Language == dwarf::DW_LANG_ObjC))
1368     addFlag(SPDie, dwarf::DW_AT_prototyped);
1369
1370   // Add Return Type. A void return type will not have a type.
1371   DICompositeType SPTy = SP.getType();
1372   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1373          "the type of a subprogram should be a subroutine");
1374
1375   DIArray Args = SPTy.getTypeArray();
1376   if (Args.getElement(0))
1377     addType(SPDie, DIType(Args.getElement(0)));
1378
1379   unsigned VK = SP.getVirtuality();
1380   if (VK) {
1381     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1382     DIEBlock *Block = getDIEBlock();
1383     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1384     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1385     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1386     ContainingTypeMap.insert(std::make_pair(SPDie,
1387                                     DD->resolve(SP.getContainingType())));
1388   }
1389
1390   if (!SP.isDefinition()) {
1391     addFlag(SPDie, dwarf::DW_AT_declaration);
1392
1393     // Add arguments. Do not add arguments for subprogram definition. They will
1394     // be handled while processing variables.
1395     for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1396       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1397       DIType ATy = DIType(Args.getElement(i));
1398       addType(Arg, ATy);
1399       if (ATy.isArtificial())
1400         addFlag(Arg, dwarf::DW_AT_artificial);
1401       SPDie->addChild(Arg);
1402     }
1403   }
1404
1405   if (SP.isArtificial())
1406     addFlag(SPDie, dwarf::DW_AT_artificial);
1407
1408   if (!SP.isLocalToUnit())
1409     addFlag(SPDie, dwarf::DW_AT_external);
1410
1411   if (SP.isOptimized())
1412     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1413
1414   if (unsigned isa = Asm->getISAEncoding()) {
1415     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1416   }
1417
1418   return SPDie;
1419 }
1420
1421 // Return const expression if value is a GEP to access merged global
1422 // constant. e.g.
1423 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1424 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1425   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1426   if (!CE || CE->getNumOperands() != 3 ||
1427       CE->getOpcode() != Instruction::GetElementPtr)
1428     return NULL;
1429
1430   // First operand points to a global struct.
1431   Value *Ptr = CE->getOperand(0);
1432   if (!isa<GlobalValue>(Ptr) ||
1433       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1434     return NULL;
1435
1436   // Second operand is zero.
1437   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1438   if (!CI || !CI->isZero())
1439     return NULL;
1440
1441   // Third operand is offset.
1442   if (!isa<ConstantInt>(CE->getOperand(2)))
1443     return NULL;
1444
1445   return CE;
1446 }
1447
1448 /// createGlobalVariableDIE - create global variable DIE.
1449 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1450   // Check for pre-existence.
1451   if (getDIE(N))
1452     return;
1453
1454   DIGlobalVariable GV(N);
1455   if (!GV.isGlobalVariable())
1456     return;
1457
1458   DIDescriptor GVContext = GV.getContext();
1459   DIType GTy = GV.getType();
1460
1461   // If this is a static data member definition, some attributes belong
1462   // to the declaration DIE.
1463   DIE *VariableDIE = NULL;
1464   bool IsStaticMember = false;
1465   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1466   if (SDMDecl.Verify()) {
1467     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1468     // We need the declaration DIE that is in the static member's class.
1469     // But that class might not exist in the DWARF yet.
1470     // Creating the class will create the static member decl DIE.
1471     getOrCreateContextDIE(DD->resolve(SDMDecl.getContext()));
1472     VariableDIE = DD->getStaticMemberDIE(SDMDecl);
1473     assert(VariableDIE && "Static member decl has no context?");
1474     IsStaticMember = true;
1475   }
1476
1477   // If this is not a static data member definition, create the variable
1478   // DIE and add the initial set of attributes to it.
1479   if (!VariableDIE) {
1480     VariableDIE = new DIE(GV.getTag());
1481     // Add to map.
1482     insertDIE(N, VariableDIE);
1483
1484     // Add name and type.
1485     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1486     addType(VariableDIE, GTy);
1487
1488     // Add scoping info.
1489     if (!GV.isLocalToUnit()) {
1490       addFlag(VariableDIE, dwarf::DW_AT_external);
1491       addGlobalName(GV.getName(), VariableDIE);
1492     }
1493
1494     // Add line number info.
1495     addSourceLine(VariableDIE, GV);
1496     // Add to context owner.
1497     addToContextOwner(VariableDIE, GVContext);
1498   }
1499
1500   // Add location.
1501   bool addToAccelTable = false;
1502   DIE *VariableSpecDIE = NULL;
1503   bool isGlobalVariable = GV.getGlobal() != NULL;
1504   if (isGlobalVariable) {
1505     addToAccelTable = true;
1506     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1507     const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1508     if (GV.getGlobal()->isThreadLocal()) {
1509       // FIXME: Make this work with -gsplit-dwarf.
1510       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1511       assert((PointerSize == 4 || PointerSize == 8) &&
1512              "Add support for other sizes if necessary");
1513       const MCExpr *Expr =
1514           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1515       // Based on GCC's support for TLS:
1516       if (!DD->useSplitDwarf()) {
1517         // 1) Start with a constNu of the appropriate pointer size
1518         addUInt(Block, 0, dwarf::DW_FORM_data1,
1519                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1520         // 2) containing the (relocated) address of the TLS variable
1521         addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1522       } else {
1523         addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1524         addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1525       }
1526       // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1527       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1528     } else
1529       addOpAddress(Block, Sym);
1530     // Do not create specification DIE if context is either compile unit
1531     // or a subprogram.
1532     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1533         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1534       // Create specification DIE.
1535       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1536       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1537                   dwarf::DW_FORM_ref4, VariableDIE);
1538       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1539       // A static member's declaration is already flagged as such.
1540       if (!SDMDecl.Verify())
1541         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1542       addDie(VariableSpecDIE);
1543     } else {
1544       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1545     }
1546     // Add the linkage name.
1547     StringRef LinkageName = GV.getLinkageName();
1548     if (!LinkageName.empty())
1549       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1550       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1551       // TAG_variable.
1552       addString(IsStaticMember && VariableSpecDIE ?
1553                 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1554                 GlobalValue::getRealLinkageName(LinkageName));
1555   } else if (const ConstantInt *CI =
1556              dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1557     // AT_const_value was added when the static member was created. To avoid
1558     // emitting AT_const_value multiple times, we only add AT_const_value when
1559     // it is not a static member.
1560     if (!IsStaticMember)
1561       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1562   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1563     addToAccelTable = true;
1564     // GV is a merged global.
1565     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1566     Value *Ptr = CE->getOperand(0);
1567     addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1568     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1569     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1570     addUInt(Block, 0, dwarf::DW_FORM_udata,
1571                    Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1572     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1573     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1574   }
1575
1576   if (addToAccelTable) {
1577     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1578     addAccelName(GV.getName(), AddrDIE);
1579
1580     // If the linkage name is different than the name, go ahead and output
1581     // that as well into the name table.
1582     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1583       addAccelName(GV.getLinkageName(), AddrDIE);
1584   }
1585 }
1586
1587 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1588 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1589                                        DIE *IndexTy) {
1590   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1591   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1592
1593   // The LowerBound value defines the lower bounds which is typically zero for
1594   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1595   // Count == -1 then the array is unbounded and we do not emit
1596   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1597   // Count == 0, then the array has zero elements in which case we do not emit
1598   // an upper bound.
1599   int64_t LowerBound = SR.getLo();
1600   int64_t DefaultLowerBound = getDefaultLowerBound();
1601   int64_t Count = SR.getCount();
1602
1603   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1604     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1605
1606   if (Count != -1 && Count != 0)
1607     // FIXME: An unbounded array should reference the expression that defines
1608     // the array.
1609     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1610
1611   Buffer.addChild(DW_Subrange);
1612 }
1613
1614 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1615 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1616                                         DICompositeType *CTy) {
1617   Buffer.setTag(dwarf::DW_TAG_array_type);
1618   if (CTy->isVector())
1619     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1620
1621   // Emit the element type.
1622   addType(&Buffer, DD->resolve(CTy->getTypeDerivedFrom()));
1623
1624   // Get an anonymous type for index type.
1625   // FIXME: This type should be passed down from the front end
1626   // as different languages may have different sizes for indexes.
1627   DIE *IdxTy = getIndexTyDie();
1628   if (!IdxTy) {
1629     // Construct an anonymous type for index type.
1630     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1631     addString(IdxTy, dwarf::DW_AT_name, "int");
1632     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1633     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1634             dwarf::DW_ATE_signed);
1635     addDie(IdxTy);
1636     setIndexTyDie(IdxTy);
1637   }
1638
1639   // Add subranges to array type.
1640   DIArray Elements = CTy->getTypeArray();
1641   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1642     DIDescriptor Element = Elements.getElement(i);
1643     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1644       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1645   }
1646 }
1647
1648 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1649 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1650   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1651   StringRef Name = ETy.getName();
1652   addString(Enumerator, dwarf::DW_AT_name, Name);
1653   int64_t Value = ETy.getEnumValue();
1654   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1655   return Enumerator;
1656 }
1657
1658 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1659 /// vtables.
1660 void CompileUnit::constructContainingTypeDIEs() {
1661   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1662          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1663     DIE *SPDie = CI->first;
1664     const MDNode *N = CI->second;
1665     if (!N) continue;
1666     DIE *NDie = DD->getTypeDIE(N);
1667     if (!NDie) continue;
1668     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1669   }
1670 }
1671
1672 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1673 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1674                                        bool isScopeAbstract) {
1675   StringRef Name = DV->getName();
1676
1677   // Translate tag to proper Dwarf tag.
1678   uint16_t Tag = DV->getTag();
1679
1680   // Define variable debug information entry.
1681   DIE *VariableDie = new DIE(Tag);
1682   DbgVariable *AbsVar = DV->getAbstractVariable();
1683   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1684   if (AbsDIE)
1685     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1686                             dwarf::DW_FORM_ref4, AbsDIE);
1687   else {
1688     if (!Name.empty())
1689       addString(VariableDie, dwarf::DW_AT_name, Name);
1690     addSourceLine(VariableDie, DV->getVariable());
1691     addType(VariableDie, DV->getType());
1692   }
1693
1694   if (DV->isArtificial())
1695     addFlag(VariableDie, dwarf::DW_AT_artificial);
1696
1697   if (isScopeAbstract) {
1698     DV->setDIE(VariableDie);
1699     return VariableDie;
1700   }
1701
1702   // Add variable address.
1703
1704   unsigned Offset = DV->getDotDebugLocOffset();
1705   if (Offset != ~0U) {
1706     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1707              Asm->GetTempSymbol("debug_loc", Offset));
1708     DV->setDIE(VariableDie);
1709     return VariableDie;
1710   }
1711
1712   // Check if variable is described by a DBG_VALUE instruction.
1713   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1714     assert(DVInsn->getNumOperands() == 3);
1715     if (DVInsn->getOperand(0).isReg()) {
1716       const MachineOperand RegOp = DVInsn->getOperand(0);
1717       // If the second operand is an immediate, this is an indirect value.
1718       if (DVInsn->getOperand(1).isImm()) {
1719         MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1720         addVariableAddress(*DV, VariableDie, Location);
1721       } else if (RegOp.getReg())
1722         addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1723     } else if (DVInsn->getOperand(0).isImm())
1724       addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1725     else if (DVInsn->getOperand(0).isFPImm())
1726       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1727     else if (DVInsn->getOperand(0).isCImm())
1728       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1729                        isUnsignedDIType(DD, DV->getType()));
1730
1731     DV->setDIE(VariableDie);
1732     return VariableDie;
1733   } else {
1734     // .. else use frame index.
1735     int FI = DV->getFrameIndex();
1736     if (FI != ~0) {
1737       unsigned FrameReg = 0;
1738       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1739       int Offset =
1740         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1741       MachineLocation Location(FrameReg, Offset);
1742       addVariableAddress(*DV, VariableDie, Location);
1743     }
1744   }
1745
1746   DV->setDIE(VariableDie);
1747   return VariableDie;
1748 }
1749
1750 /// createMemberDIE - Create new member DIE.
1751 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1752   DIE *MemberDie = new DIE(DT.getTag());
1753   StringRef Name = DT.getName();
1754   if (!Name.empty())
1755     addString(MemberDie, dwarf::DW_AT_name, Name);
1756
1757   addType(MemberDie, DD->resolve(DT.getTypeDerivedFrom()));
1758
1759   addSourceLine(MemberDie, DT);
1760
1761   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1762   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1763
1764   uint64_t Size = DT.getSizeInBits();
1765   uint64_t FieldSize = getOriginalTypeSize(DD, DT);
1766
1767   if (Size != FieldSize) {
1768     // Handle bitfield.
1769     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0,
1770             getOriginalTypeSize(DD, DT)>>3);
1771     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1772
1773     uint64_t Offset = DT.getOffsetInBits();
1774     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1775     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1776     uint64_t FieldOffset = (HiMark - FieldSize);
1777     Offset -= FieldOffset;
1778
1779     // Maybe we need to work from the other end.
1780     if (Asm->getDataLayout().isLittleEndian())
1781       Offset = FieldSize - (Offset + Size);
1782     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1783
1784     // Here WD_AT_data_member_location points to the anonymous
1785     // field that includes this bit field.
1786     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1787
1788   } else
1789     // This is not a bitfield.
1790     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1791
1792   if (DT.getTag() == dwarf::DW_TAG_inheritance
1793       && DT.isVirtual()) {
1794
1795     // For C++, virtual base classes are not at fixed offset. Use following
1796     // expression to extract appropriate offset from vtable.
1797     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1798
1799     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1800     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1801     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1802     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1803     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1804     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1805     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1806     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1807
1808     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1809              VBaseLocationDie);
1810   } else
1811     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1812
1813   if (DT.isProtected())
1814     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1815             dwarf::DW_ACCESS_protected);
1816   else if (DT.isPrivate())
1817     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1818             dwarf::DW_ACCESS_private);
1819   // Otherwise C++ member and base classes are considered public.
1820   else
1821     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1822             dwarf::DW_ACCESS_public);
1823   if (DT.isVirtual())
1824     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1825             dwarf::DW_VIRTUALITY_virtual);
1826
1827   // Objective-C properties.
1828   if (MDNode *PNode = DT.getObjCProperty())
1829     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1830       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1831                           PropertyDie);
1832
1833   if (DT.isArtificial())
1834     addFlag(MemberDie, dwarf::DW_AT_artificial);
1835
1836   return MemberDie;
1837 }
1838
1839 /// createStaticMemberDIE - Create new DIE for C++ static member.
1840 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1841   if (!DT.Verify())
1842     return NULL;
1843
1844   DIE *StaticMemberDIE = new DIE(DT.getTag());
1845   DIType Ty = DD->resolve(DT.getTypeDerivedFrom());
1846
1847   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1848   addType(StaticMemberDIE, Ty);
1849   addSourceLine(StaticMemberDIE, DT);
1850   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1851   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1852
1853   // FIXME: We could omit private if the parent is a class_type, and
1854   // public if the parent is something else.
1855   if (DT.isProtected())
1856     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1857             dwarf::DW_ACCESS_protected);
1858   else if (DT.isPrivate())
1859     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1860             dwarf::DW_ACCESS_private);
1861   else
1862     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1863             dwarf::DW_ACCESS_public);
1864
1865   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1866     addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1867   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1868     addConstantFPValue(StaticMemberDIE, CFP);
1869
1870   DD->insertStaticMemberDIE(DT, StaticMemberDIE);
1871   return StaticMemberDIE;
1872 }