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