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