contrib/llvm/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
 102 /// addBlock - Add block data.
 103 ///
 104 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
 105                            DIEBlock *Block) {
 106   Block->ComputeSize(Asm);
 107   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 108   Die->addValue(Attribute, Block->BestForm(), Block);
 109 }
 110
 111 /// addSourceLine - Add location information to specified debug information
 112 /// entry.
 113 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
 114   // Verify variable.
 115   if (!V.Verify())
 116     return;
 117
 118   unsigned Line = V.getLineNumber();
 119   if (Line == 0)
 120     return;
 121   unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
 122                                             V.getContext().getDirectory());
 123   assert(FileID && "Invalid file id");
 124   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 125   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 126 }
 127
 128 /// addSourceLine - Add location information to specified debug information
 129 /// entry.
 130 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
 131   // Verify global variable.
 132   if (!G.Verify())
 133     return;
 134
 135   unsigned Line = G.getLineNumber();
 136   if (Line == 0)
 137     return;
 138   unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(),
 139                                             G.getDirectory());
 140   assert(FileID && "Invalid file id");
 141   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 142   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 143 }
 144
 145 /// addSourceLine - Add location information to specified debug information
 146 /// entry.
 147 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
 148   // Verify subprogram.
 149   if (!SP.Verify())
 150     return;
 151   // If the line number is 0, don't add it.
 152   if (SP.getLineNumber() == 0)
 153     return;
 154
 155   unsigned Line = SP.getLineNumber();
 156   if (!SP.getContext().Verify())
 157     return;
 158   unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(), SP.getDirectory());
 159   assert(FileID && "Invalid file id");
 160   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 161   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 162 }
 163
 164 /// addSourceLine - Add location information to specified debug information
 165 /// entry.
 166 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
 167   // Verify type.
 168   if (!Ty.Verify())
 169     return;
 170
 171   unsigned Line = Ty.getLineNumber();
 172   if (Line == 0 || !Ty.getContext().Verify())
 173     return;
 174   unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(), 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 uint64_t *Ptr64 = Val.getRawData();
 531
 532   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 533   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 534
 535   // Output the constant to DWARF one byte at a time.
 536   for (int i = 0; i < NumBytes; i++) {
 537     uint8_t c;
 538     if (LittleEndian)
 539       c = Ptr64[i / 8] >> (8 * (i & 7));
 540     else
 541       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 542     addUInt(Block, 0, dwarf::DW_FORM_data1, c);
 543   }
 544
 545   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 546   return true;
 547 }
 548
 549 /// addTemplateParams - Add template parameters in buffer.
 550 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 551   // Add template parameters.
 552   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 553     DIDescriptor Element = TParams.getElement(i);
 554     if (Element.isTemplateTypeParameter())
 555       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 556                         DITemplateTypeParameter(Element)));
 557     else if (Element.isTemplateValueParameter())
 558       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 559                         DITemplateValueParameter(Element)));
 560   }
 561
 562 }
 563 /// addToContextOwner - Add Die into the list of its context owner's children.
 564 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 565   if (Context.isType()) {
 566     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
 567     ContextDIE->addChild(Die);
 568   } else if (Context.isNameSpace()) {
 569     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
 570     ContextDIE->addChild(Die);
 571   } else if (Context.isSubprogram()) {
 572     DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
 573     ContextDIE->addChild(Die);
 574   } else if (DIE *ContextDIE = getDIE(Context))
 575     ContextDIE->addChild(Die);
 576   else
 577     addDie(Die);
 578 }
 579
 580 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 581 /// given DIType.
 582 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 583   DIType Ty(TyNode);
 584   if (!Ty.Verify())
 585     return NULL;
 586   DIE *TyDIE = getDIE(Ty);
 587   if (TyDIE)
 588     return TyDIE;
 589
 590   // Create new type.
 591   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 592   insertDIE(Ty, TyDIE);
 593   if (Ty.isBasicType())
 594     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 595   else if (Ty.isCompositeType())
 596     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 597   else {
 598     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 599     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 600   }
 601
 602   addToContextOwner(TyDIE, Ty.getContext());
 603   return TyDIE;
 604 }
 605
 606 /// addType - Add a new type attribute to the specified entity.
 607 void CompileUnit::addType(DIE *Entity, DIType Ty) {
 608   if (!Ty.Verify())
 609     return;
 610
 611   // Check for pre-existence.
 612   DIEEntry *Entry = getDIEEntry(Ty);
 613   // If it exists then use the existing value.
 614   if (Entry) {
 615     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 616     return;
 617   }
 618
 619   // Construct type.
 620   DIE *Buffer = getOrCreateTypeDIE(Ty);
 621
 622   // Set up proxy.
 623   Entry = createDIEEntry(Buffer);
 624   insertDIEEntry(Ty, Entry);
 625   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 626
 627   // If this is a complete composite type then include it in the
 628   // list of global types.
 629   addGlobalType(Ty);
 630 }
 631
 632 /// addGlobalType - Add a new global type to the compile unit.
 633 ///
 634 void CompileUnit::addGlobalType(DIType Ty) {
 635   DIDescriptor Context = Ty.getContext();
 636   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
 637       && (!Context || Context.isCompileUnit() || Context.isFile()
 638           || Context.isNameSpace()))
 639     if (DIEEntry *Entry = getDIEEntry(Ty))
 640       GlobalTypes[Ty.getName()] = Entry->getEntry();
 641 }
 642
 643 /// addPubTypes - Add type for pubtypes section.
 644 void CompileUnit::addPubTypes(DISubprogram SP) {
 645   DICompositeType SPTy = SP.getType();
 646   unsigned SPTag = SPTy.getTag();
 647   if (SPTag != dwarf::DW_TAG_subroutine_type)
 648     return;
 649
 650   DIArray Args = SPTy.getTypeArray();
 651   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 652     DIType ATy(Args.getElement(i));
 653     if (!ATy.Verify())
 654       continue;
 655     addGlobalType(ATy);
 656   }
 657 }
 658
 659 /// constructTypeDIE - Construct basic type die from DIBasicType.
 660 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 661   // Get core information.
 662   StringRef Name = BTy.getName();
 663   // Add name if not anonymous or intermediate type.
 664   if (!Name.empty())
 665     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 666
 667   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 668     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 669     // Unspecified types has only name, nothing else.
 670     return;
 671   }
 672
 673   Buffer.setTag(dwarf::DW_TAG_base_type);
 674   addUInt(&Buffer, dwarf::DW_AT_encoding,  dwarf::DW_FORM_data1,
 675           BTy.getEncoding());
 676
 677   uint64_t Size = BTy.getSizeInBits() >> 3;
 678   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 679 }
 680
 681 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 682 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 683   // Get core information.
 684   StringRef Name = DTy.getName();
 685   uint64_t Size = DTy.getSizeInBits() >> 3;
 686   unsigned Tag = DTy.getTag();
 687
 688   // FIXME - Workaround for templates.
 689   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 690
 691   Buffer.setTag(Tag);
 692
 693   // Map to main type, void will not have a type.
 694   DIType FromTy = DTy.getTypeDerivedFrom();
 695   addType(&Buffer, FromTy);
 696
 697   // Add name if not anonymous or intermediate type.
 698   if (!Name.empty())
 699     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 700
 701   // Add size if non-zero (derived types might be zero-sized.)
 702   if (Size)
 703     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 704
 705   // Add source line info if available and TyDesc is not a forward declaration.
 706   if (!DTy.isForwardDecl())
 707     addSourceLine(&Buffer, DTy);
 708 }
 709
 710 /// constructTypeDIE - Construct type DIE from DICompositeType.
 711 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 712   // Get core information.
 713   StringRef Name = CTy.getName();
 714
 715   uint64_t Size = CTy.getSizeInBits() >> 3;
 716   unsigned Tag = CTy.getTag();
 717   Buffer.setTag(Tag);
 718
 719   switch (Tag) {
 720   case dwarf::DW_TAG_vector_type:
 721   case dwarf::DW_TAG_array_type:
 722     constructArrayTypeDIE(Buffer, &CTy);
 723     break;
 724   case dwarf::DW_TAG_enumeration_type: {
 725     DIArray Elements = CTy.getTypeArray();
 726
 727     // Add enumerators to enumeration type.
 728     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 729       DIE *ElemDie = NULL;
 730       DIDescriptor Enum(Elements.getElement(i));
 731       if (Enum.isEnumerator()) {
 732         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 733         Buffer.addChild(ElemDie);
 734       }
 735     }
 736   }
 737     break;
 738   case dwarf::DW_TAG_subroutine_type: {
 739     // Add return type.
 740     DIArray Elements = CTy.getTypeArray();
 741     DIDescriptor RTy = Elements.getElement(0);
 742     addType(&Buffer, DIType(RTy));
 743
 744     bool isPrototyped = true;
 745     // Add arguments.
 746     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 747       DIDescriptor Ty = Elements.getElement(i);
 748       if (Ty.isUnspecifiedParameter()) {
 749         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 750         Buffer.addChild(Arg);
 751         isPrototyped = false;
 752       } else {
 753         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 754         addType(Arg, DIType(Ty));
 755         Buffer.addChild(Arg);
 756       }
 757     }
 758     // Add prototype flag.
 759     if (isPrototyped)
 760       addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 761   }
 762     break;
 763   case dwarf::DW_TAG_structure_type:
 764   case dwarf::DW_TAG_union_type:
 765   case dwarf::DW_TAG_class_type: {
 766     // Add elements to structure type.
 767     DIArray Elements = CTy.getTypeArray();
 768
 769     // A forward struct declared type may not have elements available.
 770     unsigned N = Elements.getNumElements();
 771     if (N == 0)
 772       break;
 773
 774     // Add elements to structure type.
 775     for (unsigned i = 0; i < N; ++i) {
 776       DIDescriptor Element = Elements.getElement(i);
 777       DIE *ElemDie = NULL;
 778       if (Element.isSubprogram()) {
 779         DISubprogram SP(Element);
 780         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
 781         if (SP.isProtected())
 782           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 783                   dwarf::DW_ACCESS_protected);
 784         else if (SP.isPrivate())
 785           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 786                   dwarf::DW_ACCESS_private);
 787         else
 788           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 789             dwarf::DW_ACCESS_public);
 790         if (SP.isExplicit())
 791           addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
 792       }
 793       else if (Element.isVariable()) {
 794         DIVariable DV(Element);
 795         ElemDie = new DIE(dwarf::DW_TAG_variable);
 796         addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 797                   DV.getName());
 798         addType(ElemDie, DV.getType());
 799         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 800         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 801         addSourceLine(ElemDie, DV);
 802       } else if (Element.isDerivedType())
 803         ElemDie = createMemberDIE(DIDerivedType(Element));
 804       else
 805         continue;
 806       Buffer.addChild(ElemDie);
 807     }
 808
 809     if (CTy.isAppleBlockExtension())
 810       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 811
 812     unsigned RLang = CTy.getRunTimeLang();
 813     if (RLang)
 814       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 815               dwarf::DW_FORM_data1, RLang);
 816
 817     DICompositeType ContainingType = CTy.getContainingType();
 818     if (DIDescriptor(ContainingType).isCompositeType())
 819       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 820                   getOrCreateTypeDIE(DIType(ContainingType)));
 821     else {
 822       DIDescriptor Context = CTy.getContext();
 823       addToContextOwner(&Buffer, Context);
 824     }
 825
 826     if (CTy.isObjcClassComplete())
 827       addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
 828               dwarf::DW_FORM_flag, 1);
 829
 830     if (Tag == dwarf::DW_TAG_class_type)
 831       addTemplateParams(Buffer, CTy.getTemplateParams());
 832
 833     break;
 834   }
 835   default:
 836     break;
 837   }
 838
 839   // Add name if not anonymous or intermediate type.
 840   if (!Name.empty())
 841     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 842
 843   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 844       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 845     {
 846     // Add size if non-zero (derived types might be zero-sized.)
 847     if (Size)
 848       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 849     else {
 850       // Add zero size if it is not a forward declaration.
 851       if (CTy.isForwardDecl())
 852         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 853       else
 854         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 855     }
 856
 857     // Add source line info if available.
 858     if (!CTy.isForwardDecl())
 859       addSourceLine(&Buffer, CTy);
 860   }
 861 }
 862
 863 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 864 /// for the given DITemplateTypeParameter.
 865 DIE *
 866 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 867   DIE *ParamDIE = getDIE(TP);
 868   if (ParamDIE)
 869     return ParamDIE;
 870
 871   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 872   addType(ParamDIE, TP.getType());
 873   addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
 874   return ParamDIE;
 875 }
 876
 877 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 878 /// for the given DITemplateValueParameter.
 879 DIE *
 880 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 881   DIE *ParamDIE = getDIE(TPV);
 882   if (ParamDIE)
 883     return ParamDIE;
 884
 885   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 886   addType(ParamDIE, TPV.getType());
 887   if (!TPV.getName().empty())
 888     addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
 889   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 890           TPV.getValue());
 891   return ParamDIE;
 892 }
 893
 894 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 895 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 896   DIE *NDie = getDIE(NS);
 897   if (NDie)
 898     return NDie;
 899   NDie = new DIE(dwarf::DW_TAG_namespace);
 900   insertDIE(NS, NDie);
 901   if (!NS.getName().empty())
 902     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
 903   addSourceLine(NDie, NS);
 904   addToContextOwner(NDie, NS.getContext());
 905   return NDie;
 906 }
 907
 908 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
 909 /// printer to not emit usual symbol prefix before the symbol name is used then
 910 /// return linkage name after skipping this special LLVM prefix.
 911 static StringRef getRealLinkageName(StringRef LinkageName) {
 912   char One = '\1';
 913   if (LinkageName.startswith(StringRef(&One, 1)))
 914     return LinkageName.substr(1);
 915   return LinkageName;
 916 }
 917
 918 /// getOrCreateSubprogramDIE - Create new DIE using SP.
 919 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
 920   DIE *SPDie = getDIE(SP);
 921   if (SPDie)
 922     return SPDie;
 923
 924   SPDie = new DIE(dwarf::DW_TAG_subprogram);
 925
 926   // DW_TAG_inlined_subroutine may refer to this DIE.
 927   insertDIE(SP, SPDie);
 928
 929   // Add to context owner.
 930   addToContextOwner(SPDie, SP.getContext());
 931
 932   // Add function template parameters.
 933   addTemplateParams(*SPDie, SP.getTemplateParams());
 934
 935   StringRef LinkageName = SP.getLinkageName();
 936   if (!LinkageName.empty())
 937     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
 938                     dwarf::DW_FORM_string,
 939                     getRealLinkageName(LinkageName));
 940
 941   // If this DIE is going to refer declaration info using AT_specification
 942   // then there is no need to add other attributes.
 943   if (SP.getFunctionDeclaration().isSubprogram())
 944     return SPDie;
 945
 946   // Constructors and operators for anonymous aggregates do not have names.
 947   if (!SP.getName().empty())
 948     addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 949                     SP.getName());
 950
 951   addSourceLine(SPDie, SP);
 952
 953   if (SP.isPrototyped())
 954     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 955
 956   // Add Return Type.
 957   DICompositeType SPTy = SP.getType();
 958   DIArray Args = SPTy.getTypeArray();
 959   unsigned SPTag = SPTy.getTag();
 960
 961   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
 962     addType(SPDie, SPTy);
 963   else
 964     addType(SPDie, DIType(Args.getElement(0)));
 965
 966   unsigned VK = SP.getVirtuality();
 967   if (VK) {
 968     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
 969     DIEBlock *Block = getDIEBlock();
 970     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 971     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
 972     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
 973     ContainingTypeMap.insert(std::make_pair(SPDie,
 974                                             SP.getContainingType()));
 975   }
 976
 977   if (!SP.isDefinition()) {
 978     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 979
 980     // Add arguments. Do not add arguments for subprogram definition. They will
 981     // be handled while processing variables.
 982     DICompositeType SPTy = SP.getType();
 983     DIArray Args = SPTy.getTypeArray();
 984     unsigned SPTag = SPTy.getTag();
 985
 986     if (SPTag == dwarf::DW_TAG_subroutine_type)
 987       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
 988         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 989         DIType ATy = DIType(DIType(Args.getElement(i)));
 990         addType(Arg, ATy);
 991         if (ATy.isArtificial())
 992           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
 993         SPDie->addChild(Arg);
 994       }
 995   }
 996
 997   if (SP.isArtificial())
 998     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
 999
