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 writing dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15
  16 #include "DwarfAccelTable.h"
  17 #include "DwarfCompileUnit.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/GlobalVariable.h"
  21 #include "llvm/Instructions.h"
  22 #include "llvm/Analysis/DIBuilder.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Target/Mangler.h"
  25 #include "llvm/Target/TargetData.h"
  26 #include "llvm/Target/TargetFrameLowering.h"
  27 #include "llvm/Target/TargetMachine.h"
  28 #include "llvm/Target/TargetRegisterInfo.h"
  29 #include "llvm/ADT/APFloat.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31
  32 using namespace llvm;
  33
  34 /// CompileUnit - Compile unit constructor.
  35 CompileUnit::CompileUnit(unsigned I, unsigned L, DIE *D, AsmPrinter *A,
  36                          DwarfDebug *DW)
  37   : ID(I), Language(L), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
  38   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  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 /// addUInt - Add an unsigned integer attribute data and value.
  55 ///
  56 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
  57                           unsigned Form, uint64_t Integer) {
  58   if (!Form) Form = DIEInteger::BestForm(false, Integer);
  59   DIEValue *Value = Integer == 1 ?
  60     DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
  61   Die->addValue(Attribute, Form, Value);
  62 }
  63
  64 /// addSInt - Add an signed integer attribute data and value.
  65 ///
  66 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
  67                           unsigned Form, int64_t Integer) {
  68   if (!Form) Form = DIEInteger::BestForm(true, Integer);
  69   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
  70   Die->addValue(Attribute, Form, Value);
  71 }
  72
  73 /// addString - Add a string attribute data and value. We always emit a
  74 /// reference to the string pool instead of immediate strings so that DIEs have
  75 /// more predictable sizes.
  76 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
  77   MCSymbol *Symb = DD->getStringPoolEntry(String);
  78   DIEValue *Value;
  79   if (Asm->needsRelocationsForDwarfStringPool())
  80     Value = new (DIEValueAllocator) DIELabel(Symb);
  81   else {
  82     MCSymbol *StringPool = DD->getStringPool();
  83     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
  84   }
  85   Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
  86 }
  87
  88 /// addLabel - Add a Dwarf label attribute data and value.
  89 ///
  90 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
  91                            const MCSymbol *Label) {
  92   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
  93   Die->addValue(Attribute, Form, Value);
  94 }
  95
  96 /// addDelta - Add a label delta attribute data and value.
  97 ///
  98 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
  99                            const MCSymbol *Hi, const MCSymbol *Lo) {
 100   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 101   Die->addValue(Attribute, Form, Value);
 102 }
 103
 104 /// addDIEEntry - Add a DIE attribute data and value.
 105 ///
 106 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
 107                               DIE *Entry) {
 108   Die->addValue(Attribute, Form, createDIEEntry(Entry));
 109 }
 110
 111 /// addBlock - Add block data.
 112 ///
 113 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
 114                            DIEBlock *Block) {
 115   Block->ComputeSize(Asm);
 116   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 117   Die->addValue(Attribute, Block->BestForm(), Block);
 118 }
 119
 120 /// addSourceLine - Add location information to specified debug information
 121 /// entry.
 122 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
 123   // Verify variable.
 124   if (!V.Verify())
 125     return;
 126
 127   unsigned Line = V.getLineNumber();
 128   if (Line == 0)
 129     return;
 130   unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
 131                                             V.getContext().getDirectory());
 132   assert(FileID && "Invalid file id");
 133   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 134   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 135 }
 136
 137 /// addSourceLine - Add location information to specified debug information
 138 /// entry.
 139 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
 140   // Verify global variable.
 141   if (!G.Verify())
 142     return;
 143
 144   unsigned Line = G.getLineNumber();
 145   if (Line == 0)
 146     return;
 147   unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(), G.getDirectory());
 148   assert(FileID && "Invalid file id");
 149   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 150   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 151 }
 152
 153 /// addSourceLine - Add location information to specified debug information
 154 /// entry.
 155 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
 156   // Verify subprogram.
 157   if (!SP.Verify())
 158     return;
 159   // If the line number is 0, don't add it.
 160   if (SP.getLineNumber() == 0)
 161     return;
 162
 163   unsigned Line = SP.getLineNumber();
 164   if (!SP.getContext().Verify())
 165     return;
 166   unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
 167                                             SP.getDirectory());
 168   assert(FileID && "Invalid file id");
 169   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 170   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 171 }
 172
 173 /// addSourceLine - Add location information to specified debug information
 174 /// entry.
 175 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
 176   // Verify type.
 177   if (!Ty.Verify())
 178     return;
 179
 180   unsigned Line = Ty.getLineNumber();
 181   if (Line == 0 || !Ty.getContext().Verify())
 182     return;
 183   unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
 184                                             Ty.getDirectory());
 185   assert(FileID && "Invalid file id");
 186   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 187   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 188 }
 189
 190 /// addSourceLine - Add location information to specified debug information
 191 /// entry.
 192 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
 193   // Verify namespace.
 194   if (!NS.Verify())
 195     return;
 196
 197   unsigned Line = NS.getLineNumber();
 198   if (Line == 0)
 199     return;
 200   StringRef FN = NS.getFilename();
 201
 202   unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
 203   assert(FileID && "Invalid file id");
 204   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 205   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 206 }
 207
 208 /// addVariableAddress - Add DW_AT_location attribute for a
 209 /// DbgVariable based on provided MachineLocation.
 210 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
 211                                      MachineLocation Location) {
 212   if (DV->variableHasComplexAddress())
 213     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
 214   else if (DV->isBlockByrefVariable())
 215     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
 216   else
 217     addAddress(Die, dwarf::DW_AT_location, Location);
 218 }
 219
 220 /// addRegisterOp - Add register operand.
 221 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
 222   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 223   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 224   if (DWReg < 32)
 225     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
 226   else {
 227     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 228     addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
 229   }
 230 }
 231
 232 /// addRegisterOffset - Add register offset.
 233 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
 234                                     int64_t Offset) {
 235   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 236   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 237   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
 238   if (Reg == TRI->getFrameRegister(*Asm->MF))
 239     // If variable offset is based in frame register then use fbreg.
 240     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
 241   else if (DWReg < 32)
 242     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
 243   else {
 244     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 245     addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
 246   }
 247   addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
 248 }
 249
 250 /// addAddress - Add an address attribute to a die based on the location
 251 /// provided.
 252 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
 253                              const MachineLocation &Location) {
 254   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 255
 256   if (Location.isReg())
 257     addRegisterOp(Block, Location.getReg());
 258   else
 259     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
 260
 261   // Now attach the location information to the DIE.
 262   addBlock(Die, Attribute, 0, Block);
 263 }
 264
 265 /// addComplexAddress - Start with the address based on the location provided,
 266 /// and generate the DWARF information necessary to find the actual variable
 267 /// given the extra address information encoded in the DIVariable, starting from
 268 /// the starting location.  Add the DWARF information to the die.
 269 ///
 270 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
 271                                     unsigned Attribute,
 272                                     const MachineLocation &Location) {
 273   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 274   unsigned N = DV->getNumAddrElements();
 275   unsigned i = 0;
 276   if (Location.isReg()) {
 277     if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
 278       // If first address element is OpPlus then emit
 279       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
 280       addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
 281       i = 2;
 282     } else
 283       addRegisterOp(Block, Location.getReg());
 284   }
 285   else
 286     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
 287
 288   for (;i < N; ++i) {
 289     uint64_t Element = DV->getAddrElement(i);
 290     if (Element == DIBuilder::OpPlus) {
 291       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 292       addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
 293     } else if (Element == DIBuilder::OpDeref) {
 294       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 295     } else llvm_unreachable("unknown DIBuilder Opcode");
 296   }
 297
 298   // Now attach the location information to the DIE.
 299   addBlock(Die, Attribute, 0, Block);
 300 }
 301
 302 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 303    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 304    gives the variable VarName either the struct, or a pointer to the struct, as
 305    its type.  This is necessary for various behind-the-scenes things the
 306    compiler needs to do with by-reference variables in Blocks.
 307
 308    However, as far as the original *programmer* is concerned, the variable
 309    should still have type 'SomeType', as originally declared.
 310
 311    The function getBlockByrefType dives into the __Block_byref_x_VarName
 312    struct to find the original type of the variable, which is then assigned to
 313    the variable's Debug Information Entry as its real type.  So far, so good.
 314    However now the debugger will expect the variable VarName to have the type
 315    SomeType.  So we need the location attribute for the variable to be an
 316    expression that explains to the debugger how to navigate through the
 317    pointers and struct to find the actual variable of type SomeType.
 318
 319    The following function does just that.  We start by getting
 320    the "normal" location for the variable. This will be the location
 321    of either the struct __Block_byref_x_VarName or the pointer to the
 322    struct __Block_byref_x_VarName.
 323
 324    The struct will look something like:
 325
 326    struct __Block_byref_x_VarName {
 327      ... <various fields>
 328      struct __Block_byref_x_VarName *forwarding;
 329      ... <various other fields>
 330      SomeType VarName;
 331      ... <maybe more fields>
 332    };
 333
 334    If we are given the struct directly (as our starting point) we
 335    need to tell the debugger to:
 336
 337    1).  Add the offset of the forwarding field.
 338
 339    2).  Follow that pointer to get the real __Block_byref_x_VarName
 340    struct to use (the real one may have been copied onto the heap).
 341
 342    3).  Add the offset for the field VarName, to find the actual variable.
 343
 344    If we started with a pointer to the struct, then we need to
 345    dereference that pointer first, before the other steps.
 346    Translating this into DWARF ops, we will need to append the following
 347    to the current location description for the variable:
 348
 349    DW_OP_deref                    -- optional, if we start with a pointer
 350    DW_OP_plus_uconst <forward_fld_offset>
 351    DW_OP_deref
 352    DW_OP_plus_uconst <varName_fld_offset>
 353
 354    That is what this function does.  */
 355
 356 /// addBlockByrefAddress - Start with the address based on the location
 357 /// provided, and generate the DWARF information necessary to find the
 358 /// actual Block variable (navigating the Block struct) based on the
 359 /// starting location.  Add the DWARF information to the die.  For
 360 /// more information, read large comment just above here.
 361 ///
 362 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
 363                                        unsigned Attribute,
 364                                        const MachineLocation &Location) {
 365   DIType Ty = DV->getType();
 366   DIType TmpTy = Ty;
 367   unsigned Tag = Ty.getTag();
 368   bool isPointer = false;
 369
 370   StringRef varName = DV->getName();
 371
 372   if (Tag == dwarf::DW_TAG_pointer_type) {
 373     DIDerivedType DTy = DIDerivedType(Ty);
 374     TmpTy = DTy.getTypeDerivedFrom();
 375     isPointer = true;
 376   }
 377
 378   DICompositeType blockStruct = DICompositeType(TmpTy);
 379
 380   // Find the __forwarding field and the variable field in the __Block_byref
 381   // struct.
 382   DIArray Fields = blockStruct.getTypeArray();
 383   DIDescriptor varField = DIDescriptor();
 384   DIDescriptor forwardingField = DIDescriptor();
 385
 386   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 387     DIDescriptor Element = Fields.getElement(i);
 388     DIDerivedType DT = DIDerivedType(Element);
 389     StringRef fieldName = DT.getName();
 390     if (fieldName == "__forwarding")
 391       forwardingField = Element;
 392     else if (fieldName == varName)
 393       varField = Element;
 394   }
 395
 396   // Get the offsets for the forwarding field and the variable field.
 397   unsigned forwardingFieldOffset =
 398     DIDerivedType(forwardingField).getOffsetInBits() >> 3;
 399   unsigned varFieldOffset =
 400     DIDerivedType(varField).getOffsetInBits() >> 3;
 401
 402   // Decode the original location, and use that as the start of the byref
 403   // variable's location.
 404   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 405   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 406   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 407
 408   if (Location.isReg()) {
 409     if (Reg < 32)
 410       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 411     else {
 412       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 413       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 414     }
 415   } else {
 416     if (Reg < 32)
 417       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 418     else {
 419       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 420       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 421     }
 422
 423     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 424   }
 425
 426   // If we started with a pointer to the __Block_byref... struct, then
 427   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 428   if (isPointer)
 429     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 430
 431   // Next add the offset for the '__forwarding' field:
 432   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 433   // adding the offset if it's 0.
 434   if (forwardingFieldOffset > 0) {
 435     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 436     addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
 437   }
 438
 439   // Now dereference the __forwarding field to get to the real __Block_byref
 440   // struct:  DW_OP_deref.
 441   addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 442
 443   // Now that we've got the real __Block_byref... struct, add the offset
 444   // for the variable's field to get to the location of the actual variable:
 445   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 446   if (varFieldOffset > 0) {
 447     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 448     addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
 449   }
 450
 451   // Now attach the location information to the DIE.
 452   addBlock(Die, Attribute, 0, Block);
 453 }
 454
 455 /// isTypeSigned - Return true if the type is signed.
 456 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
 457   if (Ty.isDerivedType())
 458     return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
 459   if (Ty.isBasicType())
 460     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
 461         || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
 462       *SizeInBits = Ty.getSizeInBits();
 463       return true;
 464     }
 465   return false;
 466 }
 467
 468 /// addConstantValue - Add constant value entry in variable DIE.
 469 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
 470                                    DIType Ty) {
 471   assert(MO.isImm() && "Invalid machine operand!");
 472   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 473   int SizeInBits = -1;
 474   bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
 475   unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
 476   switch (SizeInBits) {
 477     case 8:  Form = dwarf::DW_FORM_data1; break;
 478     case 16: Form = dwarf::DW_FORM_data2; break;
 479     case 32: Form = dwarf::DW_FORM_data4; break;
 480     case 64: Form = dwarf::DW_FORM_data8; break;
 481     default: break;
 482   }
 483   SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
 484     : addUInt(Block, 0, Form, MO.getImm());
 485
 486   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 487   return true;
 488 }
 489
 490 /// addConstantFPValue - Add constant value entry in variable DIE.
 491 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
 492   assert (MO.isFPImm() && "Invalid machine operand!");
 493   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 494   APFloat FPImm = MO.getFPImm()->getValueAPF();
 495
 496   // Get the raw data form of the floating point.
 497   const APInt FltVal = FPImm.bitcastToAPInt();
 498   const char *FltPtr = (const char*)FltVal.getRawData();
 499
 500   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 501   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 502   int Incr = (LittleEndian ? 1 : -1);
 503   int Start = (LittleEndian ? 0 : NumBytes - 1);
 504   int Stop = (LittleEndian ? NumBytes : -1);
 505
 506   // Output the constant to DWARF one byte at a time.
 507   for (; Start != Stop; Start += Incr)
 508     addUInt(Block, 0, dwarf::DW_FORM_data1,
 509             (unsigned char)0xFF & FltPtr[Start]);
 510
 511   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 512   return true;
 513 }
 514
 515 /// addConstantValue - Add constant value entry in variable DIE.
 516 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
 517                                    bool Unsigned) {
 518   unsigned CIBitWidth = CI->getBitWidth();
 519   if (CIBitWidth <= 64) {
 520     unsigned form = 0;
 521     switch (CIBitWidth) {
 522     case 8: form = dwarf::DW_FORM_data1; break;
 523     case 16: form = dwarf::DW_FORM_data2; break;
 524     case 32: form = dwarf::DW_FORM_data4; break;
 525     case 64: form = dwarf::DW_FORM_data8; break;
 526     default:
 527       form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
 528     }
 529     if (Unsigned)
 530       addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
 531     else
 532       addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
 533     return true;
 534   }
 535
 536   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 537
 538   // Get the raw data form of the large APInt.
 539   const APInt Val = CI->getValue();
 540   const uint64_t *Ptr64 = Val.getRawData();
 541
 542   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 543   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 544
 545   // Output the constant to DWARF one byte at a time.
 546   for (int i = 0; i < NumBytes; i++) {
 547     uint8_t c;
 548     if (LittleEndian)
 549       c = Ptr64[i / 8] >> (8 * (i & 7));
 550     else
 551       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 552     addUInt(Block, 0, dwarf::DW_FORM_data1, c);
 553   }
 554
 555   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 556   return true;
 557 }
 558
 559 /// addTemplateParams - Add template parameters in buffer.
 560 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 561   // Add template parameters.
 562   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 563     DIDescriptor Element = TParams.getElement(i);
 564     if (Element.isTemplateTypeParameter())
 565       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 566                         DITemplateTypeParameter(Element)));
 567     else if (Element.isTemplateValueParameter())
 568       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 569                         DITemplateValueParameter(Element)));
 570   }
 571 }
 572
 573 /// addToContextOwner - Add Die into the list of its context owner's children.
 574 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 575   if (Context.isType()) {
 576     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
 577     ContextDIE->addChild(Die);
 578   } else if (Context.isNameSpace()) {
 579     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
 580     ContextDIE->addChild(Die);
 581   } else if (Context.isSubprogram()) {
 582     DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
 583     ContextDIE->addChild(Die);
 584   } else if (DIE *ContextDIE = getDIE(Context))
 585     ContextDIE->addChild(Die);
 586   else
 587     addDie(Die);
 588 }
 589
 590 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 591 /// given DIType.
 592 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 593   DIType Ty(TyNode);
 594   if (!Ty.Verify())
 595     return NULL;
 596   DIE *TyDIE = getDIE(Ty);
 597   if (TyDIE)
 598     return TyDIE;
 599
 600   // Create new type.
 601   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 602   insertDIE(Ty, TyDIE);
 603   if (Ty.isBasicType())
 604     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 605   else if (Ty.isCompositeType())
 606     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 607   else {
 608     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 609     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 610   }
 611   // If this is a named finished type then include it in the list of types
 612   // for the accelerator tables.
 613   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 614     bool IsImplementation = 0;
 615     if (Ty.isCompositeType()) {
 616       DICompositeType CT(Ty);
 617       // A runtime language of 0 actually means C/C++ and that any
 618       // non-negative value is some version of Objective-C/C++.
 619       IsImplementation = (CT.getRunTimeLang() == 0) ||
 620         CT.isObjcClassComplete();
 621     }
 622     unsigned Flags = IsImplementation ?
 623                      DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
 624     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
 625   }
 626
 627   addToContextOwner(TyDIE, Ty.getContext());
 628   return TyDIE;
 629 }
 630
 631 /// addType - Add a new type attribute to the specified entity.
 632 void CompileUnit::addType(DIE *Entity, DIType Ty) {
 633   if (!Ty.Verify())
 634     return;
 635
 636   // Check for pre-existence.
 637   DIEEntry *Entry = getDIEEntry(Ty);
 638   // If it exists then use the existing value.
 639   if (Entry) {
 640     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 641     return;
 642   }
 643
 644   // Construct type.
 645   DIE *Buffer = getOrCreateTypeDIE(Ty);
 646
 647   // Set up proxy.
 648   Entry = createDIEEntry(Buffer);
 649   insertDIEEntry(Ty, Entry);
 650   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 651
 652   // If this is a complete composite type then include it in the
 653   // list of global types.
 654   addGlobalType(Ty);
 655 }
 656
 657 /// addGlobalType - Add a new global type to the compile unit.
 658 ///
 659 void CompileUnit::addGlobalType(DIType Ty) {
 660   DIDescriptor Context = Ty.getContext();
 661   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
 662       && (!Context || Context.isCompileUnit() || Context.isFile()
 663           || Context.isNameSpace()))
 664     if (DIEEntry *Entry = getDIEEntry(Ty))
 665       GlobalTypes[Ty.getName()] = Entry->getEntry();
 666 }
 667
 668 /// addPubTypes - Add type for pubtypes section.
 669 void CompileUnit::addPubTypes(DISubprogram SP) {
 670   DICompositeType SPTy = SP.getType();
 671   unsigned SPTag = SPTy.getTag();
 672   if (SPTag != dwarf::DW_TAG_subroutine_type)
 673     return;
 674
 675   DIArray Args = SPTy.getTypeArray();
 676   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 677     DIType ATy(Args.getElement(i));
 678     if (!ATy.Verify())
 679       continue;
 680     addGlobalType(ATy);
 681   }
 682 }
 683
 684 /// constructTypeDIE - Construct basic type die from DIBasicType.
 685 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 686   // Get core information.
 687   StringRef Name = BTy.getName();
 688   // Add name if not anonymous or intermediate type.
 689   if (!Name.empty())
 690     addString(&Buffer, dwarf::DW_AT_name, Name);
 691
 692   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 693     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 694     // Unspecified types has only name, nothing else.
 695     return;
 696   }
 697
 698   Buffer.setTag(dwarf::DW_TAG_base_type);
 699   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 700           BTy.getEncoding());
 701
 702   uint64_t Size = BTy.getSizeInBits() >> 3;
 703   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 704 }
 705
 706 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 707 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 708   // Get core information.
 709   StringRef Name = DTy.getName();
 710   uint64_t Size = DTy.getSizeInBits() >> 3;
 711   unsigned Tag = DTy.getTag();
 712
 713   // FIXME - Workaround for templates.
 714   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 715
 716   Buffer.setTag(Tag);
 717
 718   // Map to main type, void will not have a type.
 719   DIType FromTy = DTy.getTypeDerivedFrom();
 720   addType(&Buffer, FromTy);
 721
 722   // Add name if not anonymous or intermediate type.
 723   if (!Name.empty())
 724     addString(&Buffer, dwarf::DW_AT_name, Name);
 725
 726   // Add size if non-zero (derived types might be zero-sized.)
 727   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 728     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 729
 730   // Add source line info if available and TyDesc is not a forward declaration.
 731   if (!DTy.isForwardDecl())
 732     addSourceLine(&Buffer, DTy);
 733 }
 734
 735 /// constructTypeDIE - Construct type DIE from DICompositeType.
 736 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 737   // Get core information.
 738   StringRef Name = CTy.getName();
 739
 740   uint64_t Size = CTy.getSizeInBits() >> 3;
 741   unsigned Tag = CTy.getTag();
 742   Buffer.setTag(Tag);
 743
 744   switch (Tag) {
 745   case dwarf::DW_TAG_vector_type:
 746   case dwarf::DW_TAG_array_type:
 747     constructArrayTypeDIE(Buffer, &CTy);
 748     break;
 749   case dwarf::DW_TAG_enumeration_type: {
 750     DIArray Elements = CTy.getTypeArray();
 751
 752     // Add enumerators to enumeration type.
 753     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 754       DIE *ElemDie = NULL;
 755       DIDescriptor Enum(Elements.getElement(i));
 756       if (Enum.isEnumerator()) {
 757         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 758         Buffer.addChild(ElemDie);
 759       }
 760     }
 761   }
 762     break;
 763   case dwarf::DW_TAG_subroutine_type: {
 764     // Add return type.
 765     DIArray Elements = CTy.getTypeArray();
 766     DIDescriptor RTy = Elements.getElement(0);
 767     addType(&Buffer, DIType(RTy));
 768
 769     bool isPrototyped = true;
 770     // Add arguments.
 771     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 772       DIDescriptor Ty = Elements.getElement(i);
 773       if (Ty.isUnspecifiedParameter()) {
 774         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 775         Buffer.addChild(Arg);
 776         isPrototyped = false;
 777       } else {
 778         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 779         addType(Arg, DIType(Ty));
 780         Buffer.addChild(Arg);
 781       }
 782     }
 783     // Add prototype flag if we're dealing with a C language and the
 784     // function has been prototyped.
 785     if (isPrototyped &&
 786         (Language == dwarf::DW_LANG_C89 ||
 787          Language == dwarf::DW_LANG_C99 ||
 788          Language == dwarf::DW_LANG_ObjC))
 789       addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 790   }
 791     break;
 792   case dwarf::DW_TAG_structure_type:
 793   case dwarf::DW_TAG_union_type:
 794   case dwarf::DW_TAG_class_type: {
 795     // Add elements to structure type.
 796     DIArray Elements = CTy.getTypeArray();
 797
 798     // A forward struct declared type may not have elements available.
 799     unsigned N = Elements.getNumElements();
 800     if (N == 0)
 801       break;
 802
 803     // Add elements to structure type.
 804     for (unsigned i = 0; i < N; ++i) {
 805       DIDescriptor Element = Elements.getElement(i);
 806       DIE *ElemDie = NULL;
 807       if (Element.isSubprogram()) {
 808         DISubprogram SP(Element);
 809         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
 810         if (SP.isProtected())
 811           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 812                   dwarf::DW_ACCESS_protected);
 813         else if (SP.isPrivate())
 814           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 815                   dwarf::DW_ACCESS_private);
 816         else
 817           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 818             dwarf::DW_ACCESS_public);
 819         if (SP.isExplicit())
 820           addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
 821       }
 822       else if (Element.isVariable()) {
 823         DIVariable DV(Element);
 824         ElemDie = new DIE(dwarf::DW_TAG_variable);
 825         addString(ElemDie, dwarf::DW_AT_name, DV.getName());
 826         addType(ElemDie, DV.getType());
 827         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 828         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 829         addSourceLine(ElemDie, DV);
 830       } else if (Element.isDerivedType())
 831         ElemDie = createMemberDIE(DIDerivedType(Element));
 832       else if (Element.isObjCProperty()) {
 833         DIObjCProperty Property(Element);
 834         ElemDie = new DIE(Property.getTag());
 835         StringRef PropertyName = Property.getObjCPropertyName();
 836         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 837         StringRef GetterName = Property.getObjCPropertyGetterName();
 838         if (!GetterName.empty())
 839           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 840         StringRef SetterName = Property.getObjCPropertySetterName();
 841         if (!SetterName.empty())
 842           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 843         unsigned PropertyAttributes = 0;
 844         if (Property.isReadOnlyObjCProperty())
 845           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
 846         if (Property.isReadWriteObjCProperty())
 847           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
 848         if (Property.isAssignObjCProperty())
 849           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
 850         if (Property.isRetainObjCProperty())
 851           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
 852         if (Property.isCopyObjCProperty())
 853           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
 854         if (Property.isNonAtomicObjCProperty())
 855           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
 856         if (PropertyAttributes)
 857           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
 858                  PropertyAttributes);
 859
 860         DIEEntry *Entry = getDIEEntry(Element);
 861         if (!Entry) {
 862           Entry = createDIEEntry(ElemDie);
 863           insertDIEEntry(Element, Entry);
 864         }
 865       } else
 866         continue;
 867       Buffer.addChild(ElemDie);
 868     }
 869
 870     if (CTy.isAppleBlockExtension())
 871       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 872
 873     DICompositeType ContainingType = CTy.getContainingType();
 874     if (DIDescriptor(ContainingType).isCompositeType())
 875       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 876                   getOrCreateTypeDIE(DIType(ContainingType)));
 877     else {
 878       DIDescriptor Context = CTy.getContext();
 879       addToContextOwner(&Buffer, Context);
 880     }
 881
 882     if (CTy.isObjcClassComplete())
 883       addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
 884               dwarf::DW_FORM_flag, 1);
 885
 886     // Add template parameters to a class, structure or union types.
 887     // FIXME: The support isn't in the metadata for this yet.
 888     if (Tag == dwarf::DW_TAG_class_type ||
 889         Tag == dwarf::DW_TAG_structure_type ||
 890         Tag == dwarf::DW_TAG_union_type)
 891       addTemplateParams(Buffer, CTy.getTemplateParams());
 892
 893     break;
 894   }
 895   default:
 896     break;
 897   }
 898
 899   // Add name if not anonymous or intermediate type.
 900   if (!Name.empty())
 901     addString(&Buffer, dwarf::DW_AT_name, Name);
 902
 903   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 904       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 905   {
 906     // Add size if non-zero (derived types might be zero-sized.)
 907     if (Size)
 908       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 909     else {
 910       // Add zero size if it is not a forward declaration.
 911       if (CTy.isForwardDecl())
 912         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 913       else
 914         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 915     }
 916
 917     // Add source line info if available.
 918     if (!CTy.isForwardDecl())
 919       addSourceLine(&Buffer, CTy);
 920
 921     // No harm in adding the runtime language to the declaration.
 922     unsigned RLang = CTy.getRunTimeLang();
 923     if (RLang)
 924       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 925               dwarf::DW_FORM_data1, RLang);
 926   }
 927 }
 928
 929 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 930 /// for the given DITemplateTypeParameter.
 931 DIE *
 932 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 933   DIE *ParamDIE = getDIE(TP);
 934   if (ParamDIE)
 935     return ParamDIE;
 936
 937   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 938   addType(ParamDIE, TP.getType());
 939   addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
 940   return ParamDIE;
 941 }
 942
 943 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 944 /// for the given DITemplateValueParameter.
 945 DIE *
 946 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 947   DIE *ParamDIE = getDIE(TPV);
 948   if (ParamDIE)
 949     return ParamDIE;
 950
 951   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 952   addType(ParamDIE, TPV.getType());
 953   if (!TPV.getName().empty())
 954     addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
 955   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 956           TPV.getValue());
 957   return ParamDIE;
 958 }
 959
 960 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 961 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 962   DIE *NDie = getDIE(NS);
 963   if (NDie)
 964     return NDie;
 965   NDie = new DIE(dwarf::DW_TAG_namespace);
 966   insertDIE(NS, NDie);
 967   if (!NS.getName().empty()) {
 968     addString(NDie, dwarf::DW_AT_name, NS.getName());
 969     addAccelNamespace(NS.getName(), NDie);
 970   } else
 971     addAccelNamespace("(anonymous namespace)", NDie);
 972   addSourceLine(NDie, NS);
 973   addToContextOwner(NDie, NS.getContext());
 974   return NDie;
 975 }
 976
 977 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
 978 /// printer to not emit usual symbol prefix before the symbol name is used then
 979 /// return linkage name after skipping this special LLVM prefix.
 980 static StringRef getRealLinkageName(StringRef LinkageName) {
 981   char One = '\1';
 982   if (LinkageName.startswith(StringRef(&One, 1)))
 983     return LinkageName.substr(1);
 984   return LinkageName;
 985 }
 986
 987 /// getOrCreateSubprogramDIE - Create new DIE using SP.
 988 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
 989   DIE *SPDie = getDIE(SP);
 990   if (SPDie)
 991     return SPDie;
 992
 993   DISubprogram SPDecl = SP.getFunctionDeclaration();
 994   DIE *DeclDie = NULL;
 995   if (SPDecl.isSubprogram()) {
 996     DeclDie = getOrCreateSubprogramDIE(SPDecl);
 997   }
 998
 999   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1000
