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