1000   if (!SP.isLocalToUnit())
1001     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1002
1003   if (SP.isOptimized())
1004     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1005
1006   if (unsigned isa = Asm->getISAEncoding()) {
1007     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1008   }
1009
1010   return SPDie;
1011 }
1012
1013 // Return const expression if value is a GEP to access merged global
1014 // constant. e.g.
1015 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1016 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1017   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1018   if (!CE || CE->getNumOperands() != 3 ||
1019       CE->getOpcode() != Instruction::GetElementPtr)
1020     return NULL;
1021
1022   // First operand points to a global struct.
1023   Value *Ptr = CE->getOperand(0);
1024   if (!isa<GlobalValue>(Ptr) ||
1025       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1026     return NULL;
1027
1028   // Second operand is zero.
1029   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1030   if (!CI || !CI->isZero())
1031     return NULL;
1032
1033   // Third operand is offset.
1034   if (!isa<ConstantInt>(CE->getOperand(2)))
1035     return NULL;
1036
1037   return CE;
1038 }
1039
1040 /// createGlobalVariableDIE - create global variable DIE.
1041 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1042   // Check for pre-existence.
1043   if (getDIE(N))
1044     return;
1045
1046   DIGlobalVariable GV(N);
1047   if (!GV.Verify())
1048     return;
1049
1050   DIE *VariableDIE = new DIE(GV.getTag());
1051   // Add to map.
1052   insertDIE(N, VariableDIE);
1053
1054   // Add name.
1055   addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1056                    GV.getDisplayName());
1057   StringRef LinkageName = GV.getLinkageName();
1058   bool isGlobalVariable = GV.getGlobal() != NULL;
1059   if (!LinkageName.empty() && isGlobalVariable)
1060     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1061                      dwarf::DW_FORM_string,
1062                      getRealLinkageName(LinkageName));
1063   // Add type.
1064   DIType GTy = GV.getType();
1065   addType(VariableDIE, GTy);
1066
1067   // Add scoping info.
1068   if (!GV.isLocalToUnit()) {
1069     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1070     // Expose as global.
1071     addGlobal(GV.getName(), VariableDIE);
1072   }
1073   // Add line number info.
1074   addSourceLine(VariableDIE, GV);
1075   // Add to context owner.
1076   DIDescriptor GVContext = GV.getContext();
1077   addToContextOwner(VariableDIE, GVContext);
1078   // Add location.
1079   if (isGlobalVariable) {
1080     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1081     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1082     addLabel(Block, 0, dwarf::DW_FORM_udata,
1083              Asm->Mang->getSymbol(GV.getGlobal()));
1084     // Do not create specification DIE if context is either compile unit
1085     // or a subprogram.
1086     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1087         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1088       // Create specification DIE.
1089       DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1090       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1091                   dwarf::DW_FORM_ref4, VariableDIE);
1092       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1093       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1094                      1);
1095       addDie(VariableSpecDIE);
1096     } else {
1097       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1098     }
1099   } else if (const ConstantInt *CI =
1100              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1101     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1102   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1103     // GV is a merged global.
1104     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1105     Value *Ptr = CE->getOperand(0);
1106     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1107     addLabel(Block, 0, dwarf::DW_FORM_udata,
1108                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1109     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1110     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1111     addUInt(Block, 0, dwarf::DW_FORM_udata,
1112                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1113     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1114     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1115   }
1116
1117   return;
1118 }
1119
1120 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1121 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1122   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1123   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1124   int64_t L = SR.getLo();
1125   int64_t H = SR.getHi();
1126
1127   // The L value defines the lower bounds which is typically zero for C/C++. The
1128   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
1129   // of the array. If L > H then do not emit DW_AT_lower_bound and
1130   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1131   // array has one element and in such case do not emit lower bound.
1132
1133   if (L > H) {
1134     Buffer.addChild(DW_Subrange);
1135     return;
1136   }
1137   if (L)
1138     addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1139   addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1140   Buffer.addChild(DW_Subrange);
1141 }
1142
1143 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1144 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1145                                         DICompositeType *CTy) {
1146   Buffer.setTag(dwarf::DW_TAG_array_type);
1147   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1148     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1149
1150   // Emit derived type.
1151   addType(&Buffer, CTy->getTypeDerivedFrom());
1152   DIArray Elements = CTy->getTypeArray();
1153
1154   // Get an anonymous type for index type.
1155   DIE *IdxTy = getIndexTyDie();
1156   if (!IdxTy) {
1157     // Construct an anonymous type for index type.
1158     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1159     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1160     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1161             dwarf::DW_ATE_signed);
1162     addDie(IdxTy);
1163     setIndexTyDie(IdxTy);
1164   }
1165
1166   // Add subranges to array type.
1167   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1168     DIDescriptor Element = Elements.getElement(i);
1169     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1170       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1171   }
1172 }
1173
1174 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1175 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1176   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1177   StringRef Name = ETy.getName();
1178   addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1179   int64_t Value = ETy.getEnumValue();
1180   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1181   return Enumerator;
1182 }
1183
1184 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1185 /// vtables.
1186 void CompileUnit::constructContainingTypeDIEs() {
1187   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1188          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1189     DIE *SPDie = CI->first;
1190     const MDNode *N = CI->second;
1191     if (!N) continue;
1192     DIE *NDie = getDIE(N);
1193     if (!NDie) continue;
1194     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1195   }
1196 }
1197
1198 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1199 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1200   StringRef Name = DV->getName();
1201   if (Name.empty())
1202     return NULL;
1203
1204   // Translate tag to proper Dwarf tag.
1205   unsigned Tag = DV->getTag();
1206
1207   // Define variable debug information entry.
1208   DIE *VariableDie = new DIE(Tag);
1209   DbgVariable *AbsVar = DV->getAbstractVariable();
1210   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1211   if (AbsDIE)
1212     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1213                             dwarf::DW_FORM_ref4, AbsDIE);
1214   else {
1215     addString(VariableDie, dwarf::DW_AT_name,
1216                           dwarf::DW_FORM_string, Name);
1217     addSourceLine(VariableDie, DV->getVariable());
1218     addType(VariableDie, DV->getType());
1219   }
1220
1221   if (DV->isArtificial())
1222     addUInt(VariableDie, dwarf::DW_AT_artificial,
1223                         dwarf::DW_FORM_flag, 1);
1224
1225   if (isScopeAbstract) {
1226     DV->setDIE(VariableDie);
1227     return VariableDie;
1228   }
1229
1230   // Add variable address.
1231
1232   unsigned Offset = DV->getDotDebugLocOffset();
1233   if (Offset != ~0U) {
1234     addLabel(VariableDie, dwarf::DW_AT_location,
1235                          dwarf::DW_FORM_data4,
1236                          Asm->GetTempSymbol("debug_loc", Offset));
1237     DV->setDIE(VariableDie);
1238     return VariableDie;
1239   }
1240
1241   // Check if variable is described by a DBG_VALUE instruction.
1242   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1243     bool updated = false;
1244     if (DVInsn->getNumOperands() == 3) {
1245       if (DVInsn->getOperand(0).isReg()) {
1246         const MachineOperand RegOp = DVInsn->getOperand(0);
1247         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1248         if (DVInsn->getOperand(1).isImm() &&
1249             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1250           unsigned FrameReg = 0;
1251           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1252           int Offset =
1253             TFI->getFrameIndexReference(*Asm->MF,
1254                                         DVInsn->getOperand(1).getImm(),
1255                                         FrameReg);
1256           MachineLocation Location(FrameReg, Offset);
1257           addVariableAddress(DV, VariableDie, Location);
1258
1259         } else if (RegOp.getReg())
1260           addVariableAddress(DV, VariableDie,
1261                                          MachineLocation(RegOp.getReg()));
1262         updated = true;
1263       }
1264       else if (DVInsn->getOperand(0).isImm())
1265         updated =
1266           addConstantValue(VariableDie, DVInsn->getOperand(0),
1267                                        DV->getType());
1268       else if (DVInsn->getOperand(0).isFPImm())
1269         updated =
1270           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1271       else if (DVInsn->getOperand(0).isCImm())
1272         updated =
1273           addConstantValue(VariableDie,
1274                                        DVInsn->getOperand(0).getCImm(),
1275                                        DV->getType().isUnsignedDIType());
1276     } else {
1277       addVariableAddress(DV, VariableDie,
1278                                      Asm->getDebugValueLocation(DVInsn));
1279       updated = true;
1280     }
1281     if (!updated) {
1282       // If variableDie is not updated then DBG_VALUE instruction does not
1283       // have valid variable info.
1284       delete VariableDie;
1285       return NULL;
1286     }
1287     DV->setDIE(VariableDie);
1288     return VariableDie;
1289   } else {
1290     // .. else use frame index.
1291     int FI = DV->getFrameIndex();
1292     if (FI != ~0) {
1293       unsigned FrameReg = 0;
1294       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1295       int Offset =
1296         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1297       MachineLocation Location(FrameReg, Offset);
1298       addVariableAddress(DV, VariableDie, Location);
1299     }
1300   }
1301
1302   DV->setDIE(VariableDie);
1303   return VariableDie;
1304 }
1305
1306 /// createMemberDIE - Create new member DIE.
1307 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1308   DIE *MemberDie = new DIE(DT.getTag());
1309   StringRef Name = DT.getName();
1310   if (!Name.empty())
1311     addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1312
1313   addType(MemberDie, DT.getTypeDerivedFrom());
1314
1315   addSourceLine(MemberDie, DT);
1316
1317   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1318   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1319
1320   uint64_t Size = DT.getSizeInBits();
1321   uint64_t FieldSize = DT.getOriginalTypeSize();
1322
1323   if (Size != FieldSize) {
1324     // Handle bitfield.
1325     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1326     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1327
1328     uint64_t Offset = DT.getOffsetInBits();
1329     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1330     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1331     uint64_t FieldOffset = (HiMark - FieldSize);
1332     Offset -= FieldOffset;
1333
1334     // Maybe we need to work from the other end.
1335     if (Asm->getTargetData().isLittleEndian())
1336       Offset = FieldSize - (Offset + Size);
1337     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1338
1339     // Here WD_AT_data_member_location points to the anonymous
1340     // field that includes this bit field.
1341     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1342
1343   } else
1344     // This is not a bitfield.
1345     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1346
1347   if (DT.getTag() == dwarf::DW_TAG_inheritance
1348       && DT.isVirtual()) {
1349
1350     // For C++, virtual base classes are not at fixed offset. Use following
1351     // expression to extract appropriate offset from vtable.
1352     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1353
1354     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1355     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1356     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1357     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1358     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1359     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1360     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1361     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1362
1363     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1364              VBaseLocationDie);
1365   } else
1366     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1367
1368   if (DT.isProtected())
1369     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1370             dwarf::DW_ACCESS_protected);
1371   else if (DT.isPrivate())
1372     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1373             dwarf::DW_ACCESS_private);
1374   // Otherwise C++ member and base classes are considered public.
1375   else
1376     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1377             dwarf::DW_ACCESS_public);
1378   if (DT.isVirtual())
1379     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1380             dwarf::DW_VIRTUALITY_virtual);
1381
1382   // Objective-C properties.
1383   StringRef PropertyName = DT.getObjCPropertyName();
1384   if (!PropertyName.empty()) {
1385     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string,
1386               PropertyName);
1387     StringRef GetterName = DT.getObjCPropertyGetterName();
1388     if (!GetterName.empty())
1389       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter,
1390                 dwarf::DW_FORM_string, GetterName);
1391     StringRef SetterName = DT.getObjCPropertySetterName();
1392     if (!SetterName.empty())
1393       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter,
1394                 dwarf::DW_FORM_string, SetterName);
1395     unsigned PropertyAttributes = 0;
1396     if (DT.isReadOnlyObjCProperty())
1397       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1398     if (DT.isReadWriteObjCProperty())
1399       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1400     if (DT.isAssignObjCProperty())
1401       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1402     if (DT.isRetainObjCProperty())
1403       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1404     if (DT.isCopyObjCProperty())
1405       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1406     if (DT.isNonAtomicObjCProperty())
1407       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1408     if (PropertyAttributes)
1409       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1410               PropertyAttributes);
1411   }
1412   return MemberDie;
1413 }