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(DIDescriptor 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, DIDescriptor 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(dwarf::DW_TAG_base_type);
 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   DIDescriptor 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   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 908     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 909     // An unspecified type only has a name attribute.
 910     return;
 911   }
 912
 913   Buffer.setTag(dwarf::DW_TAG_base_type);
 914   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 915           BTy.getEncoding());
 916
 917   uint64_t Size = BTy.getSizeInBits() >> 3;
 918   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 919 }
 920
 921 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 922 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 923   // Get core information.
 924   StringRef Name = DTy.getName();
 925   uint64_t Size = DTy.getSizeInBits() >> 3;
 926   uint16_t Tag = DTy.getTag();
 927
 928   // FIXME - Workaround for templates.
 929   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 930
 931   Buffer.setTag(Tag);
 932
 933   // Map to main type, void will not have a type.
 934   DIType FromTy = DTy.getTypeDerivedFrom();
 935   if (FromTy)
 936     addType(&Buffer, FromTy);
 937
 938   // Add name if not anonymous or intermediate type.
 939   if (!Name.empty())
 940     addString(&Buffer, dwarf::DW_AT_name, Name);
 941
 942   // Add size if non-zero (derived types might be zero-sized.)
 943   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 944     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 945
 946   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 947       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 948                   getOrCreateTypeDIE(DD->resolve(DTy.getClassType())));
 949   // Add source line info if available and TyDesc is not a forward declaration.
 950   if (!DTy.isForwardDecl())
 951     addSourceLine(&Buffer, DTy);
 952 }
 953
 954 /// Return true if the type is appropriately scoped to be contained inside
 955 /// its own type unit.
 956 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
 957   DIScope Parent = DD->resolve(Ty.getContext());
 958   while (Parent) {
 959     // Don't generate a hash for anything scoped inside a function.
 960     if (Parent.isSubprogram())
 961       return false;
 962     Parent = DD->resolve(Parent.getContext());
 963   }
 964   return true;
 965 }
 966
 967 /// Return true if the type should be split out into a type unit.
 968 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
 969   uint16_t Tag = CTy.getTag();
 970
 971   switch (Tag) {
 972   case dwarf::DW_TAG_structure_type:
 973   case dwarf::DW_TAG_union_type:
 974   case dwarf::DW_TAG_enumeration_type:
 975   case dwarf::DW_TAG_class_type:
 976     // If this is a class, structure, union, or enumeration type
 977     // that is not a declaration, is a type definition, and not scoped
 978     // inside a function then separate this out as a type unit.
 979     if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy, DD))
 980       return 0;
 981     return 1;
 982   default:
 983     return 0;
 984   }
 985 }
 986
 987 /// constructTypeDIE - Construct type DIE from DICompositeType.
 988 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 989   // Get core information.
 990   StringRef Name = CTy.getName();
 991
 992   uint64_t Size = CTy.getSizeInBits() >> 3;
 993   uint16_t Tag = CTy.getTag();
 994   Buffer.setTag(Tag);
 995
 996   switch (Tag) {
 997   case dwarf::DW_TAG_array_type:
 998     constructArrayTypeDIE(Buffer, &CTy);
 999     break;
1000   case dwarf::DW_TAG_enumeration_type: {
1001     DIArray Elements = CTy.getTypeArray();
1002
1003     // Add enumerators to enumeration type.
1004     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1005       DIE *ElemDie = NULL;
1006       DIDescriptor Enum(Elements.getElement(i));
1007       if (Enum.isEnumerator()) {
1008         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1009         Buffer.addChild(ElemDie);
1010       }
1011     }
1012     DIType DTy = CTy.getTypeDerivedFrom();
1013     if (DTy) {
1014       addType(&Buffer, DTy);
1015       addFlag(&Buffer, dwarf::DW_AT_enum_class);
1016     }
1017   }
1018     break;
1019   case dwarf::DW_TAG_subroutine_type: {
1020     // Add return type. A void return won't have a type.
1021     DIArray Elements = CTy.getTypeArray();
1022     DIDescriptor RTy = Elements.getElement(0);
1023     if (RTy)
1024       addType(&Buffer, DIType(RTy));
1025
1026     bool isPrototyped = true;
1027     // Add arguments.
1028     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1029       DIDescriptor Ty = Elements.getElement(i);
1030       if (Ty.isUnspecifiedParameter()) {
1031         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1032         Buffer.addChild(Arg);
1033         isPrototyped = false;
1034       } else {
1035         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1036         addType(Arg, DIType(Ty));
1037         if (DIType(Ty).isArtificial())
1038           addFlag(Arg, dwarf::DW_AT_artificial);
1039         Buffer.addChild(Arg);
1040       }
1041     }
1042     // Add prototype flag if we're dealing with a C language and the
1043     // function has been prototyped.
1044     uint16_t Language = DICompileUnit(Node).getLanguage();
1045     if (isPrototyped &&
1046         (Language == dwarf::DW_LANG_C89 ||
1047          Language == dwarf::DW_LANG_C99 ||
1048          Language == dwarf::DW_LANG_ObjC))
1049       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1050   }
1051     break;
1052   case dwarf::DW_TAG_structure_type:
1053   case dwarf::DW_TAG_union_type:
1054   case dwarf::DW_TAG_class_type: {
1055     // Add elements to structure type.
1056     DIArray Elements = CTy.getTypeArray();
1057     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1058       DIDescriptor Element = Elements.getElement(i);
1059       DIE *ElemDie = NULL;
1060       if (Element.isSubprogram()) {
1061         DISubprogram SP(Element);
1062         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1063         if (SP.isProtected())
1064           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1065                   dwarf::DW_ACCESS_protected);
1066         else if (SP.isPrivate())
1067           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1068                   dwarf::DW_ACCESS_private);
1069         else
1070           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1071             dwarf::DW_ACCESS_public);
1072         if (SP.isExplicit())
1073           addFlag(ElemDie, dwarf::DW_AT_explicit);
1074       } else if (Element.isDerivedType()) {
1075         DIDerivedType DDTy(Element);
1076         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1077           ElemDie = new DIE(dwarf::DW_TAG_friend);
1078           addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1079         } else if (DDTy.isStaticMember())
1080           ElemDie = createStaticMemberDIE(DDTy);
1081         else
1082           ElemDie = createMemberDIE(DDTy);
1083         Buffer.addChild(ElemDie);
1084       } else if (Element.isObjCProperty()) {
1085         DIObjCProperty Property(Element);
1086         ElemDie = new DIE(Property.getTag());
1087         StringRef PropertyName = Property.getObjCPropertyName();
1088         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1089         addType(ElemDie, Property.getType());
1090         addSourceLine(ElemDie, Property);
1091         StringRef GetterName = Property.getObjCPropertyGetterName();
1092         if (!GetterName.empty())
1093           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1094         StringRef SetterName = Property.getObjCPropertySetterName();
1095         if (!SetterName.empty())
1096           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1097         unsigned PropertyAttributes = 0;
1098         if (Property.isReadOnlyObjCProperty())
1099           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1100         if (Property.isReadWriteObjCProperty())
1101           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1102         if (Property.isAssignObjCProperty())
1103           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1104         if (Property.isRetainObjCProperty())
1105           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1106         if (Property.isCopyObjCProperty())
1107           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1108         if (Property.isNonAtomicObjCProperty())
1109           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1110         if (PropertyAttributes)
1111           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1112                  PropertyAttributes);
1113
1114         DIEEntry *Entry = getDIEEntry(Element);
1115         if (!Entry) {
1116           Entry = createDIEEntry(ElemDie);
1117           insertDIEEntry(Element, Entry);
1118         }
1119         Buffer.addChild(ElemDie);
1120       } else
1121         continue;
1122     }
1123
1124     if (CTy.isAppleBlockExtension())
1125       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1126
1127     DICompositeType ContainingType(DD->resolve(CTy.getContainingType()));
1128     if (DIDescriptor(ContainingType).isCompositeType())
1129       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1130                   getOrCreateTypeDIE(DIType(ContainingType)));
1131
1132     if (CTy.isObjcClassComplete())
1133       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1134
1135     // Add template parameters to a class, structure or union types.
1136     // FIXME: The support isn't in the metadata for this yet.
1137     if (Tag == dwarf::DW_TAG_class_type ||
1138         Tag == dwarf::DW_TAG_structure_type ||
1139         Tag == dwarf::DW_TAG_union_type)
1140       addTemplateParams(Buffer, CTy.getTemplateParams());
1141
1142     break;
1143   }
1144   default:
1145     break;
1146   }
1147
1148   // Add name if not anonymous or intermediate type.
1149   if (!Name.empty())
1150     addString(&Buffer, dwarf::DW_AT_name, Name);
1151
1152   if (Tag == dwarf::DW_TAG_enumeration_type ||
1153       Tag == dwarf::DW_TAG_class_type ||
1154       Tag == dwarf::DW_TAG_structure_type ||
1155       Tag == dwarf::DW_TAG_union_type) {
1156     // Add size if non-zero (derived types might be zero-sized.)
1157     // TODO: Do we care about size for enum forward declarations?
1158     if (Size)
1159       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1160     else if (!CTy.isForwardDecl())
1161       // Add zero size if it is not a forward declaration.
1162       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1163
1164     // If we're a forward decl, say so.
1165     if (CTy.isForwardDecl())
1166       addFlag(&Buffer, dwarf::DW_AT_declaration);
1167
1168     // Add source line info if available.
1169     if (!CTy.isForwardDecl())
1170       addSourceLine(&Buffer, CTy);
1171
1172     // No harm in adding the runtime language to the declaration.
1173     unsigned RLang = CTy.getRunTimeLang();
1174     if (RLang)
1175       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1176               dwarf::DW_FORM_data1, RLang);
1177   }
1178   // If this is a type applicable to a type unit it then add it to the
1179   // list of types we'll compute a hash for later.
1180   if (shouldCreateTypeUnit(CTy, DD))
1181     DD->addTypeUnitType(&Buffer);
1182 }
1183
1184 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1185 /// for the given DITemplateTypeParameter.
1186 DIE *
1187 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1188   DIE *ParamDIE = getDIE(TP);
1189   if (ParamDIE)
1190     return ParamDIE;
1191
1192   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1193   // Add the type if it exists, it could be void and therefore no type.
1194   if (TP.getType())
1195     addType(ParamDIE, TP.getType());
1196   if (!TP.getName().empty())
1197     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1198   return ParamDIE;
1199 }
1200
1201 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1202 /// for the given DITemplateValueParameter.
1203 DIE *
1204 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1205   DIE *ParamDIE = getDIE(VP);
1206   if (ParamDIE)
1207     return ParamDIE;
1208
1209   ParamDIE = new DIE(VP.getTag());
1210
1211   // Add the type if there is one, template template and template parameter
1212   // packs will not have a type.
1213   if (VP.getType())
1214     addType(ParamDIE, VP.getType());
1215   if (!VP.getName().empty())
1216     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1217   if (Value *Val = VP.getValue()) {
1218     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1219       addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1220     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1221       // For declaration non-type template parameters (such as global values and
1222       // functions)
1223       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1224       addOpAddress(Block, Asm->Mang->getSymbol(GV));
1225       // Emit DW_OP_stack_value to use the address as the immediate value of the
1226       // parameter, rather than a pointer to it.
1227       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1228       addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1229     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1230       assert(isa<MDString>(Val));
1231       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1232                 cast<MDString>(Val)->getString());
1233     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1234       assert(isa<MDNode>(Val));
1235       DIArray A(cast<MDNode>(Val));
1236       addTemplateParams(*ParamDIE, A);
1237     }
1238   }
1239
1240   return ParamDIE;
1241 }
1242
1243 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1244 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1245   DIE *NDie = getDIE(NS);
1246   if (NDie)
1247     return NDie;
1248   NDie = new DIE(dwarf::DW_TAG_namespace);
1249   insertDIE(NS, NDie);
1250   if (!NS.getName().empty()) {
1251     addString(NDie, dwarf::DW_AT_name, NS.getName());
1252     addAccelNamespace(NS.getName(), NDie);
1253     addGlobalName(NS.getName(), NDie);
1254   } else
1255     addAccelNamespace("(anonymous namespace)", NDie);
1256   addSourceLine(NDie, NS);
1257   addToContextOwner(NDie, NS.getContext());
1258   return NDie;
1259 }
1260
1261 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1262 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1263   // Construct the context before querying for the existence of the DIE in case
1264   // such construction creates the DIE (as is the case for member function
1265   // declarations).
1266   DIE *ContextDIE = getOrCreateContextDIE(SP.getContext());
1267   if (!ContextDIE)
1268     ContextDIE = CUDie.get();
1269
1270   DIE *SPDie = getDIE(SP);
1271   if (SPDie)
1272     return SPDie;
1273
1274   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1275
1276   // DW_TAG_inlined_subroutine may refer to this DIE.
1277   insertDIE(SP, SPDie);
1278
1279   DISubprogram SPDecl = SP.getFunctionDeclaration();
1280   DIE *DeclDie = NULL;
1281   if (SPDecl.isSubprogram()) {
1282     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1283   }
1284
1285   // Add to context owner.
1286   ContextDIE->addChild(SPDie);
1287
1288   // Add function template parameters.
1289   addTemplateParams(*SPDie, SP.getTemplateParams());
1290
1291   // If this DIE is going to refer declaration info using AT_specification
1292   // then there is no need to add other attributes.
1293   if (DeclDie) {
1294     // Refer function declaration directly.
1295     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1296                 DeclDie);
1297
1298     return SPDie;
1299   }
1300
1301   // Add the linkage name if we have one.
1302   StringRef LinkageName = SP.getLinkageName();
1303   if (!LinkageName.empty())
1304     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1305               GlobalValue::getRealLinkageName(LinkageName));
1306
1307   // Constructors and operators for anonymous aggregates do not have names.
1308   if (!SP.getName().empty())
1309     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1310
1311   addSourceLine(SPDie, SP);
1312
1313   // Add the prototype if we have a prototype and we have a C like
1314   // language.
1315   uint16_t Language = DICompileUnit(Node).getLanguage();
1316   if (SP.isPrototyped() &&
1317       (Language == dwarf::DW_LANG_C89 ||
1318        Language == dwarf::DW_LANG_C99 ||
1319        Language == dwarf::DW_LANG_ObjC))
1320     addFlag(SPDie, dwarf::DW_AT_prototyped);
1321
1322   // Add Return Type. A void return type will not have a type.
1323   DICompositeType SPTy = SP.getType();
1324   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1325          "the type of a subprogram should be a subroutine");
1326
1327   DIArray Args = SPTy.getTypeArray();
1328   if (Args.getElement(0))
1329     addType(SPDie, DIType(Args.getElement(0)));
1330
1331   unsigned VK = SP.getVirtuality();
1332   if (VK) {
1333     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1334     DIEBlock *Block = getDIEBlock();
1335     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1336     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1337     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1338     ContainingTypeMap.insert(std::make_pair(SPDie,
1339                                     DD->resolve(SP.getContainingType())));
1340   }
1341
1342   if (!SP.isDefinition()) {
1343     addFlag(SPDie, dwarf::DW_AT_declaration);
1344
1345     // Add arguments. Do not add arguments for subprogram definition. They will
1346     // be handled while processing variables.
1347     for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1348       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1349       DIType ATy = DIType(Args.getElement(i));
1350       addType(Arg, ATy);
1351       if (ATy.isArtificial())
1352         addFlag(Arg, dwarf::DW_AT_artificial);
1353       SPDie->addChild(Arg);
1354     }
1355   }
1356
1357   if (SP.isArtificial())
1358     addFlag(SPDie, dwarf::DW_AT_artificial);
1359
1360   if (!SP.isLocalToUnit())
1361     addFlag(SPDie, dwarf::DW_AT_external);
1362
1363   if (SP.isOptimized())
1364     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1365
1366   if (unsigned isa = Asm->getISAEncoding()) {
1367     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1368   }
1369
1370   return SPDie;
1371 }
1372
1373 // Return const expression if value is a GEP to access merged global
1374 // constant. e.g.
1375 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1376 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1377   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1378   if (!CE || CE->getNumOperands() != 3 ||
1379       CE->getOpcode() != Instruction::GetElementPtr)
1380     return NULL;
1381
1382   // First operand points to a global struct.
1383   Value *Ptr = CE->getOperand(0);
1384   if (!isa<GlobalValue>(Ptr) ||
1385       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1386     return NULL;
1387
1388   // Second operand is zero.
1389   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1390   if (!CI || !CI->isZero())
1391     return NULL;
1392
1393   // Third operand is offset.
1394   if (!isa<ConstantInt>(CE->getOperand(2)))
1395     return NULL;
1396
1397   return CE;
1398 }
1399
1400 /// createGlobalVariableDIE - create global variable DIE.
1401 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1402   // Check for pre-existence.
1403   if (getDIE(N))
1404     return;
1405
1406   DIGlobalVariable GV(N);
1407   if (!GV.isGlobalVariable())
1408     return;
1409
1410   DIDescriptor GVContext = GV.getContext();
1411   DIType GTy = GV.getType();
1412
1413   // If this is a static data member definition, some attributes belong
1414   // to the declaration DIE.
1415   DIE *VariableDIE = NULL;
1416   bool IsStaticMember = false;
1417   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1418   if (SDMDecl.Verify()) {
1419     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1420     // We need the declaration DIE that is in the static member's class.
1421     // But that class might not exist in the DWARF yet.
1422     // Creating the class will create the static member decl DIE.
1423     getOrCreateContextDIE(DD->resolve(SDMDecl.getContext()));
1424     VariableDIE = getDIE(SDMDecl);
1425     assert(VariableDIE && "Static member decl has no context?");
1426     IsStaticMember = true;
1427   }
1428
1429   // If this is not a static data member definition, create the variable
1430   // DIE and add the initial set of attributes to it.
1431   if (!VariableDIE) {
1432     VariableDIE = new DIE(GV.getTag());
1433     // Add to map.
1434     insertDIE(N, VariableDIE);
1435
1436     // Add name and type.
1437     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1438     addType(VariableDIE, GTy);
1439
1440     // Add scoping info.
1441     if (!GV.isLocalToUnit()) {
1442       addFlag(VariableDIE, dwarf::DW_AT_external);
1443       addGlobalName(GV.getName(), VariableDIE);
1444     }
1445
1446     // Add line number info.
1447     addSourceLine(VariableDIE, GV);
1448     // Add to context owner.
1449     addToContextOwner(VariableDIE, GVContext);
1450   }
1451
1452   // Add location.
1453   bool addToAccelTable = false;
1454   DIE *VariableSpecDIE = NULL;
1455   bool isGlobalVariable = GV.getGlobal() != NULL;
1456   if (isGlobalVariable) {
1457     addToAccelTable = true;
1458     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1459     const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1460     if (GV.getGlobal()->isThreadLocal()) {
1461       // FIXME: Make this work with -gsplit-dwarf.
1462       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1463       assert((PointerSize == 4 || PointerSize == 8) &&
1464              "Add support for other sizes if necessary");
1465       const MCExpr *Expr =
1466           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1467       // Based on GCC's support for TLS:
1468       if (!DD->useSplitDwarf()) {
1469         // 1) Start with a constNu of the appropriate pointer size
1470         addUInt(Block, 0, dwarf::DW_FORM_data1,
1471                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1472         // 2) containing the (relocated) address of the TLS variable
1473         addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1474       } else {
1475         addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1476         addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1477       }
1478       // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1479       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1480     } else
1481       addOpAddress(Block, Sym);
1482     // Do not create specification DIE if context is either compile unit
1483     // or a subprogram.
1484     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1485         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1486       // Create specification DIE.
1487       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1488       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1489                   dwarf::DW_FORM_ref4, VariableDIE);
1490       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1491       // A static member's declaration is already flagged as such.
1492       if (!SDMDecl.Verify())
1493         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1494       addDie(VariableSpecDIE);
1495     } else {
1496       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1497     }
1498     // Add the linkage name.
1499     StringRef LinkageName = GV.getLinkageName();
1500     if (!LinkageName.empty())
1501       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1502       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1503       // TAG_variable.
1504       addString(IsStaticMember && VariableSpecDIE ?
1505                 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1506                 GlobalValue::getRealLinkageName(LinkageName));
1507   } else if (const ConstantInt *CI =
1508              dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1509     // AT_const_value was added when the static member was created. To avoid
1510     // emitting AT_const_value multiple times, we only add AT_const_value when
1511     // it is not a static member.
1512     if (!IsStaticMember)
1513       addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1514   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1515     addToAccelTable = true;
1516     // GV is a merged global.
1517     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1518     Value *Ptr = CE->getOperand(0);
1519     addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1520     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1521     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1522     addUInt(Block, 0, dwarf::DW_FORM_udata,
1523                    Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1524     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1525     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1526   }
1527
1528   if (addToAccelTable) {
1529     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1530     addAccelName(GV.getName(), AddrDIE);
1531
1532     // If the linkage name is different than the name, go ahead and output
1533     // that as well into the name table.
1534     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1535       addAccelName(GV.getLinkageName(), AddrDIE);
1536   }
1537 }
1538
1539 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1540 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1541                                        DIE *IndexTy) {
1542   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1543   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1544
1545   // The LowerBound value defines the lower bounds which is typically zero for
1546   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1547   // Count == -1 then the array is unbounded and we do not emit
1548   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1549   // Count == 0, then the array has zero elements in which case we do not emit
1550   // an upper bound.
1551   int64_t LowerBound = SR.getLo();
1552   int64_t DefaultLowerBound = getDefaultLowerBound();
1553   int64_t Count = SR.getCount();
1554
1555   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1556     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1557
1558   if (Count != -1 && Count != 0)
1559     // FIXME: An unbounded array should reference the expression that defines
1560     // the array.
1561     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1562
1563   Buffer.addChild(DW_Subrange);
1564 }
1565
1566 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1567 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1568                                         DICompositeType *CTy) {
1569   Buffer.setTag(dwarf::DW_TAG_array_type);
1570   if (CTy->isVector())
1571     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1572
1573   // Emit the element type.
1574   addType(&Buffer, CTy->getTypeDerivedFrom());
1575
1576   // Get an anonymous type for index type.
1577   // FIXME: This type should be passed down from the front end
1578   // as different languages may have different sizes for indexes.
1579   DIE *IdxTy = getIndexTyDie();
1580   if (!IdxTy) {
1581     // Construct an anonymous type for index type.
1582     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1583     addString(IdxTy, dwarf::DW_AT_name, "int");
1584     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1585     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1586             dwarf::DW_ATE_signed);
1587     addDie(IdxTy);
1588     setIndexTyDie(IdxTy);
1589   }
1590
1591   // Add subranges to array type.
1592   DIArray Elements = CTy->getTypeArray();
1593   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1594     DIDescriptor Element = Elements.getElement(i);
1595     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1596       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1597   }
1598 }
1599
1600 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1601 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1602   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1603   StringRef Name = ETy.getName();
1604   addString(Enumerator, dwarf::DW_AT_name, Name);
1605   int64_t Value = ETy.getEnumValue();
1606   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1607   return Enumerator;
1608 }
1609
1610 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1611 /// vtables.
1612 void CompileUnit::constructContainingTypeDIEs() {
1613   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1614          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1615     DIE *SPDie = CI->first;
1616     const MDNode *N = CI->second;
1617     if (!N) continue;
1618     DIE *NDie = getDIE(N);
1619     if (!NDie) continue;
1620     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1621   }
1622 }
1623
1624 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1625 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1626                                        bool isScopeAbstract) {
1627   StringRef Name = DV->getName();
1628
1629   // Translate tag to proper Dwarf tag.
1630   uint16_t Tag = DV->getTag();
1631
1632   // Define variable debug information entry.
1633   DIE *VariableDie = new DIE(Tag);
1634   DbgVariable *AbsVar = DV->getAbstractVariable();
1635   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1636   if (AbsDIE)
1637     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1638                             dwarf::DW_FORM_ref4, AbsDIE);
1639   else {
1640     if (!Name.empty())
1641       addString(VariableDie, dwarf::DW_AT_name, Name);
1642     addSourceLine(VariableDie, DV->getVariable());
1643     addType(VariableDie, DV->getType());
1644   }
1645
1646   if (DV->isArtificial())
1647     addFlag(VariableDie, dwarf::DW_AT_artificial);
1648
1649   if (isScopeAbstract) {
1650     DV->setDIE(VariableDie);
1651     return VariableDie;
1652   }
1653
1654   // Add variable address.
1655
1656   unsigned Offset = DV->getDotDebugLocOffset();
1657   if (Offset != ~0U) {
1658     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1659              Asm->GetTempSymbol("debug_loc", Offset));
1660     DV->setDIE(VariableDie);
1661     return VariableDie;
1662   }
1663
1664   // Check if variable is described by a DBG_VALUE instruction.
1665   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1666     assert(DVInsn->getNumOperands() == 3);
1667     if (DVInsn->getOperand(0).isReg()) {
1668       const MachineOperand RegOp = DVInsn->getOperand(0);
1669       // If the second operand is an immediate, this is an indirect value.
1670       if (DVInsn->getOperand(1).isImm()) {
1671         MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1672         addVariableAddress(*DV, VariableDie, Location);
1673       } else if (RegOp.getReg())
1674         addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1675     } else if (DVInsn->getOperand(0).isImm())
1676       addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1677     else if (DVInsn->getOperand(0).isFPImm())
1678       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1679     else if (DVInsn->getOperand(0).isCImm())
1680       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1681                        DV->getType().isUnsignedDIType());
1682
1683     DV->setDIE(VariableDie);
1684     return VariableDie;
1685   } else {
1686     // .. else use frame index.
1687     int FI = DV->getFrameIndex();
1688     if (FI != ~0) {
1689       unsigned FrameReg = 0;
1690       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1691       int Offset =
1692         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1693       MachineLocation Location(FrameReg, Offset);
1694       addVariableAddress(*DV, VariableDie, Location);
1695     }
1696   }
1697
1698   DV->setDIE(VariableDie);
1699   return VariableDie;
1700 }
1701
1702 /// createMemberDIE - Create new member DIE.
1703 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1704   DIE *MemberDie = new DIE(DT.getTag());
1705   StringRef Name = DT.getName();
1706   if (!Name.empty())
1707     addString(MemberDie, dwarf::DW_AT_name, Name);
1708
1709   addType(MemberDie, DT.getTypeDerivedFrom());
1710
1711   addSourceLine(MemberDie, DT);
1712
1713   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1714   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1715
1716   uint64_t Size = DT.getSizeInBits();
1717   uint64_t FieldSize = DT.getOriginalTypeSize();
1718
1719   if (Size != FieldSize) {
1720     // Handle bitfield.
1721     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1722     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1723
1724     uint64_t Offset = DT.getOffsetInBits();
1725     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1726     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1727     uint64_t FieldOffset = (HiMark - FieldSize);
1728     Offset -= FieldOffset;
1729
1730     // Maybe we need to work from the other end.
1731     if (Asm->getDataLayout().isLittleEndian())
1732       Offset = FieldSize - (Offset + Size);
1733     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1734
1735     // Here WD_AT_data_member_location points to the anonymous
1736     // field that includes this bit field.
1737     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1738
1739   } else
1740     // This is not a bitfield.
1741     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1742
1743   if (DT.getTag() == dwarf::DW_TAG_inheritance
1744       && DT.isVirtual()) {
1745
1746     // For C++, virtual base classes are not at fixed offset. Use following
1747     // expression to extract appropriate offset from vtable.
1748     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1749
1750     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1751     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1752     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1753     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1754     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1755     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1756     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1757     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1758
1759     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1760              VBaseLocationDie);
1761   } else
1762     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1763
1764   if (DT.isProtected())
1765     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1766             dwarf::DW_ACCESS_protected);
1767   else if (DT.isPrivate())
1768     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1769             dwarf::DW_ACCESS_private);
1770   // Otherwise C++ member and base classes are considered public.
1771   else
1772     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1773             dwarf::DW_ACCESS_public);
1774   if (DT.isVirtual())
1775     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1776             dwarf::DW_VIRTUALITY_virtual);
1777
1778   // Objective-C properties.
1779   if (MDNode *PNode = DT.getObjCProperty())
1780     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1781       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1782                           PropertyDie);
1783
1784   if (DT.isArtificial())
1785     addFlag(MemberDie, dwarf::DW_AT_artificial);
1786
1787   return MemberDie;
1788 }
1789
1790 /// createStaticMemberDIE - Create new DIE for C++ static member.
1791 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1792   if (!DT.Verify())
1793     return NULL;
1794
1795   DIE *StaticMemberDIE = new DIE(DT.getTag());
1796   DIType Ty = DT.getTypeDerivedFrom();
1797
1798   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1799   addType(StaticMemberDIE, Ty);
1800   addSourceLine(StaticMemberDIE, DT);
1801   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1802   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1803
1804   // FIXME: We could omit private if the parent is a class_type, and
1805   // public if the parent is something else.
1806   if (DT.isProtected())
1807     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1808             dwarf::DW_ACCESS_protected);
1809   else if (DT.isPrivate())
1810     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1811             dwarf::DW_ACCESS_private);
1812   else
1813     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1814             dwarf::DW_ACCESS_public);
1815
1816   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1817     addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1818   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1819     addConstantFPValue(StaticMemberDIE, CFP);
1820
1821   insertDIE(DT, StaticMemberDIE);
1822   return StaticMemberDIE;
1823 }