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