lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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