lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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