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     if (Tag == dwarf::DW_TAG_class_type)
 842       addTemplateParams(Buffer, CTy.getTemplateParams());
 843
 844     break;
 845   }
 846   default:
 847     break;
 848   }
 849
 850   // Add name if not anonymous or intermediate type.
 851   if (!Name.empty())
 852     addString(&Buffer, dwarf::DW_AT_name, Name);
 853
 854   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 855       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 856   {
 857     // Add size if non-zero (derived types might be zero-sized.)
 858     if (Size)
 859       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 860     else {
 861       // Add zero size if it is not a forward declaration.
 862       if (CTy.isForwardDecl())
 863         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 864       else
 865         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 866     }
 867
 868     // Add source line info if available.
 869     if (!CTy.isForwardDecl())
 870       addSourceLine(&Buffer, CTy);
 871   }
 872 }
 873
 874 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 875 /// for the given DITemplateTypeParameter.
 876 DIE *
 877 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 878   DIE *ParamDIE = getDIE(TP);
 879   if (ParamDIE)
 880     return ParamDIE;
 881
 882   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 883   addType(ParamDIE, TP.getType());
 884   addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
 885   return ParamDIE;
 886 }
 887
 888 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 889 /// for the given DITemplateValueParameter.
 890 DIE *
 891 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 892   DIE *ParamDIE = getDIE(TPV);
 893   if (ParamDIE)
 894     return ParamDIE;
 895
 896   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 897   addType(ParamDIE, TPV.getType());
 898   if (!TPV.getName().empty())
 899     addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
 900   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 901           TPV.getValue());
 902   return ParamDIE;
 903 }
 904
 905 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 906 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 907   DIE *NDie = getDIE(NS);
 908   if (NDie)
 909     return NDie;
 910   NDie = new DIE(dwarf::DW_TAG_namespace);
 911   insertDIE(NS, NDie);
 912   if (!NS.getName().empty()) {
 913     addString(NDie, dwarf::DW_AT_name, NS.getName());
 914     addAccelNamespace(NS.getName(), NDie);
 915   } else
 916     addAccelNamespace("(anonymous namespace)", NDie);
 917   addSourceLine(NDie, NS);
 918   addToContextOwner(NDie, NS.getContext());
 919   return NDie;
 920 }
 921
 922 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
 923 /// printer to not emit usual symbol prefix before the symbol name is used then
 924 /// return linkage name after skipping this special LLVM prefix.
 925 static StringRef getRealLinkageName(StringRef LinkageName) {
 926   char One = '\1';
 927   if (LinkageName.startswith(StringRef(&One, 1)))
 928     return LinkageName.substr(1);
 929   return LinkageName;
 930 }
 931
 932 /// getOrCreateSubprogramDIE - Create new DIE using SP.
 933 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
 934   DIE *SPDie = getDIE(SP);
 935   if (SPDie)
 936     return SPDie;
 937
 938   DISubprogram SPDecl = SP.getFunctionDeclaration();
 939   DIE *DeclDie = NULL;
 940   if (SPDecl.isSubprogram()) {
 941     DeclDie = getOrCreateSubprogramDIE(SPDecl);
 942   }
 943
 944   SPDie = new DIE(dwarf::DW_TAG_subprogram);
 945
 946   // DW_TAG_inlined_subroutine may refer to this DIE.
 947   insertDIE(SP, SPDie);
 948
 949   // Add to context owner.
 950   addToContextOwner(SPDie, SP.getContext());
 951
 952   // Add function template parameters.
 953   addTemplateParams(*SPDie, SP.getTemplateParams());
 954
 955   StringRef LinkageName = SP.getLinkageName();
 956   if (!LinkageName.empty())
 957     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
 958               getRealLinkageName(LinkageName));
 959
 960   // If this DIE is going to refer declaration info using AT_specification
 961   // then there is no need to add other attributes.
 962   if (DeclDie) {
 963     // Refer function declaration directly.
 964     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
 965                 DeclDie);
 966
 967     return SPDie;
 968   }
 969
 970   // Constructors and operators for anonymous aggregates do not have names.
 971   if (!SP.getName().empty())
 972     addString(SPDie, dwarf::DW_AT_name, SP.getName());
 973
 974   addSourceLine(SPDie, SP);
 975
 976   if (SP.isPrototyped())
 977     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 978
 979   // Add Return Type.
 980   DICompositeType SPTy = SP.getType();
 981   DIArray Args = SPTy.getTypeArray();
 982   unsigned SPTag = SPTy.getTag();
 983
 984   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
 985     addType(SPDie, SPTy);
 986   else
 987     addType(SPDie, DIType(Args.getElement(0)));
 988
 989   unsigned VK = SP.getVirtuality();
 990   if (VK) {
 991     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
 992     DIEBlock *Block = getDIEBlock();
 993     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 994     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
 995     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
 996     ContainingTypeMap.insert(std::make_pair(SPDie,
 997                                             SP.getContainingType()));
 998   }
 999
