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, 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 ||
 929       Tag == dwarf::DW_TAG_class_type ||
 930       Tag == dwarf::DW_TAG_structure_type ||
 931       Tag == dwarf::DW_TAG_union_type) {
 932     // Add size if non-zero (derived types might be zero-sized.)
 933     if (Size)
 934       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 935     else {
 936       // Add zero size if it is not a forward declaration.
 937       if (CTy.isForwardDecl())
 938         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 939       else
 940         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 941     }
 942
 943     // Add source line info if available.
 944     if (!CTy.isForwardDecl())
 945       addSourceLine(&Buffer, CTy);
 946
 947     // No harm in adding the runtime language to the declaration.
 948     unsigned RLang = CTy.getRunTimeLang();
 949     if (RLang)
 950       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 951               dwarf::DW_FORM_data1, RLang);
 952   }
 953 }
 954
 955 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 956 /// for the given DITemplateTypeParameter.
 957 DIE *
 958 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 959   DIE *ParamDIE = getDIE(TP);
 960   if (ParamDIE)
 961     return ParamDIE;
 962
 963   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 964   addType(ParamDIE, TP.getType());
 965   addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
 966   return ParamDIE;
 967 }
 968
 969 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 970 /// for the given DITemplateValueParameter.
 971 DIE *
 972 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){
 973   DIE *ParamDIE = getDIE(TPV);
 974   if (ParamDIE)
 975     return ParamDIE;
 976
 977   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 978   addType(ParamDIE, TPV.getType());
 979   if (!TPV.getName().empty())
 980     addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
 981   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 982           TPV.getValue());
 983   return ParamDIE;
 984 }
 985
 986 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 987 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 988   DIE *NDie = getDIE(NS);
 989   if (NDie)
 990     return NDie;
 991   NDie = new DIE(dwarf::DW_TAG_namespace);
 992   insertDIE(NS, NDie);
 993   if (!NS.getName().empty()) {
 994     addString(NDie, dwarf::DW_AT_name, NS.getName());
 995     addAccelNamespace(NS.getName(), NDie);
 996   } else
 997     addAccelNamespace("(anonymous namespace)", NDie);
 998   addSourceLine(NDie, NS);
 999   addToContextOwner(NDie, NS.getContext());
