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