1000   if (!SP.isDefinition()) {
1001     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1002
1003     // Add arguments. Do not add arguments for subprogram definition. They will
1004     // be handled while processing variables.
1005     DICompositeType SPTy = SP.getType();
1006     DIArray Args = SPTy.getTypeArray();
1007     unsigned SPTag = SPTy.getTag();
1008
1009     if (SPTag == dwarf::DW_TAG_subroutine_type)
1010       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1011         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1012         DIType ATy = DIType(DIType(Args.getElement(i)));
1013         addType(Arg, ATy);
1014         if (ATy.isArtificial())
1015           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1016         SPDie->addChild(Arg);
1017       }
1018   }
1019
1020   if (SP.isArtificial())
1021     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1022
1023   if (!SP.isLocalToUnit())
1024     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1025
1026   if (SP.isOptimized())
1027     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1028
1029   if (unsigned isa = Asm->getISAEncoding()) {
1030     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1031   }
1032
1033   return SPDie;
1034 }
1035
1036 // Return const expression if value is a GEP to access merged global
1037 // constant. e.g.
1038 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1039 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1040   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1041   if (!CE || CE->getNumOperands() != 3 ||
1042       CE->getOpcode() != Instruction::GetElementPtr)
1043     return NULL;
1044
1045   // First operand points to a global struct.
1046   Value *Ptr = CE->getOperand(0);
1047   if (!isa<GlobalValue>(Ptr) ||
1048       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1049     return NULL;
1050
1051   // Second operand is zero.
1052   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1053   if (!CI || !CI->isZero())
1054     return NULL;
1055
1056   // Third operand is offset.
1057   if (!isa<ConstantInt>(CE->getOperand(2)))
1058     return NULL;
1059
1060   return CE;
1061 }
1062
1063 /// createGlobalVariableDIE - create global variable DIE.
1064 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1065   // Check for pre-existence.
1066   if (getDIE(N))
1067     return;
1068
1069   DIGlobalVariable GV(N);
1070   if (!GV.Verify())
1071     return;
1072
1073   DIE *VariableDIE = new DIE(GV.getTag());
1074   // Add to map.
1075   insertDIE(N, VariableDIE);
1076
1077   // Add name.
1078   addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1079   StringRef LinkageName = GV.getLinkageName();
1080   bool isGlobalVariable = GV.getGlobal() != NULL;
1081   if (!LinkageName.empty() && isGlobalVariable)
1082     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1083               getRealLinkageName(LinkageName));
1084   // Add type.
1085   DIType GTy = GV.getType();
1086   addType(VariableDIE, GTy);
1087
1088   // Add scoping info.
1089   if (!GV.isLocalToUnit())
1090     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1091
1092   // Add line number info.
1093   addSourceLine(VariableDIE, GV);
1094   // Add to context owner.
1095   DIDescriptor GVContext = GV.getContext();
1096   addToContextOwner(VariableDIE, GVContext);
1097   // Add location.
1098   bool addToAccelTable = false;
1099   DIE *VariableSpecDIE = NULL;
1100   if (isGlobalVariable) {
1101     addToAccelTable = true;
1102     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1103     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1104     addLabel(Block, 0, dwarf::DW_FORM_udata,
1105              Asm->Mang->getSymbol(GV.getGlobal()));
1106     // Do not create specification DIE if context is either compile unit
1107     // or a subprogram.
1108     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1109         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1110       // Create specification DIE.
1111       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1112       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1113                   dwarf::DW_FORM_ref4, VariableDIE);
1114       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1115       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1116                      1);
1117       addDie(VariableSpecDIE);
1118     } else {
1119       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1120     }
1121   } else if (const ConstantInt *CI =
1122              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1123     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1124   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1125     addToAccelTable = true;
1126     // GV is a merged global.
1127     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1128     Value *Ptr = CE->getOperand(0);
1129     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1130     addLabel(Block, 0, dwarf::DW_FORM_udata,
1131                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1132     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1133     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1134     addUInt(Block, 0, dwarf::DW_FORM_udata,
1135                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1136     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1137     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1138   }
1139
1140   if (addToAccelTable) {
1141     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1142     addAccelName(GV.getName(), AddrDIE);
1143
1144     // If the linkage name is different than the name, go ahead and output
1145     // that as well into the name table.
1146     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1147       addAccelName(GV.getLinkageName(), AddrDIE);
1148   }
1149
1150   return;
1151 }
1152
1153 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1154 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1155   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1156   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1157   uint64_t L = SR.getLo();
1158   uint64_t H = SR.getHi();
1159
1160   // The L value defines the lower bounds which is typically zero for C/C++. The
1161   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
1162   // of the array. If L > H then do not emit DW_AT_lower_bound and
1163   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1164   // array has one element and in such case do not emit lower bound.
1165
1166   if (L > H) {
1167     Buffer.addChild(DW_Subrange);
1168     return;
1169   }
1170   if (L)
1171     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1172   addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1173   Buffer.addChild(DW_Subrange);
1174 }
1175
1176 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1177 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1178                                         DICompositeType *CTy) {
1179   Buffer.setTag(dwarf::DW_TAG_array_type);
1180   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1181     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1182
1183   // Emit derived type.
1184   addType(&Buffer, CTy->getTypeDerivedFrom());
1185   DIArray Elements = CTy->getTypeArray();
1186
1187   // Get an anonymous type for index type.
1188   DIE *IdxTy = getIndexTyDie();
1189   if (!IdxTy) {
1190     // Construct an anonymous type for index type.
1191     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1192     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1193     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1194             dwarf::DW_ATE_signed);
1195     addDie(IdxTy);
1196     setIndexTyDie(IdxTy);
1197   }
1198
1199   // Add subranges to array type.
1200   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1201     DIDescriptor Element = Elements.getElement(i);
1202     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1203       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1204   }
1205 }
1206
1207 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1208 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1209   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1210   StringRef Name = ETy.getName();
1211   addString(Enumerator, dwarf::DW_AT_name, Name);
1212   int64_t Value = ETy.getEnumValue();
1213   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1214   return Enumerator;
1215 }
1216
1217 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1218 /// vtables.
1219 void CompileUnit::constructContainingTypeDIEs() {
1220   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1221          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1222     DIE *SPDie = CI->first;
1223     const MDNode *N = CI->second;
1224     if (!N) continue;
1225     DIE *NDie = getDIE(N);
1226     if (!NDie) continue;
1227     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1228   }
1229 }
1230
1231 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1232 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1233   StringRef Name = DV->getName();
1234   if (Name.empty())
1235     return NULL;
1236
1237   // Translate tag to proper Dwarf tag.
1238   unsigned Tag = DV->getTag();
1239
1240   // Define variable debug information entry.
1241   DIE *VariableDie = new DIE(Tag);
1242   DbgVariable *AbsVar = DV->getAbstractVariable();
1243   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1244   if (AbsDIE)
1245     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1246                             dwarf::DW_FORM_ref4, AbsDIE);
1247   else {
1248     addString(VariableDie, dwarf::DW_AT_name, Name);
1249     addSourceLine(VariableDie, DV->getVariable());
1250     addType(VariableDie, DV->getType());
1251   }
1252
1253   if (DV->isArtificial())
1254     addUInt(VariableDie, dwarf::DW_AT_artificial,
1255                         dwarf::DW_FORM_flag, 1);
1256
1257   if (isScopeAbstract) {
1258     DV->setDIE(VariableDie);
1259     return VariableDie;
1260   }
1261
1262   // Add variable address.
1263
1264   unsigned Offset = DV->getDotDebugLocOffset();
1265   if (Offset != ~0U) {
1266     addLabel(VariableDie, dwarf::DW_AT_location,
1267                          dwarf::DW_FORM_data4,
1268                          Asm->GetTempSymbol("debug_loc", Offset));
1269     DV->setDIE(VariableDie);
1270     return VariableDie;
1271   }
1272
1273   // Check if variable is described by a DBG_VALUE instruction.
1274   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1275     bool updated = false;
1276     if (DVInsn->getNumOperands() == 3) {
1277       if (DVInsn->getOperand(0).isReg()) {
1278         const MachineOperand RegOp = DVInsn->getOperand(0);
1279         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1280         if (DVInsn->getOperand(1).isImm() &&
1281             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1282           unsigned FrameReg = 0;
1283           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1284           int Offset =
1285             TFI->getFrameIndexReference(*Asm->MF,
1286                                         DVInsn->getOperand(1).getImm(),
1287                                         FrameReg);
1288           MachineLocation Location(FrameReg, Offset);
1289           addVariableAddress(DV, VariableDie, Location);
1290
1291         } else if (RegOp.getReg())
1292           addVariableAddress(DV, VariableDie,
1293                                          MachineLocation(RegOp.getReg()));
1294         updated = true;
1295       }
1296       else if (DVInsn->getOperand(0).isImm())
1297         updated =
1298           addConstantValue(VariableDie, DVInsn->getOperand(0),
1299                                        DV->getType());
1300       else if (DVInsn->getOperand(0).isFPImm())
1301         updated =
1302           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1303       else if (DVInsn->getOperand(0).isCImm())
1304         updated =
1305           addConstantValue(VariableDie,
1306                                        DVInsn->getOperand(0).getCImm(),
1307                                        DV->getType().isUnsignedDIType());
1308     } else {
1309       addVariableAddress(DV, VariableDie,
1310                                      Asm->getDebugValueLocation(DVInsn));
1311       updated = true;
1312     }
1313     if (!updated) {
1314       // If variableDie is not updated then DBG_VALUE instruction does not
1315       // have valid variable info.
1316       delete VariableDie;
1317       return NULL;
1318     }
1319     DV->setDIE(VariableDie);
1320     return VariableDie;
1321   } else {
1322     // .. else use frame index.
1323     int FI = DV->getFrameIndex();
1324     if (FI != ~0) {
1325       unsigned FrameReg = 0;
1326       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1327       int Offset =
1328         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1329       MachineLocation Location(FrameReg, Offset);
1330       addVariableAddress(DV, VariableDie, Location);
1331     }
1332   }
1333
1334   DV->setDIE(VariableDie);
1335   return VariableDie;
1336 }
1337
1338 /// createMemberDIE - Create new member DIE.
1339 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1340   DIE *MemberDie = new DIE(DT.getTag());
1341   StringRef Name = DT.getName();
1342   if (!Name.empty())
1343     addString(MemberDie, dwarf::DW_AT_name, Name);
1344
1345   addType(MemberDie, DT.getTypeDerivedFrom());
1346
1347   addSourceLine(MemberDie, DT);
1348
1349   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1350   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1351
1352   uint64_t Size = DT.getSizeInBits();
1353   uint64_t FieldSize = DT.getOriginalTypeSize();
1354
1355   if (Size != FieldSize) {
1356     // Handle bitfield.
1357     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1358     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1359
1360     uint64_t Offset = DT.getOffsetInBits();
1361     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1362     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1363     uint64_t FieldOffset = (HiMark - FieldSize);
1364     Offset -= FieldOffset;
1365
1366     // Maybe we need to work from the other end.
1367     if (Asm->getTargetData().isLittleEndian())
1368       Offset = FieldSize - (Offset + Size);
1369     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1370
1371     // Here WD_AT_data_member_location points to the anonymous
1372     // field that includes this bit field.
1373     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1374
1375   } else
1376     // This is not a bitfield.
1377     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1378
1379   if (DT.getTag() == dwarf::DW_TAG_inheritance
1380       && DT.isVirtual()) {
1381
1382     // For C++, virtual base classes are not at fixed offset. Use following
1383     // expression to extract appropriate offset from vtable.
1384     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1385
1386     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1387     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1388     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1389     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1390     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1391     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1392     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1393     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1394
1395     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1396              VBaseLocationDie);
1397   } else
1398     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1399
1400   if (DT.isProtected())
1401     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1402             dwarf::DW_ACCESS_protected);
1403   else if (DT.isPrivate())
1404     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1405             dwarf::DW_ACCESS_private);
1406   // Otherwise C++ member and base classes are considered public.
1407   else
1408     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1409             dwarf::DW_ACCESS_public);
1410   if (DT.isVirtual())
1411     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1412             dwarf::DW_VIRTUALITY_virtual);
1413
1414   // Objective-C properties.
1415   StringRef PropertyName = DT.getObjCPropertyName();
1416   if (!PropertyName.empty()) {
1417     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1418     StringRef GetterName = DT.getObjCPropertyGetterName();
1419     if (!GetterName.empty())
1420       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1421     StringRef SetterName = DT.getObjCPropertySetterName();
1422     if (!SetterName.empty())
1423       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1424     unsigned PropertyAttributes = 0;
1425     if (DT.isReadOnlyObjCProperty())
1426       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1427     if (DT.isReadWriteObjCProperty())
1428       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1429     if (DT.isAssignObjCProperty())
1430       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1431     if (DT.isRetainObjCProperty())
1432       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1433     if (DT.isCopyObjCProperty())
1434       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1435     if (DT.isNonAtomicObjCProperty())
1436       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1437     if (PropertyAttributes)
1438       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1439               PropertyAttributes);
1440   }
1441   return MemberDie;
1442 }