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