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