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   StringRef LinkageName = SP.getLinkageName();
1011   if (!LinkageName.empty())
1012     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1013               getRealLinkageName(LinkageName));
1014
1015   // If this DIE is going to refer declaration info using AT_specification
1016   // then there is no need to add other attributes.
1017   if (DeclDie) {
1018     // Refer function declaration directly.
1019     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1020                 DeclDie);
1021
1022     return SPDie;
1023   }
1024
1025   // Constructors and operators for anonymous aggregates do not have names.
1026   if (!SP.getName().empty())
1027     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1028
1029   addSourceLine(SPDie, SP);
1030
1031   // Add the prototype if we have a prototype and we have a C like
1032   // language.
1033   if (SP.isPrototyped() &&
1034       (Language == dwarf::DW_LANG_C89 ||
1035        Language == dwarf::DW_LANG_C99 ||
1036        Language == dwarf::DW_LANG_ObjC))
1037     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1038
1039   // Add Return Type.
1040   DICompositeType SPTy = SP.getType();
1041   DIArray Args = SPTy.getTypeArray();
1042   unsigned SPTag = SPTy.getTag();
1043
1044   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1045     addType(SPDie, SPTy);
1046   else
1047     addType(SPDie, DIType(Args.getElement(0)));
1048
1049   unsigned VK = SP.getVirtuality();
1050   if (VK) {
1051     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1052     DIEBlock *Block = getDIEBlock();
1053     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1054     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1055     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1056     ContainingTypeMap.insert(std::make_pair(SPDie,
1057                                             SP.getContainingType()));
1058   }
1059
1060   if (!SP.isDefinition()) {
1061     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1062
1063     // Add arguments. Do not add arguments for subprogram definition. They will
1064     // be handled while processing variables.
1065     DICompositeType SPTy = SP.getType();
1066     DIArray Args = SPTy.getTypeArray();
1067     unsigned SPTag = SPTy.getTag();
1068
1069     if (SPTag == dwarf::DW_TAG_subroutine_type)
1070       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1071         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1072         DIType ATy = DIType(DIType(Args.getElement(i)));
1073         addType(Arg, ATy);
1074         if (ATy.isArtificial())
1075           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1076         SPDie->addChild(Arg);
1077       }
1078   }
1079
1080   if (SP.isArtificial())
1081     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1082
1083   if (!SP.isLocalToUnit())
1084     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1085
1086   if (SP.isOptimized())
1087     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1088
1089   if (unsigned isa = Asm->getISAEncoding()) {
1090     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1091   }
1092
1093   return SPDie;
1094 }
1095
1096 // Return const expression if value is a GEP to access merged global
1097 // constant. e.g.
1098 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1099 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1100   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1101   if (!CE || CE->getNumOperands() != 3 ||
1102       CE->getOpcode() != Instruction::GetElementPtr)
1103     return NULL;
1104
1105   // First operand points to a global struct.
1106   Value *Ptr = CE->getOperand(0);
1107   if (!isa<GlobalValue>(Ptr) ||
1108       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1109     return NULL;
1110
1111   // Second operand is zero.
1112   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1113   if (!CI || !CI->isZero())
1114     return NULL;
1115
1116   // Third operand is offset.
1117   if (!isa<ConstantInt>(CE->getOperand(2)))
1118     return NULL;
1119
1120   return CE;
1121 }
1122
1123 /// createGlobalVariableDIE - create global variable DIE.
1124 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1125   // Check for pre-existence.
1126   if (getDIE(N))
1127     return;
1128
1129   DIGlobalVariable GV(N);
1130   if (!GV.Verify())
1131     return;
1132
1133   DIE *VariableDIE = new DIE(GV.getTag());
1134   // Add to map.
1135   insertDIE(N, VariableDIE);
1136
1137   // Add name.
1138   addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1139   StringRef LinkageName = GV.getLinkageName();
1140   bool isGlobalVariable = GV.getGlobal() != NULL;
1141   if (!LinkageName.empty() && isGlobalVariable)
1142     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1143               getRealLinkageName(LinkageName));
1144   // Add type.
1145   DIType GTy = GV.getType();
1146   addType(VariableDIE, GTy);
1147
1148   // Add scoping info.
1149   if (!GV.isLocalToUnit())
1150     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1151
1152   // Add line number info.
1153   addSourceLine(VariableDIE, GV);
1154   // Add to context owner.
1155   DIDescriptor GVContext = GV.getContext();
1156   addToContextOwner(VariableDIE, GVContext);
1157   // Add location.
1158   bool addToAccelTable = false;
1159   DIE *VariableSpecDIE = NULL;
1160   if (isGlobalVariable) {
1161     addToAccelTable = true;
1162     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1163     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1164     addLabel(Block, 0, dwarf::DW_FORM_udata,
1165              Asm->Mang->getSymbol(GV.getGlobal()));
1166     // Do not create specification DIE if context is either compile unit
1167     // or a subprogram.
1168     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1169         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1170       // Create specification DIE.
1171       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1172       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1173                   dwarf::DW_FORM_ref4, VariableDIE);
1174       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1175       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1176                      1);
1177       addDie(VariableSpecDIE);
1178     } else {
1179       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1180     }
1181   } else if (const ConstantInt *CI =
1182              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1183     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1184   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1185     addToAccelTable = true;
1186     // GV is a merged global.
1187     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1188     Value *Ptr = CE->getOperand(0);
1189     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1190     addLabel(Block, 0, dwarf::DW_FORM_udata,
1191                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1192     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1193     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1194     addUInt(Block, 0, dwarf::DW_FORM_udata,
1195                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1196     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1197     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1198   }
1199
1200   if (addToAccelTable) {
1201     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1202     addAccelName(GV.getName(), AddrDIE);
1203
1204     // If the linkage name is different than the name, go ahead and output
1205     // that as well into the name table.
1206     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1207       addAccelName(GV.getLinkageName(), AddrDIE);
1208   }
1209
1210   return;
1211 }
1212
1213 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1214 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1215   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1216   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1217   uint64_t L = SR.getLo();
1218   uint64_t H = SR.getHi();
1219
1220   // The L value defines the lower bounds which is typically zero for C/C++. The
1221   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
1222   // of the array. If L > H then do not emit DW_AT_lower_bound and
1223   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1224   // array has one element and in such case do not emit lower bound.
1225
1226   if (L > H) {
1227     Buffer.addChild(DW_Subrange);
1228     return;
1229   }
1230   if (L)
1231     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1232   addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1233   Buffer.addChild(DW_Subrange);
1234 }
1235
1236 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1237 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1238                                         DICompositeType *CTy) {
1239   Buffer.setTag(dwarf::DW_TAG_array_type);
1240   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1241     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1242
1243   // Emit derived type.
1244   addType(&Buffer, CTy->getTypeDerivedFrom());
1245   DIArray Elements = CTy->getTypeArray();
1246
1247   // Get an anonymous type for index type.
1248   DIE *IdxTy = getIndexTyDie();
1249   if (!IdxTy) {
1250     // Construct an anonymous type for index type.
1251     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1252     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1253     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1254             dwarf::DW_ATE_signed);
1255     addDie(IdxTy);
1256     setIndexTyDie(IdxTy);
1257   }
1258
1259   // Add subranges to array type.
1260   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1261     DIDescriptor Element = Elements.getElement(i);
1262     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1263       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1264   }
1265 }
1266
1267 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1268 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1269   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1270   StringRef Name = ETy.getName();
1271   addString(Enumerator, dwarf::DW_AT_name, Name);
1272   int64_t Value = ETy.getEnumValue();
1273   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1274   return Enumerator;
1275 }
1276
1277 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1278 /// vtables.
1279 void CompileUnit::constructContainingTypeDIEs() {
1280   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1281          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1282     DIE *SPDie = CI->first;
1283     const MDNode *N = CI->second;
1284     if (!N) continue;
1285     DIE *NDie = getDIE(N);
1286     if (!NDie) continue;
1287     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1288   }
1289 }
1290
1291 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1292 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1293   StringRef Name = DV->getName();
1294   if (Name.empty())
1295     return NULL;
1296
1297   // Translate tag to proper Dwarf tag.
1298   unsigned Tag = DV->getTag();
1299
1300   // Define variable debug information entry.
1301   DIE *VariableDie = new DIE(Tag);
1302   DbgVariable *AbsVar = DV->getAbstractVariable();
1303   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1304   if (AbsDIE)
1305     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1306                             dwarf::DW_FORM_ref4, AbsDIE);
1307   else {
1308     addString(VariableDie, dwarf::DW_AT_name, Name);
1309     addSourceLine(VariableDie, DV->getVariable());
1310     addType(VariableDie, DV->getType());
1311   }
1312
1313   if (DV->isArtificial())
1314     addUInt(VariableDie, dwarf::DW_AT_artificial,
1315                         dwarf::DW_FORM_flag, 1);
1316
1317   if (isScopeAbstract) {
1318     DV->setDIE(VariableDie);
1319     return VariableDie;
1320   }
1321
1322   // Add variable address.
1323
1324   unsigned Offset = DV->getDotDebugLocOffset();
1325   if (Offset != ~0U) {
1326     addLabel(VariableDie, dwarf::DW_AT_location,
1327                          dwarf::DW_FORM_data4,
1328                          Asm->GetTempSymbol("debug_loc", Offset));
1329     DV->setDIE(VariableDie);
1330     return VariableDie;
1331   }
1332
1333   // Check if variable is described by a DBG_VALUE instruction.
1334   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1335     bool updated = false;
1336     if (DVInsn->getNumOperands() == 3) {
1337       if (DVInsn->getOperand(0).isReg()) {
1338         const MachineOperand RegOp = DVInsn->getOperand(0);
1339         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1340         if (DVInsn->getOperand(1).isImm() &&
1341             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1342           unsigned FrameReg = 0;
1343           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1344           int Offset =
1345             TFI->getFrameIndexReference(*Asm->MF,
1346                                         DVInsn->getOperand(1).getImm(),
1347                                         FrameReg);
1348           MachineLocation Location(FrameReg, Offset);
1349           addVariableAddress(DV, VariableDie, Location);
1350
1351         } else if (RegOp.getReg())
1352           addVariableAddress(DV, VariableDie,
1353                                          MachineLocation(RegOp.getReg()));
1354         updated = true;
1355       }
1356       else if (DVInsn->getOperand(0).isImm())
1357         updated =
1358           addConstantValue(VariableDie, DVInsn->getOperand(0),
1359                                        DV->getType());
1360       else if (DVInsn->getOperand(0).isFPImm())
1361         updated =
1362           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1363       else if (DVInsn->getOperand(0).isCImm())
1364         updated =
1365           addConstantValue(VariableDie,
1366                                        DVInsn->getOperand(0).getCImm(),
1367                                        DV->getType().isUnsignedDIType());
1368     } else {
1369       addVariableAddress(DV, VariableDie,
1370                                      Asm->getDebugValueLocation(DVInsn));
1371       updated = true;
1372     }
1373     if (!updated) {
1374       // If variableDie is not updated then DBG_VALUE instruction does not
1375       // have valid variable info.
1376       delete VariableDie;
1377       return NULL;
1378     }
1379     DV->setDIE(VariableDie);
1380     return VariableDie;
1381   } else {
1382     // .. else use frame index.
1383     int FI = DV->getFrameIndex();
1384     if (FI != ~0) {
1385       unsigned FrameReg = 0;
1386       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1387       int Offset =
1388         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1389       MachineLocation Location(FrameReg, Offset);
1390       addVariableAddress(DV, VariableDie, Location);
1391     }
1392   }
1393
1394   DV->setDIE(VariableDie);
1395   return VariableDie;
1396 }
1397
1398 /// createMemberDIE - Create new member DIE.
1399 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1400   DIE *MemberDie = new DIE(DT.getTag());
1401   StringRef Name = DT.getName();
1402   if (!Name.empty())
1403     addString(MemberDie, dwarf::DW_AT_name, Name);
1404
1405   addType(MemberDie, DT.getTypeDerivedFrom());
1406
1407   addSourceLine(MemberDie, DT);
1408
1409   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1410   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1411
1412   uint64_t Size = DT.getSizeInBits();
1413   uint64_t FieldSize = DT.getOriginalTypeSize();
1414
1415   if (Size != FieldSize) {
1416     // Handle bitfield.
1417     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1418     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1419
1420     uint64_t Offset = DT.getOffsetInBits();
1421     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1422     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1423     uint64_t FieldOffset = (HiMark - FieldSize);
1424     Offset -= FieldOffset;
1425
1426     // Maybe we need to work from the other end.
1427     if (Asm->getTargetData().isLittleEndian())
1428       Offset = FieldSize - (Offset + Size);
1429     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1430
1431     // Here WD_AT_data_member_location points to the anonymous
1432     // field that includes this bit field.
1433     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1434
1435   } else
1436     // This is not a bitfield.
1437     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1438
1439   if (DT.getTag() == dwarf::DW_TAG_inheritance
1440       && DT.isVirtual()) {
1441
1442     // For C++, virtual base classes are not at fixed offset. Use following
1443     // expression to extract appropriate offset from vtable.
1444     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1445
1446     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1447     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1448     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1449     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1450     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1451     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1452     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1453     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1454
1455     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1456              VBaseLocationDie);
1457   } else
1458     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1459
1460   if (DT.isProtected())
1461     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1462             dwarf::DW_ACCESS_protected);
1463   else if (DT.isPrivate())
1464     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1465             dwarf::DW_ACCESS_private);
1466   // Otherwise C++ member and base classes are considered public.
1467   else
1468     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1469             dwarf::DW_ACCESS_public);
1470   if (DT.isVirtual())
1471     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1472             dwarf::DW_VIRTUALITY_virtual);
1473
1474   // Objective-C properties.
1475   if (MDNode *PNode = DT.getObjCProperty())
1476     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1477       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1478                           PropertyDie);
1479
1480   // This is only for backward compatibility.
1481   StringRef PropertyName = DT.getObjCPropertyName();
1482   if (!PropertyName.empty()) {
1483     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1484     StringRef GetterName = DT.getObjCPropertyGetterName();
1485     if (!GetterName.empty())
1486       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1487     StringRef SetterName = DT.getObjCPropertySetterName();
1488     if (!SetterName.empty())
1489       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1490     unsigned PropertyAttributes = 0;
1491     if (DT.isReadOnlyObjCProperty())
1492       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1493     if (DT.isReadWriteObjCProperty())
1494       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1495     if (DT.isAssignObjCProperty())
1496       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1497     if (DT.isRetainObjCProperty())
1498       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1499     if (DT.isCopyObjCProperty())
1500       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1501     if (DT.isNonAtomicObjCProperty())
1502       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1503     if (PropertyAttributes)
1504       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1505               PropertyAttributes);
1506   }
1507   return MemberDie;
1508 }