lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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