1000   return NDie;
1001 }
1002
1003 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1004 /// printer to not emit usual symbol prefix before the symbol name is used then
1005 /// return linkage name after skipping this special LLVM prefix.
1006 static StringRef getRealLinkageName(StringRef LinkageName) {
1007   char One = '\1';
1008   if (LinkageName.startswith(StringRef(&One, 1)))
1009     return LinkageName.substr(1);
1010   return LinkageName;
1011 }
1012
1013 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1014 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1015   DIE *SPDie = getDIE(SP);
1016   if (SPDie)
1017     return SPDie;
1018
1019   DISubprogram SPDecl = SP.getFunctionDeclaration();
1020   DIE *DeclDie = NULL;
1021   if (SPDecl.isSubprogram()) {
1022     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1023   }
1024
1025   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1026
1027   // DW_TAG_inlined_subroutine may refer to this DIE.
1028   insertDIE(SP, SPDie);
1029
1030   // Add to context owner.
1031   addToContextOwner(SPDie, SP.getContext());
1032
1033   // Add function template parameters.
1034   addTemplateParams(*SPDie, SP.getTemplateParams());
1035
1036   // Unfortunately this code needs to stay here instead of below the
1037   // AT_specification code in order to work around a bug in older
1038   // gdbs that requires the linkage name to resolve multiple template
1039   // functions.
1040   StringRef LinkageName = SP.getLinkageName();
1041   if (!LinkageName.empty())
1042     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1043               getRealLinkageName(LinkageName));
1044
1045   // If this DIE is going to refer declaration info using AT_specification
1046   // then there is no need to add other attributes.
1047   if (DeclDie) {
1048     // Refer function declaration directly.
1049     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1050                 DeclDie);
1051
1052     return SPDie;
1053   }
1054
1055   // Constructors and operators for anonymous aggregates do not have names.
1056   if (!SP.getName().empty())
1057     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1058
1059   addSourceLine(SPDie, SP);
1060
1061   // Add the prototype if we have a prototype and we have a C like
1062   // language.
1063   if (SP.isPrototyped() &&
1064       (Language == dwarf::DW_LANG_C89 ||
1065        Language == dwarf::DW_LANG_C99 ||
1066        Language == dwarf::DW_LANG_ObjC))
1067     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1068
1069   // Add Return Type.
1070   DICompositeType SPTy = SP.getType();
1071   DIArray Args = SPTy.getTypeArray();
1072   unsigned SPTag = SPTy.getTag();
1073
1074   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1075     addType(SPDie, SPTy);
1076   else
1077     addType(SPDie, DIType(Args.getElement(0)));
1078
1079   unsigned VK = SP.getVirtuality();
1080   if (VK) {
1081     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1082     DIEBlock *Block = getDIEBlock();
1083     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1084     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1085     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1086     ContainingTypeMap.insert(std::make_pair(SPDie,
1087                                             SP.getContainingType()));
1088   }
1089
1090   if (!SP.isDefinition()) {
1091     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1092
1093     // Add arguments. Do not add arguments for subprogram definition. They will
1094     // be handled while processing variables.
1095     DICompositeType SPTy = SP.getType();
1096     DIArray Args = SPTy.getTypeArray();
1097     unsigned SPTag = SPTy.getTag();
1098
1099     if (SPTag == dwarf::DW_TAG_subroutine_type)
1100       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1101         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1102         DIType ATy = DIType(DIType(Args.getElement(i)));
1103         addType(Arg, ATy);
1104         if (ATy.isArtificial())
1105           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1106         SPDie->addChild(Arg);
1107       }
1108   }
1109
1110   if (SP.isArtificial())
1111     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1112
1113   if (!SP.isLocalToUnit())
1114     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1115
1116   if (SP.isOptimized())
1117     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1118
1119   if (unsigned isa = Asm->getISAEncoding()) {
1120     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1121   }
1122
1123   return SPDie;
1124 }
1125
1126 // Return const expression if value is a GEP to access merged global
1127 // constant. e.g.
1128 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1129 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1130   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1131   if (!CE || CE->getNumOperands() != 3 ||
1132       CE->getOpcode() != Instruction::GetElementPtr)
1133     return NULL;
1134
1135   // First operand points to a global struct.
1136   Value *Ptr = CE->getOperand(0);
1137   if (!isa<GlobalValue>(Ptr) ||
1138       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1139     return NULL;
1140
1141   // Second operand is zero.
1142   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1143   if (!CI || !CI->isZero())
1144     return NULL;
1145
1146   // Third operand is offset.
1147   if (!isa<ConstantInt>(CE->getOperand(2)))
1148     return NULL;
1149
1150   return CE;
1151 }
1152
1153 /// createGlobalVariableDIE - create global variable DIE.
1154 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1155   // Check for pre-existence.
1156   if (getDIE(N))
1157     return;
1158
1159   DIGlobalVariable GV(N);
1160   if (!GV.Verify())
1161     return;
1162
1163   DIE *VariableDIE = new DIE(GV.getTag());
1164   // Add to map.
1165   insertDIE(N, VariableDIE);
1166
1167   // Add name.
1168   addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1169   StringRef LinkageName = GV.getLinkageName();
1170   bool isGlobalVariable = GV.getGlobal() != NULL;
1171   if (!LinkageName.empty() && isGlobalVariable)
1172     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1173               getRealLinkageName(LinkageName));
1174   // Add type.
1175   DIType GTy = GV.getType();
1176   addType(VariableDIE, GTy);
1177
1178   // Add scoping info.
1179   if (!GV.isLocalToUnit())
1180     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181
1182   // Add line number info.
1183   addSourceLine(VariableDIE, GV);
1184   // Add to context owner.
1185   DIDescriptor GVContext = GV.getContext();
1186   addToContextOwner(VariableDIE, GVContext);
1187   // Add location.
1188   bool addToAccelTable = false;
1189   DIE *VariableSpecDIE = NULL;
1190   if (isGlobalVariable) {
1191     addToAccelTable = true;
1192     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1193     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1194     addLabel(Block, 0, dwarf::DW_FORM_udata,
1195              Asm->Mang->getSymbol(GV.getGlobal()));
1196     // Do not create specification DIE if context is either compile unit
1197     // or a subprogram.
1198     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1199         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1200       // Create specification DIE.
1201       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1202       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1203                   dwarf::DW_FORM_ref4, VariableDIE);
1204       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1205       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1206                      1);
1207       addDie(VariableSpecDIE);
1208     } else {
1209       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1210     }
1211   } else if (const ConstantInt *CI =
1212              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1213     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1214   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1215     addToAccelTable = true;
1216     // GV is a merged global.
1217     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1218     Value *Ptr = CE->getOperand(0);
1219     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1220     addLabel(Block, 0, dwarf::DW_FORM_udata,
1221                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1222     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1223     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1224     addUInt(Block, 0, dwarf::DW_FORM_udata,
1225                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1226     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1227     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1228   }
1229
1230   if (addToAccelTable) {
1231     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1232     addAccelName(GV.getName(), AddrDIE);
1233
1234     // If the linkage name is different than the name, go ahead and output
1235     // that as well into the name table.
1236     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1237       addAccelName(GV.getLinkageName(), AddrDIE);
1238   }
1239
1240   return;
1241 }
1242
1243 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1244 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1245                                        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 }