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