contrib/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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