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