lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

   1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing dwarf compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfDebug.h"
  18 #include "llvm/Constants.h"
  19 #include "llvm/Analysis/DIBuilder.h"
  20 #include "llvm/Target/TargetData.h"
  21 #include "llvm/Target/TargetFrameLowering.h"
  22 #include "llvm/Target/TargetMachine.h"
  23 #include "llvm/Target/TargetRegisterInfo.h"
  24 #include "llvm/ADT/APFloat.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26
  27 using namespace llvm;
  28
  29 /// CompileUnit - Compile unit constructor.
  30 CompileUnit::CompileUnit(unsigned I, DIE *D, AsmPrinter *A, DwarfDebug *DW)
  31   : ID(I), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
  32   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  33 }
  34
  35 /// ~CompileUnit - Destructor for compile unit.
  36 CompileUnit::~CompileUnit() {
  37   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  38     DIEBlocks[j]->~DIEBlock();
  39 }
  40
  41 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  42 /// information entry.
  43 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
  44   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  45   return Value;
  46 }
  47
  48 /// addUInt - Add an unsigned integer attribute data and value.
  49 ///
  50 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
  51                           unsigned Form, uint64_t Integer) {
  52   if (!Form) Form = DIEInteger::BestForm(false, Integer);
  53   DIEValue *Value = Integer == 1 ?
  54     DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
  55   Die->addValue(Attribute, Form, Value);
  56 }
  57
  58 /// addSInt - Add an signed integer attribute data and value.
  59 ///
  60 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
  61                           unsigned Form, int64_t Integer) {
  62   if (!Form) Form = DIEInteger::BestForm(true, Integer);
  63   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
  64   Die->addValue(Attribute, Form, Value);
  65 }
  66
  67 /// addString - Add a string attribute data and value. DIEString only
  68 /// keeps string reference.
  69 void CompileUnit::addString(DIE *Die, unsigned Attribute, unsigned Form,
  70                             StringRef String) {
  71   DIEValue *Value = new (DIEValueAllocator) DIEString(String);
  72   Die->addValue(Attribute, Form, Value);
  73 }
  74
  75 /// addLabel - Add a Dwarf label attribute data and value.
  76 ///
  77 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
  78                            const MCSymbol *Label) {
  79   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
  80   Die->addValue(Attribute, Form, Value);
  81 }
  82
  83 /// addDelta - Add a label delta attribute data and value.
  84 ///
  85 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
  86                            const MCSymbol *Hi, const MCSymbol *Lo) {
  87   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
  88   Die->addValue(Attribute, Form, Value);
  89 }
  90
  91 /// addDIEEntry - Add a DIE attribute data and value.
  92 ///
  93 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
  94                               DIE *Entry) {
  95   Die->addValue(Attribute, Form, createDIEEntry(Entry));
  96 }
  97
  98
  99 /// addBlock - Add block data.
 100 ///
 101 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
 102                            DIEBlock *Block) {
 103   Block->ComputeSize(Asm);
 104   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 105   Die->addValue(Attribute, Block->BestForm(), Block);
 106 }
 107
 108 /// addSourceLine - Add location information to specified debug information
 109 /// entry.
 110 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
 111   // Verify variable.
 112   if (!V.Verify())
 113     return;
 114
 115   unsigned Line = V.getLineNumber();
 116   if (Line == 0)
 117     return;
 118   unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
 119                                             V.getContext().getDirectory());
 120   assert(FileID && "Invalid file id");
 121   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 122   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 123 }
 124
 125 /// addSourceLine - Add location information to specified debug information
 126 /// entry.
 127 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
 128   // Verify global variable.
 129   if (!G.Verify())
 130     return;
 131
 132   unsigned Line = G.getLineNumber();
 133   if (Line == 0)
 134     return;
 135   unsigned FileID = DD->GetOrCreateSourceID(G.getContext().getFilename(),
 136                                             G.getContext().getDirectory());
 137   assert(FileID && "Invalid file id");
 138   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 139   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 140 }
 141
 142 /// addSourceLine - Add location information to specified debug information
 143 /// entry.
 144 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
 145   // Verify subprogram.
 146   if (!SP.Verify())
 147     return;
 148   // If the line number is 0, don't add it.
 149   if (SP.getLineNumber() == 0)
 150     return;
 151
 152   unsigned Line = SP.getLineNumber();
 153   if (!SP.getContext().Verify())
 154     return;
 155   unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(), SP.getDirectory());
 156   assert(FileID && "Invalid file id");
 157   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 158   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 159 }
 160
 161 /// addSourceLine - Add location information to specified debug information
 162 /// entry.
 163 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
 164   // Verify type.
 165   if (!Ty.Verify())
 166     return;
 167
 168   unsigned Line = Ty.getLineNumber();
 169   if (Line == 0 || !Ty.getContext().Verify())
 170     return;
 171   unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(), Ty.getDirectory());
 172   assert(FileID && "Invalid file id");
 173   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 174   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 175 }
 176
 177 /// addSourceLine - Add location information to specified debug information
 178 /// entry.
 179 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
 180   // Verify namespace.
 181   if (!NS.Verify())
 182     return;
 183
 184   unsigned Line = NS.getLineNumber();
 185   if (Line == 0)
 186     return;
 187   StringRef FN = NS.getFilename();
 188
 189   unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
 190   assert(FileID && "Invalid file id");
 191   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 192   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 193 }
 194
 195 /// addVariableAddress - Add DW_AT_location attribute for a
 196 /// DbgVariable based on provided MachineLocation.
 197 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
 198                                      MachineLocation Location) {
 199   if (DV->variableHasComplexAddress())
 200     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
 201   else if (DV->isBlockByrefVariable())
 202     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
 203   else
 204     addAddress(Die, dwarf::DW_AT_location, Location);
 205 }
 206
 207 /// addRegisterOp - Add register operand.
 208 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
 209   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 210   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 211   if (DWReg < 32)
 212     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
 213   else {
 214     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 215     addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
 216   }
 217 }
 218
 219 /// addRegisterOffset - Add register offset.
 220 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
 221                                     int64_t Offset) {
 222   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 223   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 224   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
 225   if (Reg == TRI->getFrameRegister(*Asm->MF))
 226     // If variable offset is based in frame register then use fbreg.
 227     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
 228   else if (DWReg < 32)
 229     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
 230   else {
 231     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 232     addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
 233   }
 234   addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
 235 }
 236
 237 /// addAddress - Add an address attribute to a die based on the location
 238 /// provided.
 239 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
 240                              const MachineLocation &Location) {
 241   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 242
 243   if (Location.isReg())
 244     addRegisterOp(Block, Location.getReg());
 245   else
 246     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
 247
 248   // Now attach the location information to the DIE.
 249   addBlock(Die, Attribute, 0, Block);
 250 }
 251
 252 /// addComplexAddress - Start with the address based on the location provided,
 253 /// and generate the DWARF information necessary to find the actual variable
 254 /// given the extra address information encoded in the DIVariable, starting from
 255 /// the starting location.  Add the DWARF information to the die.
 256 ///
 257 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
 258                                     unsigned Attribute,
 259                                     const MachineLocation &Location) {
 260   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 261   unsigned N = DV->getNumAddrElements();
 262   unsigned i = 0;
 263   if (Location.isReg()) {
 264     if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
 265       // If first address element is OpPlus then emit
 266       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
 267       addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
 268       i = 2;
 269     } else
 270       addRegisterOp(Block, Location.getReg());
 271   }
 272   else
 273     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
 274
 275   for (;i < N; ++i) {
 276     uint64_t Element = DV->getAddrElement(i);
 277     if (Element == DIBuilder::OpPlus) {
 278       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 279       addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
 280     } else if (Element == DIBuilder::OpDeref) {
 281       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 282     } else llvm_unreachable("unknown DIBuilder Opcode");
 283   }
 284
 285   // Now attach the location information to the DIE.
 286   addBlock(Die, Attribute, 0, Block);
 287 }
 288
 289 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 290    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 291    gives the variable VarName either the struct, or a pointer to the struct, as
 292    its type.  This is necessary for various behind-the-scenes things the
 293    compiler needs to do with by-reference variables in Blocks.
 294
 295    However, as far as the original *programmer* is concerned, the variable
 296    should still have type 'SomeType', as originally declared.
 297
 298    The function getBlockByrefType dives into the __Block_byref_x_VarName
 299    struct to find the original type of the variable, which is then assigned to
 300    the variable's Debug Information Entry as its real type.  So far, so good.
 301    However now the debugger will expect the variable VarName to have the type
 302    SomeType.  So we need the location attribute for the variable to be an
 303    expression that explains to the debugger how to navigate through the
 304    pointers and struct to find the actual variable of type SomeType.
 305
 306    The following function does just that.  We start by getting
 307    the "normal" location for the variable. This will be the location
 308    of either the struct __Block_byref_x_VarName or the pointer to the
 309    struct __Block_byref_x_VarName.
 310
 311    The struct will look something like:
 312
 313    struct __Block_byref_x_VarName {
 314      ... <various fields>
 315      struct __Block_byref_x_VarName *forwarding;
 316      ... <various other fields>
 317      SomeType VarName;
 318      ... <maybe more fields>
 319    };
 320
 321    If we are given the struct directly (as our starting point) we
 322    need to tell the debugger to:
 323
 324    1).  Add the offset of the forwarding field.
 325
 326    2).  Follow that pointer to get the real __Block_byref_x_VarName
 327    struct to use (the real one may have been copied onto the heap).
 328
 329    3).  Add the offset for the field VarName, to find the actual variable.
 330
 331    If we started with a pointer to the struct, then we need to
 332    dereference that pointer first, before the other steps.
 333    Translating this into DWARF ops, we will need to append the following
 334    to the current location description for the variable:
 335
 336    DW_OP_deref                    -- optional, if we start with a pointer
 337    DW_OP_plus_uconst <forward_fld_offset>
 338    DW_OP_deref
 339    DW_OP_plus_uconst <varName_fld_offset>
 340
 341    That is what this function does.  */
 342
 343 /// addBlockByrefAddress - Start with the address based on the location
 344 /// provided, and generate the DWARF information necessary to find the
 345 /// actual Block variable (navigating the Block struct) based on the
 346 /// starting location.  Add the DWARF information to the die.  For
 347 /// more information, read large comment just above here.
 348 ///
 349 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
 350                                        unsigned Attribute,
 351                                        const MachineLocation &Location) {
 352   DIType Ty = DV->getType();
 353   DIType TmpTy = Ty;
 354   unsigned Tag = Ty.getTag();
 355   bool isPointer = false;
 356
 357   StringRef varName = DV->getName();
 358
 359   if (Tag == dwarf::DW_TAG_pointer_type) {
 360     DIDerivedType DTy = DIDerivedType(Ty);
 361     TmpTy = DTy.getTypeDerivedFrom();
 362     isPointer = true;
 363   }
 364
 365   DICompositeType blockStruct = DICompositeType(TmpTy);
 366
 367   // Find the __forwarding field and the variable field in the __Block_byref
 368   // struct.
 369   DIArray Fields = blockStruct.getTypeArray();
 370   DIDescriptor varField = DIDescriptor();
 371   DIDescriptor forwardingField = DIDescriptor();
 372
 373   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 374     DIDescriptor Element = Fields.getElement(i);
 375     DIDerivedType DT = DIDerivedType(Element);
 376     StringRef fieldName = DT.getName();
 377     if (fieldName == "__forwarding")
 378       forwardingField = Element;
 379     else if (fieldName == varName)
 380       varField = Element;
 381   }
 382
 383   // Get the offsets for the forwarding field and the variable field.
 384   unsigned forwardingFieldOffset =
 385     DIDerivedType(forwardingField).getOffsetInBits() >> 3;
 386   unsigned varFieldOffset =
 387     DIDerivedType(varField).getOffsetInBits() >> 3;
 388
 389   // Decode the original location, and use that as the start of the byref
 390   // variable's location.
 391   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 392   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 393   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 394
 395   if (Location.isReg()) {
 396     if (Reg < 32)
 397       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 398     else {
 399       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 400       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 401     }
 402   } else {
 403     if (Reg < 32)
 404       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 405     else {
 406       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 407       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 408     }
 409
 410     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 411   }
 412
 413   // If we started with a pointer to the __Block_byref... struct, then
 414   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 415   if (isPointer)
 416     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 417
 418   // Next add the offset for the '__forwarding' field:
 419   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 420   // adding the offset if it's 0.
 421   if (forwardingFieldOffset > 0) {
 422     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 423     addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
 424   }
 425
 426   // Now dereference the __forwarding field to get to the real __Block_byref
 427   // struct:  DW_OP_deref.
 428   addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 429
 430   // Now that we've got the real __Block_byref... struct, add the offset
 431   // for the variable's field to get to the location of the actual variable:
 432   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 433   if (varFieldOffset > 0) {
 434     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 435     addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
 436   }
 437
 438   // Now attach the location information to the DIE.
 439   addBlock(Die, Attribute, 0, Block);
 440 }
 441
 442 /// addConstantValue - Add constant value entry in variable DIE.
 443 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
 444                                    DIType Ty) {
 445   assert (MO.isImm() && "Invalid machine operand!");
 446   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 447   unsigned form = dwarf::DW_FORM_udata;
 448   switch (Ty.getSizeInBits()) {
 449     case 8: form = dwarf::DW_FORM_data1; break;
 450     case 16: form = dwarf::DW_FORM_data2; break;
 451     case 32: form = dwarf::DW_FORM_data4; break;
 452     case 64: form = dwarf::DW_FORM_data8; break;
 453     default: break;
 454   }
 455
 456   DIBasicType BTy(Ty);
 457   if (BTy.Verify() &&
 458       (BTy.getEncoding()  == dwarf::DW_ATE_signed
 459        || BTy.getEncoding() == dwarf::DW_ATE_signed_char))
 460     addSInt(Block, 0, form, MO.getImm());
 461   else
 462     addUInt(Block, 0, form, MO.getImm());
 463
 464   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 465   return true;
 466 }
 467
 468 /// addConstantFPValue - Add constant value entry in variable DIE.
 469 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
 470   assert (MO.isFPImm() && "Invalid machine operand!");
 471   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 472   APFloat FPImm = MO.getFPImm()->getValueAPF();
 473
 474   // Get the raw data form of the floating point.
 475   const APInt FltVal = FPImm.bitcastToAPInt();
 476   const char *FltPtr = (const char*)FltVal.getRawData();
 477
 478   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 479   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 480   int Incr = (LittleEndian ? 1 : -1);
 481   int Start = (LittleEndian ? 0 : NumBytes - 1);
 482   int Stop = (LittleEndian ? NumBytes : -1);
 483
 484   // Output the constant to DWARF one byte at a time.
 485   for (; Start != Stop; Start += Incr)
 486     addUInt(Block, 0, dwarf::DW_FORM_data1,
 487             (unsigned char)0xFF & FltPtr[Start]);
 488
 489   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 490   return true;
 491 }
 492
 493 /// addConstantValue - Add constant value entry in variable DIE.
 494 bool CompileUnit::addConstantValue(DIE *Die, ConstantInt *CI,
 495                                    bool Unsigned) {
 496   unsigned CIBitWidth = CI->getBitWidth();
 497   if (CIBitWidth <= 64) {
 498     unsigned form = 0;
 499     switch (CIBitWidth) {
 500     case 8: form = dwarf::DW_FORM_data1; break;
 501     case 16: form = dwarf::DW_FORM_data2; break;
 502     case 32: form = dwarf::DW_FORM_data4; break;
 503     case 64: form = dwarf::DW_FORM_data8; break;
 504     default:
 505       form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
 506     }
 507     if (Unsigned)
 508       addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
 509     else
 510       addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
 511     return true;
 512   }
 513
 514   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 515
 516   // Get the raw data form of the large APInt.
 517   const APInt Val = CI->getValue();
 518   const char *Ptr = (const char*)Val.getRawData();
 519
 520   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 521   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 522   int Incr = (LittleEndian ? 1 : -1);
 523   int Start = (LittleEndian ? 0 : NumBytes - 1);
 524   int Stop = (LittleEndian ? NumBytes : -1);
 525
 526   // Output the constant to DWARF one byte at a time.
 527   for (; Start != Stop; Start += Incr)
 528     addUInt(Block, 0, dwarf::DW_FORM_data1,
 529             (unsigned char)0xFF & Ptr[Start]);
 530
 531   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 532   return true;
 533 }
 534
 535 /// addTemplateParams - Add template parameters in buffer.
 536 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 537   // Add template parameters.
 538   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 539     DIDescriptor Element = TParams.getElement(i);
 540     if (Element.isTemplateTypeParameter())
 541       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 542                         DITemplateTypeParameter(Element)));
 543     else if (Element.isTemplateValueParameter())
 544       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 545                         DITemplateValueParameter(Element)));
 546   }
 547
 548 }
 549 /// addToContextOwner - Add Die into the list of its context owner's children.
 550 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 551   if (Context.isType()) {
 552     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
 553     ContextDIE->addChild(Die);
 554   } else if (Context.isNameSpace()) {
 555     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
 556     ContextDIE->addChild(Die);
 557   } else if (Context.isSubprogram()) {
 558     DIE *ContextDIE = DD->createSubprogramDIE(DISubprogram(Context));
 559     ContextDIE->addChild(Die);
 560   } else if (DIE *ContextDIE = getDIE(Context))
 561     ContextDIE->addChild(Die);
 562   else
 563     addDie(Die);
 564 }
 565
 566 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 567 /// given DIType.
 568 DIE *CompileUnit::getOrCreateTypeDIE(DIType Ty) {
 569   DIE *TyDIE = getDIE(Ty);
 570   if (TyDIE)
 571     return TyDIE;
 572
 573   // Create new type.
 574   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 575   insertDIE(Ty, TyDIE);
 576   if (Ty.isBasicType())
 577     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 578   else if (Ty.isCompositeType())
 579     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 580   else {
 581     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 582     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 583   }
 584
 585   addToContextOwner(TyDIE, Ty.getContext());
 586   return TyDIE;
 587 }
 588
 589 /// addType - Add a new type attribute to the specified entity.
 590 void CompileUnit::addType(DIE *Entity, DIType Ty) {
 591   if (!Ty.Verify())
 592     return;
 593
 594   // Check for pre-existence.
 595   DIEEntry *Entry = getDIEEntry(Ty);
 596   // If it exists then use the existing value.
 597   if (Entry) {
 598     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 599     return;
 600   }
 601
 602   // Construct type.
 603   DIE *Buffer = getOrCreateTypeDIE(Ty);
 604
 605   // Set up proxy.
 606   Entry = createDIEEntry(Buffer);
 607   insertDIEEntry(Ty, Entry);
 608   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 609
 610   // If this is a complete composite type then include it in the
 611   // list of global types.
 612   DIDescriptor Context = Ty.getContext();
 613   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
 614       && (Context.isCompileUnit() || Context.isFile() || Context.isNameSpace()))
 615     addGlobalType(Ty.getName(), Entry->getEntry());
 616 }
 617
 618 /// addPubTypes - Add type for pubtypes section.
 619 void CompileUnit::addPubTypes(DISubprogram SP) {
 620   DICompositeType SPTy = SP.getType();
 621   unsigned SPTag = SPTy.getTag();
 622   if (SPTag != dwarf::DW_TAG_subroutine_type)
 623     return;
 624
 625   DIArray Args = SPTy.getTypeArray();
 626   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 627     DIType ATy(Args.getElement(i));
 628     if (!ATy.Verify())
 629       continue;
 630     DICompositeType CATy = getDICompositeType(ATy);
 631     if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
 632         && !CATy.isForwardDecl()) {
 633       if (DIEEntry *Entry = getDIEEntry(CATy))
 634         addGlobalType(CATy.getName(), Entry->getEntry());
 635     }
 636   }
 637 }
 638
 639 /// constructTypeDIE - Construct basic type die from DIBasicType.
 640 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 641   // Get core information.
 642   StringRef Name = BTy.getName();
 643   Buffer.setTag(dwarf::DW_TAG_base_type);
 644   addUInt(&Buffer, dwarf::DW_AT_encoding,  dwarf::DW_FORM_data1,
 645           BTy.getEncoding());
 646
 647   // Add name if not anonymous or intermediate type.
 648   if (!Name.empty())
 649     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 650   uint64_t Size = BTy.getSizeInBits() >> 3;
 651   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 652 }
 653
 654 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 655 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 656   // Get core information.
 657   StringRef Name = DTy.getName();
 658   uint64_t Size = DTy.getSizeInBits() >> 3;
 659   unsigned Tag = DTy.getTag();
 660
 661   // FIXME - Workaround for templates.
 662   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 663
 664   Buffer.setTag(Tag);
 665
 666   // Map to main type, void will not have a type.
 667   DIType FromTy = DTy.getTypeDerivedFrom();
 668   addType(&Buffer, FromTy);
 669
 670   // Add name if not anonymous or intermediate type.
 671   if (!Name.empty())
 672     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 673
 674   // Add size if non-zero (derived types might be zero-sized.)
 675   if (Size)
 676     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 677
 678   // Add source line info if available and TyDesc is not a forward declaration.
 679   if (!DTy.isForwardDecl())
 680     addSourceLine(&Buffer, DTy);
 681 }
 682
 683 /// constructTypeDIE - Construct type DIE from DICompositeType.
 684 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 685   // Get core information.
 686   StringRef Name = CTy.getName();
 687
 688   uint64_t Size = CTy.getSizeInBits() >> 3;
 689   unsigned Tag = CTy.getTag();
 690   Buffer.setTag(Tag);
 691
 692   switch (Tag) {
 693   case dwarf::DW_TAG_vector_type:
 694   case dwarf::DW_TAG_array_type:
 695     constructArrayTypeDIE(Buffer, &CTy);
 696     break;
 697   case dwarf::DW_TAG_enumeration_type: {
 698     DIArray Elements = CTy.getTypeArray();
 699
 700     // Add enumerators to enumeration type.
 701     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 702       DIE *ElemDie = NULL;
 703       DIDescriptor Enum(Elements.getElement(i));
 704       if (Enum.isEnumerator()) {
 705         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 706         Buffer.addChild(ElemDie);
 707       }
 708     }
 709   }
 710     break;
 711   case dwarf::DW_TAG_subroutine_type: {
 712     // Add return type.
 713     DIArray Elements = CTy.getTypeArray();
 714     DIDescriptor RTy = Elements.getElement(0);
 715     addType(&Buffer, DIType(RTy));
 716
 717     bool isPrototyped = true;
 718     // Add arguments.
 719     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 720       DIDescriptor Ty = Elements.getElement(i);
 721       if (Ty.isUnspecifiedParameter()) {
 722         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 723         Buffer.addChild(Arg);
 724         isPrototyped = false;
 725       } else {
 726         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 727         addType(Arg, DIType(Ty));
 728         Buffer.addChild(Arg);
 729       }
 730     }
 731     // Add prototype flag.
 732     if (isPrototyped)
 733       addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 734   }
 735     break;
 736   case dwarf::DW_TAG_structure_type:
 737   case dwarf::DW_TAG_union_type:
 738   case dwarf::DW_TAG_class_type: {
 739     // Add elements to structure type.
 740     DIArray Elements = CTy.getTypeArray();
 741
 742     // A forward struct declared type may not have elements available.
 743     unsigned N = Elements.getNumElements();
 744     if (N == 0)
 745       break;
 746
 747     // Add elements to structure type.
 748     for (unsigned i = 0; i < N; ++i) {
 749       DIDescriptor Element = Elements.getElement(i);
 750       DIE *ElemDie = NULL;
 751       if (Element.isSubprogram()) {
 752         DISubprogram SP(Element);
 753         ElemDie = DD->createSubprogramDIE(DISubprogram(Element));
 754         if (SP.isProtected())
 755           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 756                   dwarf::DW_ACCESS_protected);
 757         else if (SP.isPrivate())
 758           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 759                   dwarf::DW_ACCESS_private);
 760         else
 761           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 762             dwarf::DW_ACCESS_public);
 763         if (SP.isExplicit())
 764           addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
 765       }
 766       else if (Element.isVariable()) {
 767         DIVariable DV(Element);
 768         ElemDie = new DIE(dwarf::DW_TAG_variable);
 769         addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 770                   DV.getName());
 771         addType(ElemDie, DV.getType());
 772         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 773         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 774         addSourceLine(ElemDie, DV);
 775       } else if (Element.isDerivedType())
 776         ElemDie = createMemberDIE(DIDerivedType(Element));
 777       else
 778         continue;
 779       Buffer.addChild(ElemDie);
 780     }
 781
 782     if (CTy.isAppleBlockExtension())
 783       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 784
 785     unsigned RLang = CTy.getRunTimeLang();
 786     if (RLang)
 787       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 788               dwarf::DW_FORM_data1, RLang);
 789
 790     DICompositeType ContainingType = CTy.getContainingType();
 791     if (DIDescriptor(ContainingType).isCompositeType())
 792       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 793                   getOrCreateTypeDIE(DIType(ContainingType)));
 794     else {
 795       DIDescriptor Context = CTy.getContext();
 796       addToContextOwner(&Buffer, Context);
 797     }
 798
 799     if (CTy.isObjcClassComplete())
 800       addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
 801               dwarf::DW_FORM_flag, 1);
 802
 803     if (Tag == dwarf::DW_TAG_class_type)
 804       addTemplateParams(Buffer, CTy.getTemplateParams());
 805
 806     break;
 807   }
 808   default:
 809     break;
 810   }
 811
 812   // Add name if not anonymous or intermediate type.
 813   if (!Name.empty())
 814     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 815
 816   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 817       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 818     {
 819     // Add size if non-zero (derived types might be zero-sized.)
 820     if (Size)
 821       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 822     else {
 823       // Add zero size if it is not a forward declaration.
 824       if (CTy.isForwardDecl())
 825         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 826       else
 827         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 828     }
 829
 830     // Add source line info if available.
 831     if (!CTy.isForwardDecl())
 832       addSourceLine(&Buffer, CTy);
 833   }
 834 }
 835
 836 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 837 /// for the given DITemplateTypeParameter.
 838 DIE *
 839 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 840   DIE *ParamDIE = getDIE(TP);
 841   if (ParamDIE)
 842     return ParamDIE;
 843
 844   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 845   addType(ParamDIE, TP.getType());
 846   addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
 847   return ParamDIE;
 848 }
 849
 850 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 851 /// for the given DITemplateValueParameter.
 852 DIE *
 853 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 854   DIE *ParamDIE = getDIE(TPV);
 855   if (ParamDIE)
 856     return ParamDIE;
 857
 858   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 859   addType(ParamDIE, TPV.getType());
 860   if (!TPV.getName().empty())
 861     addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
 862   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 863           TPV.getValue());
 864   return ParamDIE;
 865 }
 866
 867 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 868 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 869   DIE *NDie = getDIE(NS);
 870   if (NDie)
 871     return NDie;
 872   NDie = new DIE(dwarf::DW_TAG_namespace);
 873   insertDIE(NS, NDie);
 874   if (!NS.getName().empty())
 875     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
 876   addSourceLine(NDie, NS);
 877   addToContextOwner(NDie, NS.getContext());
 878   return NDie;
 879 }
 880
 881 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
 882 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
 883   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
 884   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
 885   int64_t L = SR.getLo();
 886   int64_t H = SR.getHi();
 887
 888   // The L value defines the lower bounds which is typically zero for C/C++. The
 889   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
 890   // of the array. If L > H then do not emit DW_AT_lower_bound and
 891   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
 892   // array has one element and in such case do not emit lower bound.
 893
 894   if (L > H) {
 895     Buffer.addChild(DW_Subrange);
 896     return;
 897   }
 898   if (L)
 899     addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
 900   addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
 901   Buffer.addChild(DW_Subrange);
 902 }
 903
 904 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
 905 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
 906                                         DICompositeType *CTy) {
 907   Buffer.setTag(dwarf::DW_TAG_array_type);
 908   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
 909     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
 910
 911   // Emit derived type.
 912   addType(&Buffer, CTy->getTypeDerivedFrom());
 913   DIArray Elements = CTy->getTypeArray();
 914
 915   // Get an anonymous type for index type.
 916   DIE *IdxTy = getIndexTyDie();
 917   if (!IdxTy) {
 918     // Construct an anonymous type for index type.
 919     IdxTy = new DIE(dwarf::DW_TAG_base_type);
 920     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
 921     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 922             dwarf::DW_ATE_signed);
 923     addDie(IdxTy);
 924     setIndexTyDie(IdxTy);
 925   }
 926
 927   // Add subranges to array type.
 928   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 929     DIDescriptor Element = Elements.getElement(i);
 930     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
 931       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
 932   }
 933 }
 934
 935 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
 936 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
 937   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
 938   StringRef Name = ETy.getName();
 939   addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 940   int64_t Value = ETy.getEnumValue();
 941   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
 942   return Enumerator;
 943 }
 944
 945 /// createMemberDIE - Create new member DIE.
 946 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
 947   DIE *MemberDie = new DIE(DT.getTag());
 948   StringRef Name = DT.getName();
 949   if (!Name.empty())
 950     addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 951
 952   addType(MemberDie, DT.getTypeDerivedFrom());
 953
 954   addSourceLine(MemberDie, DT);
 955
 956   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
 957   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 958
 959   uint64_t Size = DT.getSizeInBits();
 960   uint64_t FieldSize = DT.getOriginalTypeSize();
 961
 962   if (Size != FieldSize) {
 963     // Handle bitfield.
 964     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
 965     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
 966
 967     uint64_t Offset = DT.getOffsetInBits();
 968     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
 969     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
 970     uint64_t FieldOffset = (HiMark - FieldSize);
 971     Offset -= FieldOffset;
 972
 973     // Maybe we need to work from the other end.
 974     if (Asm->getTargetData().isLittleEndian())
 975       Offset = FieldSize - (Offset + Size);
 976     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
 977
 978     // Here WD_AT_data_member_location points to the anonymous
 979     // field that includes this bit field.
 980     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
 981
 982   } else
 983     // This is not a bitfield.
 984     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
 985
 986   if (DT.getTag() == dwarf::DW_TAG_inheritance
 987       && DT.isVirtual()) {
 988
 989     // For C++, virtual base classes are not at fixed offset. Use following
 990     // expression to extract appropriate offset from vtable.
 991     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
 992
 993     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
 994     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
 995     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 996     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 997     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
 998     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
 999     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1000     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1001
1002     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1003              VBaseLocationDie);
1004   } else
1005     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1006
1007   if (DT.isProtected())
1008     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1009             dwarf::DW_ACCESS_protected);
1010   else if (DT.isPrivate())
1011     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1012             dwarf::DW_ACCESS_private);
1013   // Otherwise C++ member and base classes are considered public.
1014   else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1015     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1016             dwarf::DW_ACCESS_public);
1017   if (DT.isVirtual())
1018     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1019             dwarf::DW_VIRTUALITY_virtual);
1020
1021   // Objective-C properties.
1022   StringRef PropertyName = DT.getObjCPropertyName();
1023   if (!PropertyName.empty()) {
1024     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string,
1025               PropertyName);
1026     StringRef GetterName = DT.getObjCPropertyGetterName();
1027     if (!GetterName.empty())
1028       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter,
1029                 dwarf::DW_FORM_string, GetterName);
1030     StringRef SetterName = DT.getObjCPropertySetterName();
1031     if (!SetterName.empty())
1032       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter,
1033                 dwarf::DW_FORM_string, SetterName);
1034     unsigned PropertyAttributes = 0;
1035     if (DT.isReadOnlyObjCProperty())
1036       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1037     if (DT.isReadWriteObjCProperty())
1038       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1039     if (DT.isAssignObjCProperty())
1040       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1041     if (DT.isRetainObjCProperty())
1042       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1043     if (DT.isCopyObjCProperty())
1044       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1045     if (DT.isNonAtomicObjCProperty())
1046       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1047     if (PropertyAttributes)
1048       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1049               PropertyAttributes);
1050   }
1051   return MemberDie;
1052 }