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.
 784     if (isPrototyped)
 785       addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 786   }
 787     break;
 788   case dwarf::DW_TAG_structure_type:
 789   case dwarf::DW_TAG_union_type:
 790   case dwarf::DW_TAG_class_type: {
 791     // Add elements to structure type.
 792     DIArray Elements = CTy.getTypeArray();
 793
 794     // A forward struct declared type may not have elements available.
 795     unsigned N = Elements.getNumElements();
 796     if (N == 0)
 797       break;
 798
 799     // Add elements to structure type.
 800     for (unsigned i = 0; i < N; ++i) {
 801       DIDescriptor Element = Elements.getElement(i);
 802       DIE *ElemDie = NULL;
 803       if (Element.isSubprogram()) {
 804         DISubprogram SP(Element);
 805         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
 806         if (SP.isProtected())
 807           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 808                   dwarf::DW_ACCESS_protected);
 809         else if (SP.isPrivate())
 810           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 811                   dwarf::DW_ACCESS_private);
 812         else
 813           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 814             dwarf::DW_ACCESS_public);
 815         if (SP.isExplicit())
 816           addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
 817       }
 818       else if (Element.isVariable()) {
 819         DIVariable DV(Element);
 820         ElemDie = new DIE(dwarf::DW_TAG_variable);
 821         addString(ElemDie, dwarf::DW_AT_name, DV.getName());
 822         addType(ElemDie, DV.getType());
 823         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 824         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 825         addSourceLine(ElemDie, DV);
 826       } else if (Element.isDerivedType())
 827         ElemDie = createMemberDIE(DIDerivedType(Element));
 828       else if (Element.isObjCProperty()) {
 829         DIObjCProperty Property(Element);
 830         ElemDie = new DIE(Property.getTag());
 831         StringRef PropertyName = Property.getObjCPropertyName();
 832         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 833         StringRef GetterName = Property.getObjCPropertyGetterName();
 834         if (!GetterName.empty())
 835           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 836         StringRef SetterName = Property.getObjCPropertySetterName();
 837         if (!SetterName.empty())
 838           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 839         unsigned PropertyAttributes = 0;
 840         if (Property.isReadOnlyObjCProperty())
 841           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
 842         if (Property.isReadWriteObjCProperty())
 843           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
 844         if (Property.isAssignObjCProperty())
 845           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
 846         if (Property.isRetainObjCProperty())
 847           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
 848         if (Property.isCopyObjCProperty())
 849           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
 850         if (Property.isNonAtomicObjCProperty())
 851           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
 852         if (PropertyAttributes)
 853           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
 854                  PropertyAttributes);
 855
 856         DIEEntry *Entry = getDIEEntry(Element);
 857         if (!Entry) {
 858           Entry = createDIEEntry(ElemDie);
 859           insertDIEEntry(Element, Entry);
 860         }
 861       } else
 862         continue;
 863       Buffer.addChild(ElemDie);
 864     }
 865
 866     if (CTy.isAppleBlockExtension())
 867       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 868
 869     unsigned RLang = CTy.getRunTimeLang();
 870     if (RLang)
 871       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 872               dwarf::DW_FORM_data1, RLang);
 873
 874     DICompositeType ContainingType = CTy.getContainingType();
 875     if (DIDescriptor(ContainingType).isCompositeType())
 876       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 877                   getOrCreateTypeDIE(DIType(ContainingType)));
 878     else {
 879       DIDescriptor Context = CTy.getContext();
 880       addToContextOwner(&Buffer, Context);
 881     }
 882
 883     if (CTy.isObjcClassComplete())
 884       addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
 885               dwarf::DW_FORM_flag, 1);
 886
 887     // Add template parameters to a class, structure or union types.
 888     // FIXME: The support isn't in the metadata for this yet.
 889     if (Tag == dwarf::DW_TAG_class_type ||
 890         Tag == dwarf::DW_TAG_structure_type ||
 891         Tag == dwarf::DW_TAG_union_type)
 892       addTemplateParams(Buffer, CTy.getTemplateParams());
 893
 894     break;
 895   }
 896   default:
 897     break;
 898   }
 899
 900   // Add name if not anonymous or intermediate type.
 901   if (!Name.empty())
 902     addString(&Buffer, dwarf::DW_AT_name, Name);
 903
 904   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 905       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 906   {
 907     // Add size if non-zero (derived types might be zero-sized.)
 908     if (Size)
 909       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 910     else {
 911       // Add zero size if it is not a forward declaration.
 912       if (CTy.isForwardDecl())
 913         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 914       else
 915         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 916     }
 917
 918     // Add source line info if available.
 919     if (!CTy.isForwardDecl())
 920       addSourceLine(&Buffer, CTy);
 921   }
 922 }
 923
 924 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 925 /// for the given DITemplateTypeParameter.
 926 DIE *
 927 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 928   DIE *ParamDIE = getDIE(TP);
 929   if (ParamDIE)
 930     return ParamDIE;
 931
 932   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 933   addType(ParamDIE, TP.getType());
 934   addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
 935   return ParamDIE;
 936 }
 937
 938 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 939 /// for the given DITemplateValueParameter.
 940 DIE *
 941 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 942   DIE *ParamDIE = getDIE(TPV);
 943   if (ParamDIE)
 944     return ParamDIE;
 945
 946   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 947   addType(ParamDIE, TPV.getType());
 948   if (!TPV.getName().empty())
 949     addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
 950   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 951           TPV.getValue());
 952   return ParamDIE;
 953 }
 954
 955 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 956 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 957   DIE *NDie = getDIE(NS);
 958   if (NDie)
 959     return NDie;
 960   NDie = new DIE(dwarf::DW_TAG_namespace);
 961   insertDIE(NS, NDie);
 962   if (!NS.getName().empty()) {
 963     addString(NDie, dwarf::DW_AT_name, NS.getName());
 964     addAccelNamespace(NS.getName(), NDie);
 965   } else
 966     addAccelNamespace("(anonymous namespace)", NDie);
 967   addSourceLine(NDie, NS);
 968   addToContextOwner(NDie, NS.getContext());
 969   return NDie;
 970 }
 971
 972 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
 973 /// printer to not emit usual symbol prefix before the symbol name is used then
 974 /// return linkage name after skipping this special LLVM prefix.
 975 static StringRef getRealLinkageName(StringRef LinkageName) {
 976   char One = '\1';
 977   if (LinkageName.startswith(StringRef(&One, 1)))
 978     return LinkageName.substr(1);
 979   return LinkageName;
 980 }
 981
 982 /// getOrCreateSubprogramDIE - Create new DIE using SP.
 983 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
 984   DIE *SPDie = getDIE(SP);
 985   if (SPDie)
 986     return SPDie;
 987
 988   DISubprogram SPDecl = SP.getFunctionDeclaration();
 989   DIE *DeclDie = NULL;
 990   if (SPDecl.isSubprogram()) {
 991     DeclDie = getOrCreateSubprogramDIE(SPDecl);
 992   }
 993
 994   SPDie = new DIE(dwarf::DW_TAG_subprogram);
 995
 996   // DW_TAG_inlined_subroutine may refer to this DIE.
 997   insertDIE(SP, SPDie);
 998
 999   // Add to context owner.
