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