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 Imm = MO.getImm();
 448   unsigned form = dwarf::DW_FORM_udata;
 449   switch (Ty.getSizeInBits()) {
 450     case 8: form = dwarf::DW_FORM_data1; break;
 451     case 16: form = dwarf::DW_FORM_data2; break;
 452     case 32: form = dwarf::DW_FORM_data4; break;
 453     case 64: form = dwarf::DW_FORM_data8; break;
 454     default: break;
 455   }
 456   addUInt(Block, 0, form, Imm);
 457   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 458   return true;
 459 }
 460
 461 /// addConstantFPValue - Add constant value entry in variable DIE.
 462 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
 463   assert (MO.isFPImm() && "Invalid machine operand!");
 464   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 465   APFloat FPImm = MO.getFPImm()->getValueAPF();
 466
 467   // Get the raw data form of the floating point.
 468   const APInt FltVal = FPImm.bitcastToAPInt();
 469   const char *FltPtr = (const char*)FltVal.getRawData();
 470
 471   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 472   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 473   int Incr = (LittleEndian ? 1 : -1);
 474   int Start = (LittleEndian ? 0 : NumBytes - 1);
 475   int Stop = (LittleEndian ? NumBytes : -1);
 476
 477   // Output the constant to DWARF one byte at a time.
 478   for (; Start != Stop; Start += Incr)
 479     addUInt(Block, 0, dwarf::DW_FORM_data1,
 480             (unsigned char)0xFF & FltPtr[Start]);
 481
 482   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 483   return true;
 484 }
 485
 486 /// addConstantValue - Add constant value entry in variable DIE.
 487 bool CompileUnit::addConstantValue(DIE *Die, ConstantInt *CI,
 488                                    bool Unsigned) {
 489   if (CI->getBitWidth() <= 64) {
 490     if (Unsigned)
 491       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 492               CI->getZExtValue());
 493     else
 494       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
 495               CI->getSExtValue());
 496     return true;
 497   }
 498
 499   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 500
 501   // Get the raw data form of the large APInt.
 502   const APInt Val = CI->getValue();
 503   const char *Ptr = (const char*)Val.getRawData();
 504
 505   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 506   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 507   int Incr = (LittleEndian ? 1 : -1);
 508   int Start = (LittleEndian ? 0 : NumBytes - 1);
 509   int Stop = (LittleEndian ? NumBytes : -1);
 510
 511   // Output the constant to DWARF one byte at a time.
 512   for (; Start != Stop; Start += Incr)
 513     addUInt(Block, 0, dwarf::DW_FORM_data1,
 514             (unsigned char)0xFF & Ptr[Start]);
 515
 516   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 517   return true;
 518 }
 519
 520 /// addTemplateParams - Add template parameters in buffer.
 521 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 522   // Add template parameters.
 523   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 524     DIDescriptor Element = TParams.getElement(i);
 525     if (Element.isTemplateTypeParameter())
 526       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 527                         DITemplateTypeParameter(Element)));
 528     else if (Element.isTemplateValueParameter())
 529       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 530                         DITemplateValueParameter(Element)));
 531   }
 532
 533 }
 534 /// addToContextOwner - Add Die into the list of its context owner's children.
 535 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 536   if (Context.isType()) {
 537     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
 538     ContextDIE->addChild(Die);
 539   } else if (Context.isNameSpace()) {
 540     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
 541     ContextDIE->addChild(Die);
 542   } else if (Context.isSubprogram()) {
 543     DIE *ContextDIE = DD->createSubprogramDIE(DISubprogram(Context));
 544     ContextDIE->addChild(Die);
 545   } else if (DIE *ContextDIE = getDIE(Context))
 546     ContextDIE->addChild(Die);
 547   else
 548     addDie(Die);
 549 }
 550
 551 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 552 /// given DIType.
 553 DIE *CompileUnit::getOrCreateTypeDIE(DIType Ty) {
 554   DIE *TyDIE = getDIE(Ty);
 555   if (TyDIE)
 556     return TyDIE;
 557
 558   // Create new type.
 559   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 560   insertDIE(Ty, TyDIE);
 561   if (Ty.isBasicType())
 562     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 563   else if (Ty.isCompositeType())
 564     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 565   else {
 566     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 567     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 568   }
 569
 570   addToContextOwner(TyDIE, Ty.getContext());
 571   return TyDIE;
 572 }
 573
 574 /// addType - Add a new type attribute to the specified entity.
 575 void CompileUnit::addType(DIE *Entity, DIType Ty) {
 576   if (!Ty.Verify())
 577     return;
 578
 579   // Check for pre-existence.
 580   DIEEntry *Entry = getDIEEntry(Ty);
 581   // If it exists then use the existing value.
 582   if (Entry) {
 583     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 584     return;
 585   }
 586
 587   // Construct type.
 588   DIE *Buffer = getOrCreateTypeDIE(Ty);
 589
 590   // Set up proxy.
 591   Entry = createDIEEntry(Buffer);
 592   insertDIEEntry(Ty, Entry);
 593
 594   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
 595 }
 596
 597 /// addPubTypes - Add type for pubtypes section.
 598 void CompileUnit::addPubTypes(DISubprogram SP) {
 599   DICompositeType SPTy = SP.getType();
 600   unsigned SPTag = SPTy.getTag();
 601   if (SPTag != dwarf::DW_TAG_subroutine_type)
 602     return;
 603
 604   DIArray Args = SPTy.getTypeArray();
 605   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 606     DIType ATy(Args.getElement(i));
 607     if (!ATy.Verify())
 608       continue;
 609     DICompositeType CATy = getDICompositeType(ATy);
 610     if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
 611         && !CATy.isForwardDecl()) {
 612       if (DIEEntry *Entry = getDIEEntry(CATy))
 613         addGlobalType(CATy.getName(), Entry->getEntry());
 614     }
 615   }
 616 }
 617
 618 /// constructTypeDIE - Construct basic type die from DIBasicType.
 619 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 620   // Get core information.
 621   StringRef Name = BTy.getName();
 622   Buffer.setTag(dwarf::DW_TAG_base_type);
 623   addUInt(&Buffer, dwarf::DW_AT_encoding,  dwarf::DW_FORM_data1,
 624           BTy.getEncoding());
 625
 626   // Add name if not anonymous or intermediate type.
 627   if (!Name.empty())
 628     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 629   uint64_t Size = BTy.getSizeInBits() >> 3;
 630   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 631 }
 632
 633 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 634 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 635   // Get core information.
 636   StringRef Name = DTy.getName();
 637   uint64_t Size = DTy.getSizeInBits() >> 3;
 638   unsigned Tag = DTy.getTag();
 639
 640   // FIXME - Workaround for templates.
 641   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 642
 643   Buffer.setTag(Tag);
 644
 645   // Map to main type, void will not have a type.
 646   DIType FromTy = DTy.getTypeDerivedFrom();
 647   addType(&Buffer, FromTy);
 648
 649   // Add name if not anonymous or intermediate type.
 650   if (!Name.empty())
 651     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 652
 653   // Add size if non-zero (derived types might be zero-sized.)
 654   if (Size)
 655     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 656
 657   // Add source line info if available and TyDesc is not a forward declaration.
 658   if (!DTy.isForwardDecl())
 659     addSourceLine(&Buffer, DTy);
 660 }
 661
 662 /// constructTypeDIE - Construct type DIE from DICompositeType.
 663 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 664   // Get core information.
 665   StringRef Name = CTy.getName();
 666
 667   uint64_t Size = CTy.getSizeInBits() >> 3;
 668   unsigned Tag = CTy.getTag();
 669   Buffer.setTag(Tag);
 670
 671   switch (Tag) {
 672   case dwarf::DW_TAG_vector_type:
 673   case dwarf::DW_TAG_array_type:
 674     constructArrayTypeDIE(Buffer, &CTy);
 675     break;
 676   case dwarf::DW_TAG_enumeration_type: {
 677     DIArray Elements = CTy.getTypeArray();
 678
 679     // Add enumerators to enumeration type.
 680     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 681       DIE *ElemDie = NULL;
 682       DIDescriptor Enum(Elements.getElement(i));
 683       if (Enum.isEnumerator()) {
 684         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 685         Buffer.addChild(ElemDie);
 686       }
 687     }
 688   }
 689     break;
 690   case dwarf::DW_TAG_subroutine_type: {
 691     // Add return type.
 692     DIArray Elements = CTy.getTypeArray();
 693     DIDescriptor RTy = Elements.getElement(0);
 694     addType(&Buffer, DIType(RTy));
 695
 696     bool isPrototyped = true;
 697     // Add arguments.
 698     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 699       DIDescriptor Ty = Elements.getElement(i);
 700       if (Ty.isUnspecifiedParameter()) {
 701         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 702         Buffer.addChild(Arg);
 703         isPrototyped = false;
 704       } else {
 705         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 706         addType(Arg, DIType(Ty));
 707         Buffer.addChild(Arg);
 708       }
 709     }
 710     // Add prototype flag.
 711     if (isPrototyped)
 712       addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 713   }
 714     break;
 715   case dwarf::DW_TAG_structure_type:
 716   case dwarf::DW_TAG_union_type:
 717   case dwarf::DW_TAG_class_type: {
 718     // Add elements to structure type.
 719     DIArray Elements = CTy.getTypeArray();
 720
 721     // A forward struct declared type may not have elements available.
 722     unsigned N = Elements.getNumElements();
 723     if (N == 0)
 724       break;
 725
 726     // Add elements to structure type.
 727     for (unsigned i = 0; i < N; ++i) {
 728       DIDescriptor Element = Elements.getElement(i);
 729       DIE *ElemDie = NULL;
 730       if (Element.isSubprogram()) {
 731         DISubprogram SP(Element);
 732         ElemDie = DD->createSubprogramDIE(DISubprogram(Element));
 733         if (SP.isProtected())
 734           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 735                   dwarf::DW_ACCESS_protected);
 736         else if (SP.isPrivate())
 737           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 738                   dwarf::DW_ACCESS_private);
 739         else
 740           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 741             dwarf::DW_ACCESS_public);
 742         if (SP.isExplicit())
 743           addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
 744       }
 745       else if (Element.isVariable()) {
 746         DIVariable DV(Element);
 747         ElemDie = new DIE(dwarf::DW_TAG_variable);
 748         addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
 749                   DV.getName());
 750         addType(ElemDie, DV.getType());
 751         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 752         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 753         addSourceLine(ElemDie, DV);
 754       } else if (Element.isDerivedType())
 755         ElemDie = createMemberDIE(DIDerivedType(Element));
 756       else
 757         continue;
 758       Buffer.addChild(ElemDie);
 759     }
 760
 761     if (CTy.isAppleBlockExtension())
 762       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 763
 764     unsigned RLang = CTy.getRunTimeLang();
 765     if (RLang)
 766       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 767               dwarf::DW_FORM_data1, RLang);
 768
 769     DICompositeType ContainingType = CTy.getContainingType();
 770     if (DIDescriptor(ContainingType).isCompositeType())
 771       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 772                   getOrCreateTypeDIE(DIType(ContainingType)));
 773     else {
 774       DIDescriptor Context = CTy.getContext();
 775       addToContextOwner(&Buffer, Context);
 776     }
 777
 778     if (CTy.isObjcClassComplete())
 779       addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
 780               dwarf::DW_FORM_flag, 1);
 781
 782     if (Tag == dwarf::DW_TAG_class_type)
 783       addTemplateParams(Buffer, CTy.getTemplateParams());
 784
 785     break;
 786   }
 787   default:
 788     break;
 789   }
 790
 791   // Add name if not anonymous or intermediate type.
 792   if (!Name.empty())
 793     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 794
 795   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 796       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 797     {
 798     // Add size if non-zero (derived types might be zero-sized.)
 799     if (Size)
 800       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 801     else {
 802       // Add zero size if it is not a forward declaration.
 803       if (CTy.isForwardDecl())
 804         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 805       else
 806         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 807     }
 808
 809     // Add source line info if available.
 810     if (!CTy.isForwardDecl())
 811       addSourceLine(&Buffer, CTy);
 812   }
 813 }
 814
 815 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 816 /// for the given DITemplateTypeParameter.
 817 DIE *
 818 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 819   DIE *ParamDIE = getDIE(TP);
 820   if (ParamDIE)
 821     return ParamDIE;
 822
 823   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 824   addType(ParamDIE, TP.getType());
 825   addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
 826   return ParamDIE;
 827 }
 828
 829 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 830 /// for the given DITemplateValueParameter.
 831 DIE *
 832 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 833   DIE *ParamDIE = getDIE(TPV);
 834   if (ParamDIE)
 835     return ParamDIE;
 836
 837   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 838   addType(ParamDIE, TPV.getType());
 839   if (!TPV.getName().empty())
 840     addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
 841   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 842           TPV.getValue());
 843   return ParamDIE;
 844 }
 845
 846 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 847 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 848   DIE *NDie = getDIE(NS);
 849   if (NDie)
 850     return NDie;
 851   NDie = new DIE(dwarf::DW_TAG_namespace);
 852   insertDIE(NS, NDie);
 853   if (!NS.getName().empty())
 854     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
 855   addSourceLine(NDie, NS);
 856   addToContextOwner(NDie, NS.getContext());
 857   return NDie;
 858 }
 859
 860 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
 861 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
 862   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
 863   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
 864   int64_t L = SR.getLo();
 865   int64_t H = SR.getHi();
 866
 867   // The L value defines the lower bounds which is typically zero for C/C++. The
 868   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
 869   // of the array. If L > H then do not emit DW_AT_lower_bound and
 870   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
 871   // array has one element and in such case do not emit lower bound.
 872
 873   if (L > H) {
 874     Buffer.addChild(DW_Subrange);
 875     return;
 876   }
 877   if (L)
 878     addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
 879   addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
 880   Buffer.addChild(DW_Subrange);
 881 }
 882
 883 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
 884 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
 885                                         DICompositeType *CTy) {
 886   Buffer.setTag(dwarf::DW_TAG_array_type);
 887   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
 888     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
 889
 890   // Emit derived type.
 891   addType(&Buffer, CTy->getTypeDerivedFrom());
 892   DIArray Elements = CTy->getTypeArray();
 893
 894   // Get an anonymous type for index type.
 895   DIE *IdxTy = getIndexTyDie();
 896   if (!IdxTy) {
 897     // Construct an anonymous type for index type.
 898     IdxTy = new DIE(dwarf::DW_TAG_base_type);
 899     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
 900     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 901             dwarf::DW_ATE_signed);
 902     addDie(IdxTy);
 903     setIndexTyDie(IdxTy);
 904   }
 905
 906   // Add subranges to array type.
 907   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 908     DIDescriptor Element = Elements.getElement(i);
 909     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
 910       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
 911   }
 912 }
 913
 914 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
 915 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
 916   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
 917   StringRef Name = ETy.getName();
 918   addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 919   int64_t Value = ETy.getEnumValue();
 920   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
 921   return Enumerator;
 922 }
 923
 924 /// createMemberDIE - Create new member DIE.
 925 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
 926   DIE *MemberDie = new DIE(DT.getTag());
 927   StringRef Name = DT.getName();
 928   if (!Name.empty())
 929     addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
 930
 931   addType(MemberDie, DT.getTypeDerivedFrom());
 932
 933   addSourceLine(MemberDie, DT);
 934
 935   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
 936   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 937
 938   uint64_t Size = DT.getSizeInBits();
 939   uint64_t FieldSize = DT.getOriginalTypeSize();
 940
 941   if (Size != FieldSize) {
 942     // Handle bitfield.
 943     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
 944     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
 945
 946     uint64_t Offset = DT.getOffsetInBits();
 947     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
 948     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
 949     uint64_t FieldOffset = (HiMark - FieldSize);
 950     Offset -= FieldOffset;
 951
 952     // Maybe we need to work from the other end.
 953     if (Asm->getTargetData().isLittleEndian())
 954       Offset = FieldSize - (Offset + Size);
 955     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
 956
 957     // Here WD_AT_data_member_location points to the anonymous
 958     // field that includes this bit field.
 959     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
 960
 961   } else
 962     // This is not a bitfield.
 963     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
 964
 965   if (DT.getTag() == dwarf::DW_TAG_inheritance
 966       && DT.isVirtual()) {
 967
 968     // For C++, virtual base classes are not at fixed offset. Use following
 969     // expression to extract appropriate offset from vtable.
 970     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
 971
 972     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
 973     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
 974     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 975     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
 976     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
 977     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
 978     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 979     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
 980
 981     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
 982              VBaseLocationDie);
 983   } else
 984     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
 985
 986   if (DT.isProtected())
 987     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 988             dwarf::DW_ACCESS_protected);
 989   else if (DT.isPrivate())
 990     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 991             dwarf::DW_ACCESS_private);
 992   // Otherwise C++ member and base classes are considered public.
 993   else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
 994     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
 995             dwarf::DW_ACCESS_public);
 996   if (DT.isVirtual())
 997     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
 998             dwarf::DW_VIRTUALITY_virtual);
 999
1000   // Objective-C properties.
1001   StringRef PropertyName = DT.getObjCPropertyName();
1002   if (!PropertyName.empty()) {
1003     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string,
1004               PropertyName);
1005     StringRef GetterName = DT.getObjCPropertyGetterName();
1006     if (!GetterName.empty())
1007       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter,
1008                 dwarf::DW_FORM_string, GetterName);
1009     StringRef SetterName = DT.getObjCPropertySetterName();
1010     if (!SetterName.empty())
1011       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter,
1012                 dwarf::DW_FORM_string, SetterName);
1013     unsigned PropertyAttributes = 0;
1014     if (DT.isReadOnlyObjCProperty())
1015       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1016     if (DT.isReadWriteObjCProperty())
1017       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1018     if (DT.isAssignObjCProperty())
1019       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1020     if (DT.isRetainObjCProperty())
1021       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1022     if (DT.isCopyObjCProperty())
1023       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1024     if (DT.isNonAtomicObjCProperty())
1025       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1026     if (PropertyAttributes)
1027       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1028               PropertyAttributes);
1029   }
1030   return MemberDie;
1031 }