1000   addToContextOwner(SPDie, SP.getContext());
1001
1002   // Add function template parameters.
1003   addTemplateParams(*SPDie, SP.getTemplateParams());
1004
1005   StringRef LinkageName = SP.getLinkageName();
1006   if (!LinkageName.empty())
1007     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1008               getRealLinkageName(LinkageName));
1009
1010   // If this DIE is going to refer declaration info using AT_specification
1011   // then there is no need to add other attributes.
1012   if (DeclDie) {
1013     // Refer function declaration directly.
1014     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1015                 DeclDie);
1016
1017     return SPDie;
1018   }
1019
1020   // Constructors and operators for anonymous aggregates do not have names.
1021   if (!SP.getName().empty())
1022     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1023
1024   addSourceLine(SPDie, SP);
1025
1026   if (SP.isPrototyped())
1027     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1028
1029   // Add Return Type.
1030   DICompositeType SPTy = SP.getType();
1031   DIArray Args = SPTy.getTypeArray();
1032   unsigned SPTag = SPTy.getTag();
1033
1034   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1035     addType(SPDie, SPTy);
1036   else
1037     addType(SPDie, DIType(Args.getElement(0)));
1038
1039   unsigned VK = SP.getVirtuality();
1040   if (VK) {
1041     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1042     DIEBlock *Block = getDIEBlock();
1043     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1044     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1045     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1046     ContainingTypeMap.insert(std::make_pair(SPDie,
1047                                             SP.getContainingType()));
1048   }
1049
1050   if (!SP.isDefinition()) {
1051     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1052
1053     // Add arguments. Do not add arguments for subprogram definition. They will
1054     // be handled while processing variables.
1055     DICompositeType SPTy = SP.getType();
1056     DIArray Args = SPTy.getTypeArray();
1057     unsigned SPTag = SPTy.getTag();
1058
1059     if (SPTag == dwarf::DW_TAG_subroutine_type)
1060       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1061         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1062         DIType ATy = DIType(DIType(Args.getElement(i)));
1063         addType(Arg, ATy);
1064         if (ATy.isArtificial())
1065           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1066         SPDie->addChild(Arg);
1067       }
1068   }
1069
1070   if (SP.isArtificial())
1071     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1072
1073   if (!SP.isLocalToUnit())
1074     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1075
1076   if (SP.isOptimized())
1077     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1078
1079   if (unsigned isa = Asm->getISAEncoding()) {
1080     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1081   }
1082
1083   return SPDie;
1084 }
1085
1086 // Return const expression if value is a GEP to access merged global
1087 // constant. e.g.
1088 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1089 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1090   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1091   if (!CE || CE->getNumOperands() != 3 ||
1092       CE->getOpcode() != Instruction::GetElementPtr)
1093     return NULL;
1094
1095   // First operand points to a global struct.
1096   Value *Ptr = CE->getOperand(0);
1097   if (!isa<GlobalValue>(Ptr) ||
1098       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1099     return NULL;
1100
1101   // Second operand is zero.
1102   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1103   if (!CI || !CI->isZero())
1104     return NULL;
1105
1106   // Third operand is offset.
1107   if (!isa<ConstantInt>(CE->getOperand(2)))
1108     return NULL;
1109
1110   return CE;
1111 }
1112
1113 /// createGlobalVariableDIE - create global variable DIE.
1114 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1115   // Check for pre-existence.
1116   if (getDIE(N))
1117     return;
1118
1119   DIGlobalVariable GV(N);
1120   if (!GV.Verify())
1121     return;
1122
1123   DIE *VariableDIE = new DIE(GV.getTag());
1124   // Add to map.
1125   insertDIE(N, VariableDIE);
1126
1127   // Add name.
1128   addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1129   StringRef LinkageName = GV.getLinkageName();
1130   bool isGlobalVariable = GV.getGlobal() != NULL;
1131   if (!LinkageName.empty() && isGlobalVariable)
1132     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1133               getRealLinkageName(LinkageName));
1134   // Add type.
1135   DIType GTy = GV.getType();
1136   addType(VariableDIE, GTy);
1137
1138   // Add scoping info.
1139   if (!GV.isLocalToUnit())
1140     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1141
1142   // Add line number info.
1143   addSourceLine(VariableDIE, GV);
1144   // Add to context owner.
1145   DIDescriptor GVContext = GV.getContext();
1146   addToContextOwner(VariableDIE, GVContext);
1147   // Add location.
1148   bool addToAccelTable = false;
1149   DIE *VariableSpecDIE = NULL;
1150   if (isGlobalVariable) {
1151     addToAccelTable = true;
1152     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1153     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1154     addLabel(Block, 0, dwarf::DW_FORM_udata,
1155              Asm->Mang->getSymbol(GV.getGlobal()));
1156     // Do not create specification DIE if context is either compile unit
1157     // or a subprogram.
1158     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1159         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1160       // Create specification DIE.
1161       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1162       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1163                   dwarf::DW_FORM_ref4, VariableDIE);
1164       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1165       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1166                      1);
1167       addDie(VariableSpecDIE);
1168     } else {
1169       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1170     }
1171   } else if (const ConstantInt *CI =
1172              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1173     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1174   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1175     addToAccelTable = true;
1176     // GV is a merged global.
1177     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1178     Value *Ptr = CE->getOperand(0);
1179     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1180     addLabel(Block, 0, dwarf::DW_FORM_udata,
1181                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1182     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1183     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1184     addUInt(Block, 0, dwarf::DW_FORM_udata,
1185                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1186     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1187     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1188   }
1189
1190   if (addToAccelTable) {
1191     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1192     addAccelName(GV.getName(), AddrDIE);
1193
1194     // If the linkage name is different than the name, go ahead and output
1195     // that as well into the name table.
1196     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1197       addAccelName(GV.getLinkageName(), AddrDIE);
1198   }
1199
1200   return;
1201 }
1202
1203 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1204 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1205   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1206   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1207   uint64_t L = SR.getLo();
1208   uint64_t H = SR.getHi();
1209
1210   // The L value defines the lower bounds which is typically zero for C/C++. The
1211   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
1212   // of the array. If L > H then do not emit DW_AT_lower_bound and
1213   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1214   // array has one element and in such case do not emit lower bound.
1215
1216   if (L > H) {
1217     Buffer.addChild(DW_Subrange);
1218     return;
1219   }
1220   if (L)
1221     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1222   addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1223   Buffer.addChild(DW_Subrange);
1224 }
1225
1226 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1227 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1228                                         DICompositeType *CTy) {
1229   Buffer.setTag(dwarf::DW_TAG_array_type);
1230   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1231     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1232
1233   // Emit derived type.
1234   addType(&Buffer, CTy->getTypeDerivedFrom());
1235   DIArray Elements = CTy->getTypeArray();
1236
1237   // Get an anonymous type for index type.
1238   DIE *IdxTy = getIndexTyDie();
1239   if (!IdxTy) {
1240     // Construct an anonymous type for index type.
1241     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1242     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1243     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1244             dwarf::DW_ATE_signed);
1245     addDie(IdxTy);
1246     setIndexTyDie(IdxTy);
1247   }
1248
1249   // Add subranges to array type.
1250   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1251     DIDescriptor Element = Elements.getElement(i);
1252     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1253       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1254   }
1255 }
1256
1257 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1258 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1259   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1260   StringRef Name = ETy.getName();
1261   addString(Enumerator, dwarf::DW_AT_name, Name);
1262   int64_t Value = ETy.getEnumValue();
1263   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1264   return Enumerator;
1265 }
1266
1267 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1268 /// vtables.
1269 void CompileUnit::constructContainingTypeDIEs() {
1270   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1271          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1272     DIE *SPDie = CI->first;
1273     const MDNode *N = CI->second;
1274     if (!N) continue;
1275     DIE *NDie = getDIE(N);
1276     if (!NDie) continue;
1277     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1278   }
1279 }
1280
1281 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1282 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1283   StringRef Name = DV->getName();
1284   if (Name.empty())
1285     return NULL;
1286
1287   // Translate tag to proper Dwarf tag.
1288   unsigned Tag = DV->getTag();
1289
1290   // Define variable debug information entry.
1291   DIE *VariableDie = new DIE(Tag);
1292   DbgVariable *AbsVar = DV->getAbstractVariable();
1293   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1294   if (AbsDIE)
1295     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1296                             dwarf::DW_FORM_ref4, AbsDIE);
1297   else {
1298     addString(VariableDie, dwarf::DW_AT_name, Name);
1299     addSourceLine(VariableDie, DV->getVariable());
1300     addType(VariableDie, DV->getType());
1301   }
1302
1303   if (DV->isArtificial())
1304     addUInt(VariableDie, dwarf::DW_AT_artificial,
1305                         dwarf::DW_FORM_flag, 1);
1306
1307   if (isScopeAbstract) {
1308     DV->setDIE(VariableDie);
1309     return VariableDie;
1310   }
1311
1312   // Add variable address.
1313
1314   unsigned Offset = DV->getDotDebugLocOffset();
1315   if (Offset != ~0U) {
1316     addLabel(VariableDie, dwarf::DW_AT_location,
1317                          dwarf::DW_FORM_data4,
1318                          Asm->GetTempSymbol("debug_loc", Offset));
1319     DV->setDIE(VariableDie);
1320     return VariableDie;
1321   }
1322
1323   // Check if variable is described by a DBG_VALUE instruction.
1324   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1325     bool updated = false;
1326     if (DVInsn->getNumOperands() == 3) {
1327       if (DVInsn->getOperand(0).isReg()) {
1328         const MachineOperand RegOp = DVInsn->getOperand(0);
1329         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1330         if (DVInsn->getOperand(1).isImm() &&
1331             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1332           unsigned FrameReg = 0;
1333           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1334           int Offset =
1335             TFI->getFrameIndexReference(*Asm->MF,
1336                                         DVInsn->getOperand(1).getImm(),
1337                                         FrameReg);
1338           MachineLocation Location(FrameReg, Offset);
1339           addVariableAddress(DV, VariableDie, Location);
1340
1341         } else if (RegOp.getReg())
1342           addVariableAddress(DV, VariableDie,
1343                                          MachineLocation(RegOp.getReg()));
1344         updated = true;
1345       }
1346       else if (DVInsn->getOperand(0).isImm())
1347         updated =
1348           addConstantValue(VariableDie, DVInsn->getOperand(0),
1349                                        DV->getType());
1350       else if (DVInsn->getOperand(0).isFPImm())
1351         updated =
1352           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1353       else if (DVInsn->getOperand(0).isCImm())
1354         updated =
1355           addConstantValue(VariableDie,
1356                                        DVInsn->getOperand(0).getCImm(),
1357                                        DV->getType().isUnsignedDIType());
1358     } else {
1359       addVariableAddress(DV, VariableDie,
1360                                      Asm->getDebugValueLocation(DVInsn));
1361       updated = true;
1362     }
1363     if (!updated) {
1364       // If variableDie is not updated then DBG_VALUE instruction does not
1365       // have valid variable info.
1366       delete VariableDie;
1367       return NULL;
1368     }
1369     DV->setDIE(VariableDie);
1370     return VariableDie;
1371   } else {
1372     // .. else use frame index.
1373     int FI = DV->getFrameIndex();
1374     if (FI != ~0) {
1375       unsigned FrameReg = 0;
1376       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1377       int Offset =
1378         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1379       MachineLocation Location(FrameReg, Offset);
1380       addVariableAddress(DV, VariableDie, Location);
1381     }
1382   }
1383
1384   DV->setDIE(VariableDie);
1385   return VariableDie;
1386 }
1387
1388 /// createMemberDIE - Create new member DIE.
1389 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1390   DIE *MemberDie = new DIE(DT.getTag());
1391   StringRef Name = DT.getName();
1392   if (!Name.empty())
1393     addString(MemberDie, dwarf::DW_AT_name, Name);
1394
1395   addType(MemberDie, DT.getTypeDerivedFrom());
1396
1397   addSourceLine(MemberDie, DT);
1398
1399   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1400   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1401
1402   uint64_t Size = DT.getSizeInBits();
1403   uint64_t FieldSize = DT.getOriginalTypeSize();
1404
1405   if (Size != FieldSize) {
1406     // Handle bitfield.
1407     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1408     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1409
1410     uint64_t Offset = DT.getOffsetInBits();
1411     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1412     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1413     uint64_t FieldOffset = (HiMark - FieldSize);
1414     Offset -= FieldOffset;
1415
1416     // Maybe we need to work from the other end.
1417     if (Asm->getTargetData().isLittleEndian())
1418       Offset = FieldSize - (Offset + Size);
1419     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1420
1421     // Here WD_AT_data_member_location points to the anonymous
1422     // field that includes this bit field.
1423     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1424
1425   } else
1426     // This is not a bitfield.
1427     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1428
1429   if (DT.getTag() == dwarf::DW_TAG_inheritance
1430       && DT.isVirtual()) {
1431
1432     // For C++, virtual base classes are not at fixed offset. Use following
1433     // expression to extract appropriate offset from vtable.
1434     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1435
1436     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1437     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1438     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1439     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1440     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1441     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1442     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1443     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1444
1445     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1446              VBaseLocationDie);
1447   } else
1448     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1449
1450   if (DT.isProtected())
1451     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1452             dwarf::DW_ACCESS_protected);
1453   else if (DT.isPrivate())
1454     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1455             dwarf::DW_ACCESS_private);
1456   // Otherwise C++ member and base classes are considered public.
1457   else
1458     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1459             dwarf::DW_ACCESS_public);
1460   if (DT.isVirtual())
1461     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1462             dwarf::DW_VIRTUALITY_virtual);
1463
1464   // Objective-C properties.
1465   if (MDNode *PNode = DT.getObjCProperty())
1466     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1467       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1468                           PropertyDie);
1469
1470   // This is only for backward compatibility.
1471   StringRef PropertyName = DT.getObjCPropertyName();
1472   if (!PropertyName.empty()) {
1473     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1474     StringRef GetterName = DT.getObjCPropertyGetterName();
1475     if (!GetterName.empty())
1476       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1477     StringRef SetterName = DT.getObjCPropertySetterName();
1478     if (!SetterName.empty())
1479       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1480     unsigned PropertyAttributes = 0;
1481     if (DT.isReadOnlyObjCProperty())
1482       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1483     if (DT.isReadWriteObjCProperty())
1484       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1485     if (DT.isAssignObjCProperty())
1486       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1487     if (DT.isRetainObjCProperty())
1488       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1489     if (DT.isCopyObjCProperty())
1490       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1491     if (DT.isNonAtomicObjCProperty())
1492       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1493     if (PropertyAttributes)
1494       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1495               PropertyAttributes);
1496   }
1497   return MemberDie;
1498 }