1001   // DW_TAG_inlined_subroutine may refer to this DIE.
1002   insertDIE(SP, SPDie);
1003
1004   // Add to context owner.
1005   addToContextOwner(SPDie, SP.getContext());
1006
1007   // Add function template parameters.
1008   addTemplateParams(*SPDie, SP.getTemplateParams());
1009
1010   // Unfortunately this code needs to stay here to work around
1011   // a bug in older gdbs that requires the linkage name to resolve
1012   // multiple template functions.
1013   StringRef LinkageName = SP.getLinkageName();
1014   if (!LinkageName.empty())
1015     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1016               getRealLinkageName(LinkageName));
1017
1018   // If this DIE is going to refer declaration info using AT_specification
1019   // then there is no need to add other attributes.
1020   if (DeclDie) {
1021     // Refer function declaration directly.
1022     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1023                 DeclDie);
1024
1025     return SPDie;
1026   }
1027
1028   // Constructors and operators for anonymous aggregates do not have names.
1029   if (!SP.getName().empty())
1030     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1031
1032   addSourceLine(SPDie, SP);
1033
1034   // Add the prototype if we have a prototype and we have a C like
1035   // language.
1036   if (SP.isPrototyped() &&
1037       (Language == dwarf::DW_LANG_C89 ||
1038        Language == dwarf::DW_LANG_C99 ||
1039        Language == dwarf::DW_LANG_ObjC))
1040     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1041
1042   // Add Return Type.
1043   DICompositeType SPTy = SP.getType();
1044   DIArray Args = SPTy.getTypeArray();
1045   unsigned SPTag = SPTy.getTag();
1046
1047   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1048     addType(SPDie, SPTy);
1049   else
1050     addType(SPDie, DIType(Args.getElement(0)));
1051
1052   unsigned VK = SP.getVirtuality();
1053   if (VK) {
1054     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1055     DIEBlock *Block = getDIEBlock();
1056     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1057     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1058     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1059     ContainingTypeMap.insert(std::make_pair(SPDie,
1060                                             SP.getContainingType()));
1061   }
1062
1063   if (!SP.isDefinition()) {
1064     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1065
1066     // Add arguments. Do not add arguments for subprogram definition. They will
1067     // be handled while processing variables.
1068     DICompositeType SPTy = SP.getType();
1069     DIArray Args = SPTy.getTypeArray();
1070     unsigned SPTag = SPTy.getTag();
1071
1072     if (SPTag == dwarf::DW_TAG_subroutine_type)
1073       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1074         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1075         DIType ATy = DIType(DIType(Args.getElement(i)));
1076         addType(Arg, ATy);
1077         if (ATy.isArtificial())
1078           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1079         SPDie->addChild(Arg);
1080       }
1081   }
1082
1083   if (SP.isArtificial())
1084     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1085
1086   if (!SP.isLocalToUnit())
1087     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1088
1089   if (SP.isOptimized())
1090     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1091
1092   if (unsigned isa = Asm->getISAEncoding()) {
1093     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1094   }
1095
1096   return SPDie;
1097 }
1098
1099 // Return const expression if value is a GEP to access merged global
1100 // constant. e.g.
1101 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1102 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1103   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1104   if (!CE || CE->getNumOperands() != 3 ||
1105       CE->getOpcode() != Instruction::GetElementPtr)
1106     return NULL;
1107
1108   // First operand points to a global struct.
1109   Value *Ptr = CE->getOperand(0);
1110   if (!isa<GlobalValue>(Ptr) ||
1111       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1112     return NULL;
1113
1114   // Second operand is zero.
1115   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1116   if (!CI || !CI->isZero())
1117     return NULL;
1118
1119   // Third operand is offset.
1120   if (!isa<ConstantInt>(CE->getOperand(2)))
1121     return NULL;
1122
1123   return CE;
1124 }
1125
1126 /// createGlobalVariableDIE - create global variable DIE.
1127 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1128   // Check for pre-existence.
1129   if (getDIE(N))
1130     return;
1131
1132   DIGlobalVariable GV(N);
1133   if (!GV.Verify())
1134     return;
1135
1136   DIE *VariableDIE = new DIE(GV.getTag());
1137   // Add to map.
1138   insertDIE(N, VariableDIE);
1139
1140   // Add name.
1141   addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1142   StringRef LinkageName = GV.getLinkageName();
1143   bool isGlobalVariable = GV.getGlobal() != NULL;
1144   if (!LinkageName.empty() && isGlobalVariable)
1145     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1146               getRealLinkageName(LinkageName));
1147   // Add type.
1148   DIType GTy = GV.getType();
1149   addType(VariableDIE, GTy);
1150
1151   // Add scoping info.
1152   if (!GV.isLocalToUnit())
1153     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1154
1155   // Add line number info.
1156   addSourceLine(VariableDIE, GV);
1157   // Add to context owner.
1158   DIDescriptor GVContext = GV.getContext();
1159   addToContextOwner(VariableDIE, GVContext);
1160   // Add location.
1161   bool addToAccelTable = false;
1162   DIE *VariableSpecDIE = NULL;
1163   if (isGlobalVariable) {
1164     addToAccelTable = true;
1165     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1166     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1167     addLabel(Block, 0, dwarf::DW_FORM_udata,
1168              Asm->Mang->getSymbol(GV.getGlobal()));
1169     // Do not create specification DIE if context is either compile unit
1170     // or a subprogram.
1171     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1172         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1173       // Create specification DIE.
1174       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1175       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1176                   dwarf::DW_FORM_ref4, VariableDIE);
1177       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1178       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1179                      1);
1180       addDie(VariableSpecDIE);
1181     } else {
1182       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1183     }
1184   } else if (const ConstantInt *CI =
1185              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1186     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1187   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1188     addToAccelTable = true;
1189     // GV is a merged global.
1190     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1191     Value *Ptr = CE->getOperand(0);
1192     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1193     addLabel(Block, 0, dwarf::DW_FORM_udata,
1194                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1195     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1196     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1197     addUInt(Block, 0, dwarf::DW_FORM_udata,
1198                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1199     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1200     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1201   }
1202
1203   if (addToAccelTable) {
1204     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1205     addAccelName(GV.getName(), AddrDIE);
1206
1207     // If the linkage name is different than the name, go ahead and output
1208     // that as well into the name table.
1209     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1210       addAccelName(GV.getLinkageName(), AddrDIE);
1211   }
1212
1213   return;
1214 }
1215
1216 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1217 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1218   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1219   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1220   uint64_t L = SR.getLo();
1221   uint64_t H = SR.getHi();
1222
1223   // The L value defines the lower bounds which is typically zero for C/C++. The
1224   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
1225   // of the array. If L > H then do not emit DW_AT_lower_bound and
1226   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1227   // array has one element and in such case do not emit lower bound.
1228
1229   if (L > H) {
1230     Buffer.addChild(DW_Subrange);
1231     return;
1232   }
1233   if (L)
1234     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1235   addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1236   Buffer.addChild(DW_Subrange);
1237 }
1238
1239 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1240 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1241                                         DICompositeType *CTy) {
1242   Buffer.setTag(dwarf::DW_TAG_array_type);
1243   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1244     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1245
1246   // Emit derived type.
1247   addType(&Buffer, CTy->getTypeDerivedFrom());
1248   DIArray Elements = CTy->getTypeArray();
1249
1250   // Get an anonymous type for index type.
1251   DIE *IdxTy = getIndexTyDie();
1252   if (!IdxTy) {
1253     // Construct an anonymous type for index type.
1254     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1255     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1256     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1257             dwarf::DW_ATE_signed);
1258     addDie(IdxTy);
1259     setIndexTyDie(IdxTy);
1260   }
1261
1262   // Add subranges to array type.
1263   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1264     DIDescriptor Element = Elements.getElement(i);
1265     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1266       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1267   }
1268 }
1269
1270 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1271 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1272   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1273   StringRef Name = ETy.getName();
1274   addString(Enumerator, dwarf::DW_AT_name, Name);
1275   int64_t Value = ETy.getEnumValue();
1276   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1277   return Enumerator;
1278 }
1279
1280 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1281 /// vtables.
1282 void CompileUnit::constructContainingTypeDIEs() {
1283   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1284          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1285     DIE *SPDie = CI->first;
1286     const MDNode *N = CI->second;
1287     if (!N) continue;
1288     DIE *NDie = getDIE(N);
1289     if (!NDie) continue;
1290     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1291   }
1292 }
1293
1294 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1295 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1296   StringRef Name = DV->getName();
1297   if (Name.empty())
1298     return NULL;
1299
1300   // Translate tag to proper Dwarf tag.
1301   unsigned Tag = DV->getTag();
1302
1303   // Define variable debug information entry.
1304   DIE *VariableDie = new DIE(Tag);
1305   DbgVariable *AbsVar = DV->getAbstractVariable();
1306   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1307   if (AbsDIE)
1308     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1309                             dwarf::DW_FORM_ref4, AbsDIE);
1310   else {
1311     addString(VariableDie, dwarf::DW_AT_name, Name);
1312     addSourceLine(VariableDie, DV->getVariable());
1313     addType(VariableDie, DV->getType());
1314   }
1315
1316   if (DV->isArtificial())
1317     addUInt(VariableDie, dwarf::DW_AT_artificial,
1318                         dwarf::DW_FORM_flag, 1);
1319
1320   if (isScopeAbstract) {
1321     DV->setDIE(VariableDie);
1322     return VariableDie;
1323   }
1324
1325   // Add variable address.
1326
1327   unsigned Offset = DV->getDotDebugLocOffset();
1328   if (Offset != ~0U) {
1329     addLabel(VariableDie, dwarf::DW_AT_location,
1330                          dwarf::DW_FORM_data4,
1331                          Asm->GetTempSymbol("debug_loc", Offset));
1332     DV->setDIE(VariableDie);
1333     return VariableDie;
1334   }
1335
1336   // Check if variable is described by a DBG_VALUE instruction.
1337   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1338     bool updated = false;
1339     if (DVInsn->getNumOperands() == 3) {
1340       if (DVInsn->getOperand(0).isReg()) {
1341         const MachineOperand RegOp = DVInsn->getOperand(0);
1342         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1343         if (DVInsn->getOperand(1).isImm() &&
1344             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1345           unsigned FrameReg = 0;
1346           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1347           int Offset =
1348             TFI->getFrameIndexReference(*Asm->MF,
1349                                         DVInsn->getOperand(1).getImm(),
1350                                         FrameReg);
1351           MachineLocation Location(FrameReg, Offset);
1352           addVariableAddress(DV, VariableDie, Location);
1353
1354         } else if (RegOp.getReg())
1355           addVariableAddress(DV, VariableDie,
1356                                          MachineLocation(RegOp.getReg()));
1357         updated = true;
1358       }
1359       else if (DVInsn->getOperand(0).isImm())
1360         updated =
1361           addConstantValue(VariableDie, DVInsn->getOperand(0),
1362                                        DV->getType());
1363       else if (DVInsn->getOperand(0).isFPImm())
1364         updated =
1365           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1366       else if (DVInsn->getOperand(0).isCImm())
1367         updated =
1368           addConstantValue(VariableDie,
1369                                        DVInsn->getOperand(0).getCImm(),
1370                                        DV->getType().isUnsignedDIType());
1371     } else {
1372       addVariableAddress(DV, VariableDie,
1373                                      Asm->getDebugValueLocation(DVInsn));
1374       updated = true;
1375     }
1376     if (!updated) {
1377       // If variableDie is not updated then DBG_VALUE instruction does not
1378       // have valid variable info.
1379       delete VariableDie;
1380       return NULL;
1381     }
1382     DV->setDIE(VariableDie);
1383     return VariableDie;
1384   } else {
1385     // .. else use frame index.
1386     int FI = DV->getFrameIndex();
1387     if (FI != ~0) {
1388       unsigned FrameReg = 0;
1389       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1390       int Offset =
1391         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1392       MachineLocation Location(FrameReg, Offset);
1393       addVariableAddress(DV, VariableDie, Location);
1394     }
1395   }
1396
1397   DV->setDIE(VariableDie);
1398   return VariableDie;
1399 }
1400
1401 /// createMemberDIE - Create new member DIE.
1402 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1403   DIE *MemberDie = new DIE(DT.getTag());
1404   StringRef Name = DT.getName();
1405   if (!Name.empty())
1406     addString(MemberDie, dwarf::DW_AT_name, Name);
1407
1408   addType(MemberDie, DT.getTypeDerivedFrom());
1409
1410   addSourceLine(MemberDie, DT);
1411
1412   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1413   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1414
1415   uint64_t Size = DT.getSizeInBits();
1416   uint64_t FieldSize = DT.getOriginalTypeSize();
1417
1418   if (Size != FieldSize) {
1419     // Handle bitfield.
1420     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1421     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1422
1423     uint64_t Offset = DT.getOffsetInBits();
1424     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1425     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1426     uint64_t FieldOffset = (HiMark - FieldSize);
1427     Offset -= FieldOffset;
1428
1429     // Maybe we need to work from the other end.
1430     if (Asm->getTargetData().isLittleEndian())
1431       Offset = FieldSize - (Offset + Size);
1432     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1433
1434     // Here WD_AT_data_member_location points to the anonymous
1435     // field that includes this bit field.
1436     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1437
1438   } else
1439     // This is not a bitfield.
1440     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1441
1442   if (DT.getTag() == dwarf::DW_TAG_inheritance
1443       && DT.isVirtual()) {
1444
1445     // For C++, virtual base classes are not at fixed offset. Use following
1446     // expression to extract appropriate offset from vtable.
1447     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1448
1449     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1450     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1451     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1452     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1453     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1454     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1455     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1456     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1457
1458     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1459              VBaseLocationDie);
1460   } else
1461     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1462
1463   if (DT.isProtected())
1464     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1465             dwarf::DW_ACCESS_protected);
1466   else if (DT.isPrivate())
1467     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1468             dwarf::DW_ACCESS_private);
1469   // Otherwise C++ member and base classes are considered public.
1470   else
1471     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1472             dwarf::DW_ACCESS_public);
1473   if (DT.isVirtual())
1474     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1475             dwarf::DW_VIRTUALITY_virtual);
1476
1477   // Objective-C properties.
1478   if (MDNode *PNode = DT.getObjCProperty())
1479     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1480       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1481                           PropertyDie);
1482
1483   // This is only for backward compatibility.
1484   StringRef PropertyName = DT.getObjCPropertyName();
1485   if (!PropertyName.empty()) {
1486     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1487     StringRef GetterName = DT.getObjCPropertyGetterName();
1488     if (!GetterName.empty())
1489       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1490     StringRef SetterName = DT.getObjCPropertySetterName();
1491     if (!SetterName.empty())
1492       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1493     unsigned PropertyAttributes = 0;
1494     if (DT.isReadOnlyObjCProperty())
1495       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1496     if (DT.isReadWriteObjCProperty())
1497       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1498     if (DT.isAssignObjCProperty())
1499       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1500     if (DT.isRetainObjCProperty())
1501       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1502     if (DT.isCopyObjCProperty())
1503       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1504     if (DT.isNonAtomicObjCProperty())
1505       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1506     if (PropertyAttributes)
1507       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1508               PropertyAttributes);
1509   }
1510   return MemberDie;
1511 }