lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

   1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for constructing a dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfAccelTable.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/DIBuilder.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DataLayout.h"
  23 #include "llvm/IR/GlobalVariable.h"
  24 #include "llvm/IR/Instructions.h"
  25 #include "llvm/Support/Debug.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Target/Mangler.h"
  28 #include "llvm/Target/TargetFrameLowering.h"
  29 #include "llvm/Target/TargetMachine.h"
  30 #include "llvm/Target/TargetLoweringObjectFile.h"
  31 #include "llvm/Target/TargetRegisterInfo.h"
  32
  33 using namespace llvm;
  34
  35 /// CompileUnit - Compile unit constructor.
  36 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
  37                          DwarfDebug *DW, DwarfUnits *DWU)
  38     : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0),
  39       DebugInfoOffset(0) {
  40   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  41   insertDIE(N, D);
  42 }
  43
  44 /// ~CompileUnit - Destructor for compile unit.
  45 CompileUnit::~CompileUnit() {
  46   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  47     DIEBlocks[j]->~DIEBlock();
  48 }
  49
  50 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  51 /// information entry.
  52 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
  53   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  54   return Value;
  55 }
  56
  57 /// getDefaultLowerBound - Return the default lower bound for an array. If the
  58 /// DWARF version doesn't handle the language, return -1.
  59 int64_t CompileUnit::getDefaultLowerBound() const {
  60   switch (DICompileUnit(Node).getLanguage()) {
  61   default:
  62     break;
  63
  64   case dwarf::DW_LANG_C89:
  65   case dwarf::DW_LANG_C99:
  66   case dwarf::DW_LANG_C:
  67   case dwarf::DW_LANG_C_plus_plus:
  68   case dwarf::DW_LANG_ObjC:
  69   case dwarf::DW_LANG_ObjC_plus_plus:
  70     return 0;
  71
  72   case dwarf::DW_LANG_Fortran77:
  73   case dwarf::DW_LANG_Fortran90:
  74   case dwarf::DW_LANG_Fortran95:
  75     return 1;
  76
  77   // The languages below have valid values only if the DWARF version >= 4.
  78   case dwarf::DW_LANG_Java:
  79   case dwarf::DW_LANG_Python:
  80   case dwarf::DW_LANG_UPC:
  81   case dwarf::DW_LANG_D:
  82     if (dwarf::DWARF_VERSION >= 4)
  83       return 0;
  84     break;
  85
  86   case dwarf::DW_LANG_Ada83:
  87   case dwarf::DW_LANG_Ada95:
  88   case dwarf::DW_LANG_Cobol74:
  89   case dwarf::DW_LANG_Cobol85:
  90   case dwarf::DW_LANG_Modula2:
  91   case dwarf::DW_LANG_Pascal83:
  92   case dwarf::DW_LANG_PLI:
  93     if (dwarf::DWARF_VERSION >= 4)
  94       return 1;
  95     break;
  96   }
  97
  98   return -1;
  99 }
 100
 101 /// addFlag - Add a flag that is true.
 102 void CompileUnit::addFlag(DIE *Die, uint16_t Attribute) {
 103   if (DD->getDwarfVersion() >= 4)
 104     Die->addValue(Attribute, dwarf::DW_FORM_flag_present,
 105                   DIEIntegerOne);
 106   else
 107     addUInt(Die, Attribute, dwarf::DW_FORM_flag, 1);
 108 }
 109
 110 /// addUInt - Add an unsigned integer attribute data and value.
 111 ///
 112 void CompileUnit::addUInt(DIE *Die, uint16_t Attribute,
 113                           uint16_t Form, uint64_t Integer) {
 114   if (!Form) Form = DIEInteger::BestForm(false, Integer);
 115   DIEValue *Value = Integer == 1 ?
 116     DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
 117   Die->addValue(Attribute, Form, Value);
 118 }
 119
 120 /// addSInt - Add an signed integer attribute data and value.
 121 ///
 122 void CompileUnit::addSInt(DIE *Die, uint16_t Attribute,
 123                           uint16_t Form, int64_t Integer) {
 124   if (!Form) Form = DIEInteger::BestForm(true, Integer);
 125   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
 126   Die->addValue(Attribute, Form, Value);
 127 }
 128
 129 /// addString - Add a string attribute data and value. We always emit a
 130 /// reference to the string pool instead of immediate strings so that DIEs have
 131 /// more predictable sizes. In the case of split dwarf we emit an index
 132 /// into another table which gets us the static offset into the string
 133 /// table.
 134 void CompileUnit::addString(DIE *Die, uint16_t Attribute, StringRef String) {
 135   DIEValue *Value;
 136   uint16_t Form;
 137   if (!DD->useSplitDwarf()) {
 138     MCSymbol *Symb = DU->getStringPoolEntry(String);
 139     if (Asm->needsRelocationsForDwarfStringPool())
 140       Value = new (DIEValueAllocator) DIELabel(Symb);
 141     else {
 142       MCSymbol *StringPool = DU->getStringPoolSym();
 143       Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
 144     }
 145     Form = dwarf::DW_FORM_strp;
 146   } else {
 147     unsigned idx = DU->getStringPoolIndex(String);
 148     Value = new (DIEValueAllocator) DIEInteger(idx);
 149     Form = dwarf::DW_FORM_GNU_str_index;
 150   }
 151   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
 152   Die->addValue(Attribute, Form, Str);
 153 }
 154
 155 /// addLocalString - Add a string attribute data and value. This is guaranteed
 156 /// to be in the local string pool instead of indirected.
 157 void CompileUnit::addLocalString(DIE *Die, uint16_t Attribute,
 158                                  StringRef String) {
 159   MCSymbol *Symb = DU->getStringPoolEntry(String);
 160   DIEValue *Value;
 161   if (Asm->needsRelocationsForDwarfStringPool())
 162     Value = new (DIEValueAllocator) DIELabel(Symb);
 163   else {
 164     MCSymbol *StringPool = DU->getStringPoolSym();
 165     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
 166   }
 167   Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
 168 }
 169
 170 /// addExpr - Add a Dwarf expression attribute data and value.
 171 ///
 172 void CompileUnit::addExpr(DIE *Die, uint16_t Attribute, uint16_t Form,
 173                           const MCExpr *Expr) {
 174   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
 175   Die->addValue(Attribute, Form, Value);
 176 }
 177
 178 /// addLabel - Add a Dwarf label attribute data and value.
 179 ///
 180 void CompileUnit::addLabel(DIE *Die, uint16_t Attribute, uint16_t Form,
 181                            const MCSymbol *Label) {
 182   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 183   Die->addValue(Attribute, Form, Value);
 184 }
 185
 186 /// addLabelAddress - Add a dwarf label attribute data and value using
 187 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
 188 ///
 189 void CompileUnit::addLabelAddress(DIE *Die, uint16_t Attribute,
 190                                   MCSymbol *Label) {
 191   if (!DD->useSplitDwarf()) {
 192     if (Label != NULL) {
 193       DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
 194       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
 195     } else {
 196       DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
 197       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
 198     }
 199   } else {
 200     unsigned idx = DU->getAddrPoolIndex(Label);
 201     DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
 202     Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
 203   }
 204 }
 205
 206 /// addOpAddress - Add a dwarf op address data and value using the
 207 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
 208 ///
 209 void CompileUnit::addOpAddress(DIE *Die, const MCSymbol *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   if (DIE *ContextDIE = getOrCreateContextDIE(Context))
 762     ContextDIE->addChild(Die);
 763   else
 764     addDie(Die);
 765 }
 766
 767 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 768 /// given DIType.
 769 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 770   DIType Ty(TyNode);
 771   if (!Ty.isType())
 772     return NULL;
 773   DIE *TyDIE = getDIE(Ty);
 774   if (TyDIE)
 775     return TyDIE;
 776
 777   // Create new type.
 778   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 779   insertDIE(Ty, TyDIE);
 780   if (Ty.isBasicType())
 781     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 782   else if (Ty.isCompositeType())
 783     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 784   else {
 785     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 786     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 787   }
 788   // If this is a named finished type then include it in the list of types
 789   // for the accelerator tables.
 790   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 791     bool IsImplementation = 0;
 792     if (Ty.isCompositeType()) {
 793       DICompositeType CT(Ty);
 794       // A runtime language of 0 actually means C/C++ and that any
 795       // non-negative value is some version of Objective-C/C++.
 796       IsImplementation = (CT.getRunTimeLang() == 0) ||
 797         CT.isObjcClassComplete();
 798     }
 799     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 800     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
 801   }
 802
 803   addToContextOwner(TyDIE, Ty.getContext());
 804   return TyDIE;
 805 }
 806
 807 /// addType - Add a new type attribute to the specified entity.
 808 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
 809   assert(Ty && "Trying to add a type that doesn't exist?");
 810
 811   // Check for pre-existence.
 812   DIEEntry *Entry = getDIEEntry(Ty);
 813   // If it exists then use the existing value.
 814   if (Entry) {
 815     Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
 816     return;
 817   }
 818
 819   // Construct type.
 820   DIE *Buffer = getOrCreateTypeDIE(Ty);
 821
 822   // Set up proxy.
 823   Entry = createDIEEntry(Buffer);
 824   insertDIEEntry(Ty, Entry);
 825   Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
 826
 827   // If this is a complete composite type then include it in the
 828   // list of global types.
 829   addGlobalType(Ty);
 830 }
 831
 832 /// addGlobalType - Add a new global type to the compile unit.
 833 ///
 834 void CompileUnit::addGlobalType(DIType Ty) {
 835   DIDescriptor Context = Ty.getContext();
 836   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
 837       && (!Context || Context.isCompileUnit() || Context.isFile()
 838           || Context.isNameSpace()))
 839     if (DIEEntry *Entry = getDIEEntry(Ty))
 840       GlobalTypes[Ty.getName()] = Entry->getEntry();
 841 }
 842
 843 /// addPubTypes - Add type for pubtypes section.
 844 void CompileUnit::addPubTypes(DISubprogram SP) {
 845   DICompositeType SPTy = SP.getType();
 846   uint16_t SPTag = SPTy.getTag();
 847   if (SPTag != dwarf::DW_TAG_subroutine_type)
 848     return;
 849
 850   DIArray Args = SPTy.getTypeArray();
 851   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 852     DIType ATy(Args.getElement(i));
 853     if (!ATy.isType())
 854       continue;
 855     addGlobalType(ATy);
 856   }
 857 }
 858
 859 /// constructTypeDIE - Construct basic type die from DIBasicType.
 860 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 861   // Get core information.
 862   StringRef Name = BTy.getName();
 863   // Add name if not anonymous or intermediate type.
 864   if (!Name.empty())
 865     addString(&Buffer, dwarf::DW_AT_name, Name);
 866
 867   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 868     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 869     // An unspecified type only has a name attribute.
 870     return;
 871   }
 872
 873   Buffer.setTag(dwarf::DW_TAG_base_type);
 874   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 875           BTy.getEncoding());
 876
 877   uint64_t Size = BTy.getSizeInBits() >> 3;
 878   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 879 }
 880
 881 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 882 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 883   // Get core information.
 884   StringRef Name = DTy.getName();
 885   uint64_t Size = DTy.getSizeInBits() >> 3;
 886   uint16_t Tag = DTy.getTag();
 887
 888   // FIXME - Workaround for templates.
 889   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 890
 891   Buffer.setTag(Tag);
 892
 893   // Map to main type, void will not have a type.
 894   DIType FromTy = DTy.getTypeDerivedFrom();
 895   if (FromTy)
 896     addType(&Buffer, FromTy);
 897
 898   // Add name if not anonymous or intermediate type.
 899   if (!Name.empty())
 900     addString(&Buffer, dwarf::DW_AT_name, Name);
 901
 902   // Add size if non-zero (derived types might be zero-sized.)
 903   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 904     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 905
 906   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 907       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 908                   getOrCreateTypeDIE(DD->resolve(DTy.getClassType())));
 909   // Add source line info if available and TyDesc is not a forward declaration.
 910   if (!DTy.isForwardDecl())
 911     addSourceLine(&Buffer, DTy);
 912 }
 913
 914 /// Return true if the type is appropriately scoped to be contained inside
 915 /// its own type unit.
 916 static bool isTypeUnitScoped(DIType Ty) {
 917   DIScope Parent = Ty.getContext();
 918   while (Parent) {
 919     // Don't generate a hash for anything scoped inside a function.
 920     if (Parent.isSubprogram())
 921       return false;
 922     Parent = Parent.getContext();
 923   }
 924   return true;
 925 }
 926
 927 /// Return true if the type should be split out into a type unit.
 928 static bool shouldCreateTypeUnit(DICompositeType CTy) {
 929   uint16_t Tag = CTy.getTag();
 930
 931   switch (Tag) {
 932   case dwarf::DW_TAG_structure_type:
 933   case dwarf::DW_TAG_union_type:
 934   case dwarf::DW_TAG_enumeration_type:
 935   case dwarf::DW_TAG_class_type:
 936     // If this is a class, structure, union, or enumeration type
 937     // that is not a declaration, is a type definition, and not scoped
 938     // inside a function then separate this out as a type unit.
 939     if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy))
 940       return 0;
 941     return 1;
 942   default:
 943     return 0;
 944   }
 945 }
 946
 947 /// constructTypeDIE - Construct type DIE from DICompositeType.
 948 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 949   // Get core information.
 950   StringRef Name = CTy.getName();
 951
 952   uint64_t Size = CTy.getSizeInBits() >> 3;
 953   uint16_t Tag = CTy.getTag();
 954   Buffer.setTag(Tag);
 955
 956   switch (Tag) {
 957   case dwarf::DW_TAG_array_type:
 958     constructArrayTypeDIE(Buffer, &CTy);
 959     break;
 960   case dwarf::DW_TAG_enumeration_type: {
 961     DIArray Elements = CTy.getTypeArray();
 962
 963     // Add enumerators to enumeration type.
 964     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 965       DIE *ElemDie = NULL;
 966       DIDescriptor Enum(Elements.getElement(i));
 967       if (Enum.isEnumerator()) {
 968         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 969         Buffer.addChild(ElemDie);
 970       }
 971     }
 972     DIType DTy = CTy.getTypeDerivedFrom();
 973     if (DTy) {
 974       addType(&Buffer, DTy);
 975       addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
 976     }
 977   }
 978     break;
 979   case dwarf::DW_TAG_subroutine_type: {
 980     // Add return type. A void return won't have a type.
 981     DIArray Elements = CTy.getTypeArray();
 982     DIDescriptor RTy = Elements.getElement(0);
 983     if (RTy)
 984       addType(&Buffer, DIType(RTy));
 985
 986     bool isPrototyped = true;
 987     // Add arguments.
 988     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 989       DIDescriptor Ty = Elements.getElement(i);
 990       if (Ty.isUnspecifiedParameter()) {
 991         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 992         Buffer.addChild(Arg);
 993         isPrototyped = false;
 994       } else {
 995         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 996         addType(Arg, DIType(Ty));
 997         if (DIType(Ty).isArtificial())
 998           addFlag(Arg, dwarf::DW_AT_artificial);
 999         Buffer.addChild(Arg);
1000       }
1001     }
1002     // Add prototype flag if we're dealing with a C language and the
1003     // function has been prototyped.
1004     uint16_t Language = DICompileUnit(Node).getLanguage();
1005     if (isPrototyped &&
1006         (Language == dwarf::DW_LANG_C89 ||
1007          Language == dwarf::DW_LANG_C99 ||
1008          Language == dwarf::DW_LANG_ObjC))
1009       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1010   }
1011     break;
1012   case dwarf::DW_TAG_structure_type:
1013   case dwarf::DW_TAG_union_type:
1014   case dwarf::DW_TAG_class_type: {
1015     // Add elements to structure type.
1016     DIArray Elements = CTy.getTypeArray();
1017     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1018       DIDescriptor Element = Elements.getElement(i);
1019       DIE *ElemDie = NULL;
1020       if (Element.isSubprogram()) {
1021         DISubprogram SP(Element);
1022         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1023         if (SP.isProtected())
1024           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1025                   dwarf::DW_ACCESS_protected);
1026         else if (SP.isPrivate())
1027           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1028                   dwarf::DW_ACCESS_private);
1029         else
1030           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1031             dwarf::DW_ACCESS_public);
1032         if (SP.isExplicit())
1033           addFlag(ElemDie, dwarf::DW_AT_explicit);
1034       } else if (Element.isDerivedType()) {
1035         DIDerivedType DDTy(Element);
1036         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1037           ElemDie = new DIE(dwarf::DW_TAG_friend);
1038           addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1039         } else if (DDTy.isStaticMember())
1040           ElemDie = createStaticMemberDIE(DDTy);
1041         else
1042           ElemDie = createMemberDIE(DDTy);
1043       } else if (Element.isObjCProperty()) {
1044         DIObjCProperty Property(Element);
1045         ElemDie = new DIE(Property.getTag());
1046         StringRef PropertyName = Property.getObjCPropertyName();
1047         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1048         addType(ElemDie, Property.getType());
1049         addSourceLine(ElemDie, Property);
1050         StringRef GetterName = Property.getObjCPropertyGetterName();
1051         if (!GetterName.empty())
1052           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1053         StringRef SetterName = Property.getObjCPropertySetterName();
1054         if (!SetterName.empty())
1055           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1056         unsigned PropertyAttributes = 0;
1057         if (Property.isReadOnlyObjCProperty())
1058           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1059         if (Property.isReadWriteObjCProperty())
1060           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1061         if (Property.isAssignObjCProperty())
1062           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1063         if (Property.isRetainObjCProperty())
1064           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1065         if (Property.isCopyObjCProperty())
1066           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1067         if (Property.isNonAtomicObjCProperty())
1068           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1069         if (PropertyAttributes)
1070           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1071                  PropertyAttributes);
1072
1073         DIEEntry *Entry = getDIEEntry(Element);
1074         if (!Entry) {
1075           Entry = createDIEEntry(ElemDie);
1076           insertDIEEntry(Element, Entry);
1077         }
1078       } else
1079         continue;
1080       Buffer.addChild(ElemDie);
1081     }
1082
1083     if (CTy.isAppleBlockExtension())
1084       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1085
1086     DICompositeType ContainingType(DD->resolve(CTy.getContainingType()));
1087     if (DIDescriptor(ContainingType).isCompositeType())
1088       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1089                   getOrCreateTypeDIE(DIType(ContainingType)));
1090     else
1091       addToContextOwner(&Buffer, CTy.getContext());
1092
1093     if (CTy.isObjcClassComplete())
1094       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1095
1096     // Add template parameters to a class, structure or union types.
1097     // FIXME: The support isn't in the metadata for this yet.
1098     if (Tag == dwarf::DW_TAG_class_type ||
1099         Tag == dwarf::DW_TAG_structure_type ||
1100         Tag == dwarf::DW_TAG_union_type)
1101       addTemplateParams(Buffer, CTy.getTemplateParams());
1102
1103     break;
1104   }
1105   default:
1106     break;
1107   }
1108
1109   // Add name if not anonymous or intermediate type.
1110   if (!Name.empty())
1111     addString(&Buffer, dwarf::DW_AT_name, Name);
1112
1113   if (Tag == dwarf::DW_TAG_enumeration_type ||
1114       Tag == dwarf::DW_TAG_class_type ||
1115       Tag == dwarf::DW_TAG_structure_type ||
1116       Tag == dwarf::DW_TAG_union_type) {
1117     // Add size if non-zero (derived types might be zero-sized.)
1118     // TODO: Do we care about size for enum forward declarations?
1119     if (Size)
1120       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1121     else if (!CTy.isForwardDecl())
1122       // Add zero size if it is not a forward declaration.
1123       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1124
1125     // If we're a forward decl, say so.
1126     if (CTy.isForwardDecl())
1127       addFlag(&Buffer, dwarf::DW_AT_declaration);
1128
1129     // Add source line info if available.
1130     if (!CTy.isForwardDecl())
1131       addSourceLine(&Buffer, CTy);
1132
1133     // No harm in adding the runtime language to the declaration.
1134     unsigned RLang = CTy.getRunTimeLang();
1135     if (RLang)
1136       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1137               dwarf::DW_FORM_data1, RLang);
1138   }
1139   // If this is a type applicable to a type unit it then add it to the
1140   // list of types we'll compute a hash for later.
1141   if (shouldCreateTypeUnit(CTy))
1142     DD->addTypeUnitType(&Buffer);
1143 }
1144
1145 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1146 /// for the given DITemplateTypeParameter.
1147 DIE *
1148 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1149   DIE *ParamDIE = getDIE(TP);
1150   if (ParamDIE)
1151     return ParamDIE;
1152
1153   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1154   // Add the type if it exists, it could be void and therefore no type.
1155   if (TP.getType())
1156     addType(ParamDIE, TP.getType());
1157   if (!TP.getName().empty())
1158     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1159   return ParamDIE;
1160 }
1161
1162 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1163 /// for the given DITemplateValueParameter.
1164 DIE *
1165 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1166   DIE *ParamDIE = getDIE(VP);
1167   if (ParamDIE)
1168     return ParamDIE;
1169
1170   ParamDIE = new DIE(VP.getTag());
1171
1172   // Add the type if there is one, template template and template parameter
1173   // packs will not have a type.
1174   if (VP.getType())
1175     addType(ParamDIE, VP.getType());
1176   if (!VP.getName().empty())
1177     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1178   if (Value *Val = VP.getValue()) {
1179     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1180       addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1181     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1182       // For declaration non-type template parameters (such as global values and
1183       // functions)
1184       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1185       addOpAddress(Block, Asm->Mang->getSymbol(GV));
1186       // Emit DW_OP_stack_value to use the address as the immediate value of the
1187       // parameter, rather than a pointer to it.
1188       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1189       addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1190     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1191       assert(isa<MDString>(Val));
1192       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1193                 cast<MDString>(Val)->getString());
1194     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1195       assert(isa<MDNode>(Val));
1196       DIArray A(cast<MDNode>(Val));
1197       addTemplateParams(*ParamDIE, A);
1198     }
1199   }
1200
1201   return ParamDIE;
1202 }
1203
1204 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1205 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1206   DIE *NDie = getDIE(NS);
1207   if (NDie)
1208     return NDie;
1209   NDie = new DIE(dwarf::DW_TAG_namespace);
1210   insertDIE(NS, NDie);
1211   if (!NS.getName().empty()) {
1212     addString(NDie, dwarf::DW_AT_name, NS.getName());
1213     addAccelNamespace(NS.getName(), NDie);
1214   } else
1215     addAccelNamespace("(anonymous namespace)", NDie);
1216   addSourceLine(NDie, NS);
1217   addToContextOwner(NDie, NS.getContext());
1218   return NDie;
1219 }
1220
1221 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1222 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1223   DIE *SPDie = getDIE(SP);
1224   if (SPDie)
1225     return SPDie;
1226
1227   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1228
1229   // DW_TAG_inlined_subroutine may refer to this DIE.
1230   insertDIE(SP, SPDie);
1231
1232   DISubprogram SPDecl = SP.getFunctionDeclaration();
1233   DIE *DeclDie = NULL;
1234   if (SPDecl.isSubprogram()) {
1235     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1236   }
1237
1238   // Add to context owner.
1239   addToContextOwner(SPDie, SP.getContext());
1240
1241   // Add function template parameters.
1242   addTemplateParams(*SPDie, SP.getTemplateParams());
1243
1244   // If this DIE is going to refer declaration info using AT_specification
1245   // then there is no need to add other attributes.
1246   if (DeclDie) {
1247     // Refer function declaration directly.
1248     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1249                 DeclDie);
1250
1251     return SPDie;
1252   }
1253
1254   // Add the linkage name if we have one.
1255   StringRef LinkageName = SP.getLinkageName();
1256   if (!LinkageName.empty())
1257     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1258               GlobalValue::getRealLinkageName(LinkageName));
1259
1260   // Constructors and operators for anonymous aggregates do not have names.
1261   if (!SP.getName().empty())
1262     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1263
1264   addSourceLine(SPDie, SP);
1265
1266   // Add the prototype if we have a prototype and we have a C like
1267   // language.
1268   uint16_t Language = DICompileUnit(Node).getLanguage();
1269   if (SP.isPrototyped() &&
1270       (Language == dwarf::DW_LANG_C89 ||
1271        Language == dwarf::DW_LANG_C99 ||
1272        Language == dwarf::DW_LANG_ObjC))
1273     addFlag(SPDie, dwarf::DW_AT_prototyped);
1274
1275   // Add Return Type. A void return type will not have a type.
1276   DICompositeType SPTy = SP.getType();
1277   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1278          "the type of a subprogram should be a subroutine");
1279
1280   DIArray Args = SPTy.getTypeArray();
1281   if (Args.getElement(0))
1282     addType(SPDie, DIType(Args.getElement(0)));
1283
1284   unsigned VK = SP.getVirtuality();
1285   if (VK) {
1286     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1287     DIEBlock *Block = getDIEBlock();
1288     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1289     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1290     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1291     ContainingTypeMap.insert(std::make_pair(SPDie,
1292                                             SP.getContainingType()));
1293   }
1294
1295   if (!SP.isDefinition()) {
1296     addFlag(SPDie, dwarf::DW_AT_declaration);
1297
1298     // Add arguments. Do not add arguments for subprogram definition. They will
1299     // be handled while processing variables.
1300     for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1301       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1302       DIType ATy = DIType(Args.getElement(i));
1303       addType(Arg, ATy);
1304       if (ATy.isArtificial())
1305         addFlag(Arg, dwarf::DW_AT_artificial);
1306       SPDie->addChild(Arg);
1307     }
1308   }
1309
1310   if (SP.isArtificial())
1311     addFlag(SPDie, dwarf::DW_AT_artificial);
1312
1313   if (!SP.isLocalToUnit())
1314     addFlag(SPDie, dwarf::DW_AT_external);
1315
1316   if (SP.isOptimized())
1317     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1318
1319   if (unsigned isa = Asm->getISAEncoding()) {
1320     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1321   }
1322
1323   return SPDie;
1324 }
1325
1326 // Return const expression if value is a GEP to access merged global
1327 // constant. e.g.
1328 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1329 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1330   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1331   if (!CE || CE->getNumOperands() != 3 ||
1332       CE->getOpcode() != Instruction::GetElementPtr)
1333     return NULL;
1334
1335   // First operand points to a global struct.
1336   Value *Ptr = CE->getOperand(0);
1337   if (!isa<GlobalValue>(Ptr) ||
1338       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1339     return NULL;
1340
1341   // Second operand is zero.
1342   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1343   if (!CI || !CI->isZero())
1344     return NULL;
1345
1346   // Third operand is offset.
1347   if (!isa<ConstantInt>(CE->getOperand(2)))
1348     return NULL;
1349
1350   return CE;
1351 }
1352
1353 /// createGlobalVariableDIE - create global variable DIE.
1354 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1355   // Check for pre-existence.
1356   if (getDIE(N))
1357     return;
1358
1359   DIGlobalVariable GV(N);
1360   if (!GV.isGlobalVariable())
1361     return;
1362
1363   DIDescriptor GVContext = GV.getContext();
1364   DIType GTy = GV.getType();
1365
1366   // If this is a static data member definition, some attributes belong
1367   // to the declaration DIE.
1368   DIE *VariableDIE = NULL;
1369   bool IsStaticMember = false;
1370   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1371   if (SDMDecl.Verify()) {
1372     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1373     // We need the declaration DIE that is in the static member's class.
1374     // But that class might not exist in the DWARF yet.
1375     // Creating the class will create the static member decl DIE.
1376     getOrCreateContextDIE(SDMDecl.getContext());
1377     VariableDIE = getDIE(SDMDecl);
1378     assert(VariableDIE && "Static member decl has no context?");
1379     IsStaticMember = true;
1380   }
1381
1382   // If this is not a static data member definition, create the variable
1383   // DIE and add the initial set of attributes to it.
1384   if (!VariableDIE) {
1385     VariableDIE = new DIE(GV.getTag());
1386     // Add to map.
1387     insertDIE(N, VariableDIE);
1388
1389     // Add name and type.
1390     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1391     addType(VariableDIE, GTy);
1392
1393     // Add scoping info.
1394     if (!GV.isLocalToUnit()) {
1395       addFlag(VariableDIE, dwarf::DW_AT_external);
1396       addGlobalName(GV.getName(), VariableDIE);
1397     }
1398
1399     // Add line number info.
1400     addSourceLine(VariableDIE, GV);
1401     // Add to context owner.
1402     addToContextOwner(VariableDIE, GVContext);
1403   }
1404
1405   // Add location.
1406   bool addToAccelTable = false;
1407   DIE *VariableSpecDIE = NULL;
1408   bool isGlobalVariable = GV.getGlobal() != NULL;
1409   if (isGlobalVariable) {
1410     addToAccelTable = true;
1411     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1412     const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1413     if (GV.getGlobal()->isThreadLocal()) {
1414       // FIXME: Make this work with -gsplit-dwarf.
1415       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1416       assert((PointerSize == 4 || PointerSize == 8) &&
1417              "Add support for other sizes if necessary");
1418       const MCExpr *Expr =
1419           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1420       // Based on GCC's support for TLS:
1421       if (!DD->useSplitDwarf()) {
1422         // 1) Start with a constNu of the appropriate pointer size
1423         addUInt(Block, 0, dwarf::DW_FORM_data1,
1424                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1425         // 2) containing the (relocated) address of the TLS variable
1426         addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1427       } else {
1428         addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1429         addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1430       }
1431       // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1432       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1433     } else
1434       addOpAddress(Block, Sym);
1435     // Do not create specification DIE if context is either compile unit
1436     // or a subprogram.
1437     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1438         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1439       // Create specification DIE.
1440       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1441       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1442                   dwarf::DW_FORM_ref4, VariableDIE);
1443       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1444       // A static member's declaration is already flagged as such.
1445       if (!SDMDecl.Verify())
1446         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1447       addDie(VariableSpecDIE);
1448     } else {
1449       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1450     }
1451     // Add the linkage name.
1452     StringRef LinkageName = GV.getLinkageName();
1453     if (!LinkageName.empty())
1454       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1455       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1456       // TAG_variable.
1457       addString(IsStaticMember && VariableSpecDIE ?
1458                 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1459                 GlobalValue::getRealLinkageName(LinkageName));
1460   } else if (const ConstantInt *CI =
1461              dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1462     // AT_const_value was added when the static member was created. To avoid
1463     // emitting AT_const_value multiple times, we only add AT_const_value when
1464     // it is not a static member.
1465     if (!IsStaticMember)
1466       addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1467   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1468     addToAccelTable = true;
1469     // GV is a merged global.
1470     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1471     Value *Ptr = CE->getOperand(0);
1472     addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1473     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1474     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1475     addUInt(Block, 0, dwarf::DW_FORM_udata,
1476                    Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1477     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1478     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1479   }
1480
1481   if (addToAccelTable) {
1482     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1483     addAccelName(GV.getName(), AddrDIE);
1484
1485     // If the linkage name is different than the name, go ahead and output
1486     // that as well into the name table.
1487     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1488       addAccelName(GV.getLinkageName(), AddrDIE);
1489   }
1490 }
1491
1492 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1493 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1494                                        DIE *IndexTy) {
1495   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1496   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1497
1498   // The LowerBound value defines the lower bounds which is typically zero for
1499   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1500   // Count == -1 then the array is unbounded and we do not emit
1501   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1502   // Count == 0, then the array has zero elements in which case we do not emit
1503   // an upper bound.
1504   int64_t LowerBound = SR.getLo();
1505   int64_t DefaultLowerBound = getDefaultLowerBound();
1506   int64_t Count = SR.getCount();
1507
1508   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1509     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1510
1511   if (Count != -1 && Count != 0)
1512     // FIXME: An unbounded array should reference the expression that defines
1513     // the array.
1514     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1515
1516   Buffer.addChild(DW_Subrange);
1517 }
1518
1519 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1520 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1521                                         DICompositeType *CTy) {
1522   Buffer.setTag(dwarf::DW_TAG_array_type);
1523   if (CTy->isVector())
1524     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1525
1526   // Emit the element type.
1527   addType(&Buffer, CTy->getTypeDerivedFrom());
1528
1529   // Get an anonymous type for index type.
1530   // FIXME: This type should be passed down from the front end
1531   // as different languages may have different sizes for indexes.
1532   DIE *IdxTy = getIndexTyDie();
1533   if (!IdxTy) {
1534     // Construct an anonymous type for index type.
1535     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1536     addString(IdxTy, dwarf::DW_AT_name, "int");
1537     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1538     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1539             dwarf::DW_ATE_signed);
1540     addDie(IdxTy);
1541     setIndexTyDie(IdxTy);
1542   }
1543
1544   // Add subranges to array type.
1545   DIArray Elements = CTy->getTypeArray();
1546   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1547     DIDescriptor Element = Elements.getElement(i);
1548     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1549       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1550   }
1551 }
1552
1553 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1554 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1555   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1556   StringRef Name = ETy.getName();
1557   addString(Enumerator, dwarf::DW_AT_name, Name);
1558   int64_t Value = ETy.getEnumValue();
1559   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1560   return Enumerator;
1561 }
1562
1563 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1564 /// vtables.
1565 void CompileUnit::constructContainingTypeDIEs() {
1566   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1567          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1568     DIE *SPDie = CI->first;
1569     const MDNode *N = CI->second;
1570     if (!N) continue;
1571     DIE *NDie = getDIE(N);
1572     if (!NDie) continue;
1573     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1574   }
1575 }
1576
1577 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1578 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1579                                        bool isScopeAbstract) {
1580   StringRef Name = DV->getName();
1581
1582   // Translate tag to proper Dwarf tag.
1583   uint16_t Tag = DV->getTag();
1584
1585   // Define variable debug information entry.
1586   DIE *VariableDie = new DIE(Tag);
1587   DbgVariable *AbsVar = DV->getAbstractVariable();
1588   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1589   if (AbsDIE)
1590     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1591                             dwarf::DW_FORM_ref4, AbsDIE);
1592   else {
1593     if (!Name.empty())
1594       addString(VariableDie, dwarf::DW_AT_name, Name);
1595     addSourceLine(VariableDie, DV->getVariable());
1596     addType(VariableDie, DV->getType());
1597   }
1598
1599   if (DV->isArtificial())
1600     addFlag(VariableDie, dwarf::DW_AT_artificial);
1601
1602   if (isScopeAbstract) {
1603     DV->setDIE(VariableDie);
1604     return VariableDie;
1605   }
1606
1607   // Add variable address.
1608
1609   unsigned Offset = DV->getDotDebugLocOffset();
1610   if (Offset != ~0U) {
1611     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1612              Asm->GetTempSymbol("debug_loc", Offset));
1613     DV->setDIE(VariableDie);
1614     return VariableDie;
1615   }
1616
1617   // Check if variable is described by a DBG_VALUE instruction.
1618   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1619     assert(DVInsn->getNumOperands() == 3);
1620     if (DVInsn->getOperand(0).isReg()) {
1621       const MachineOperand RegOp = DVInsn->getOperand(0);
1622       // If the second operand is an immediate, this is an indirect value.
1623       if (DVInsn->getOperand(1).isImm()) {
1624         MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1625         addVariableAddress(*DV, VariableDie, Location);
1626       } else if (RegOp.getReg())
1627         addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1628     } else if (DVInsn->getOperand(0).isImm())
1629       addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1630     else if (DVInsn->getOperand(0).isFPImm())
1631       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1632     else if (DVInsn->getOperand(0).isCImm())
1633       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1634                        DV->getType().isUnsignedDIType());
1635
1636     DV->setDIE(VariableDie);
1637     return VariableDie;
1638   } else {
1639     // .. else use frame index.
1640     int FI = DV->getFrameIndex();
1641     if (FI != ~0) {
1642       unsigned FrameReg = 0;
1643       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1644       int Offset =
1645         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1646       MachineLocation Location(FrameReg, Offset);
1647       addVariableAddress(*DV, VariableDie, Location);
1648     }
1649   }
1650
1651   DV->setDIE(VariableDie);
1652   return VariableDie;
1653 }
1654
1655 /// createMemberDIE - Create new member DIE.
1656 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1657   DIE *MemberDie = new DIE(DT.getTag());
1658   StringRef Name = DT.getName();
1659   if (!Name.empty())
1660     addString(MemberDie, dwarf::DW_AT_name, Name);
1661
1662   addType(MemberDie, DT.getTypeDerivedFrom());
1663
1664   addSourceLine(MemberDie, DT);
1665
1666   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1667   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1668
1669   uint64_t Size = DT.getSizeInBits();
1670   uint64_t FieldSize = DT.getOriginalTypeSize();
1671
1672   if (Size != FieldSize) {
1673     // Handle bitfield.
1674     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1675     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1676
1677     uint64_t Offset = DT.getOffsetInBits();
1678     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1679     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1680     uint64_t FieldOffset = (HiMark - FieldSize);
1681     Offset -= FieldOffset;
1682
1683     // Maybe we need to work from the other end.
1684     if (Asm->getDataLayout().isLittleEndian())
1685       Offset = FieldSize - (Offset + Size);
1686     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1687
1688     // Here WD_AT_data_member_location points to the anonymous
1689     // field that includes this bit field.
1690     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1691
1692   } else
1693     // This is not a bitfield.
1694     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1695
1696   if (DT.getTag() == dwarf::DW_TAG_inheritance
1697       && DT.isVirtual()) {
1698
1699     // For C++, virtual base classes are not at fixed offset. Use following
1700     // expression to extract appropriate offset from vtable.
1701     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1702
1703     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1704     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1705     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1706     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1707     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1708     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1709     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1710     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1711
1712     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1713              VBaseLocationDie);
1714   } else
1715     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1716
1717   if (DT.isProtected())
1718     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1719             dwarf::DW_ACCESS_protected);
1720   else if (DT.isPrivate())
1721     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1722             dwarf::DW_ACCESS_private);
1723   // Otherwise C++ member and base classes are considered public.
1724   else
1725     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1726             dwarf::DW_ACCESS_public);
1727   if (DT.isVirtual())
1728     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1729             dwarf::DW_VIRTUALITY_virtual);
1730
1731   // Objective-C properties.
1732   if (MDNode *PNode = DT.getObjCProperty())
1733     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1734       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1735                           PropertyDie);
1736
1737   if (DT.isArtificial())
1738     addFlag(MemberDie, dwarf::DW_AT_artificial);
1739
1740   return MemberDie;
1741 }
1742
1743 /// createStaticMemberDIE - Create new DIE for C++ static member.
1744 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1745   if (!DT.Verify())
1746     return NULL;
1747
1748   DIE *StaticMemberDIE = new DIE(DT.getTag());
1749   DIType Ty = DT.getTypeDerivedFrom();
1750
1751   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1752   addType(StaticMemberDIE, Ty);
1753   addSourceLine(StaticMemberDIE, DT);
1754   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1755   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1756
1757   // FIXME: We could omit private if the parent is a class_type, and
1758   // public if the parent is something else.
1759   if (DT.isProtected())
1760     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1761             dwarf::DW_ACCESS_protected);
1762   else if (DT.isPrivate())
1763     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1764             dwarf::DW_ACCESS_private);
1765   else
1766     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1767             dwarf::DW_ACCESS_public);
1768
1769   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1770     addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1771   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1772     addConstantFPValue(StaticMemberDIE, CFP);
1773
1774   insertDIE(DT, StaticMemberDIE);
1775   return StaticMemberDIE;
1776 }