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