DwarfCompileUnit.cpp revision 8d45a98eb14338428155be70681a42dccc03a5ce 
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      // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1353      // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1354      // TAG_variable.
1355      addString(IsStaticMember && VariableSpecDIE ?
1356                VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1357                getRealLinkageName(LinkageName));
1358      // In compatibility mode with older gdbs we put the linkage name on both
1359      // the TAG_variable DIE and on the TAG_member DIE.
1360      if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat())
1361        addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1362                  getRealLinkageName(LinkageName));
1363    }
1364  } else if (const ConstantInt *CI =
1365             dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1366    // AT_const_value was added when the static memeber was created. To avoid
1367    // emitting AT_const_value multiple times, we only add AT_const_value when
1368    // it is not a static member.
1369    if (!IsStaticMember)
1370      addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1371  } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1372    addToAccelTable = true;
1373    // GV is a merged global.
1374    DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1375    Value *Ptr = CE->getOperand(0);
1376    addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1377    addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1378    SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1379    addUInt(Block, 0, dwarf::DW_FORM_udata,
1380                   Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1381    addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1382    addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1383  }
1384
1385  if (addToAccelTable) {
1386    DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1387    addAccelName(GV.getName(), AddrDIE);
1388
1389    // If the linkage name is different than the name, go ahead and output
1390    // that as well into the name table.
1391    if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1392      addAccelName(GV.getLinkageName(), AddrDIE);
1393  }
1394
1395  return;
1396}
1397
1398/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1399void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1400                                       DIE *IndexTy) {
1401  DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1402  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1403
1404  // The LowerBound value defines the lower bounds which is typically zero for
1405  // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1406  // Count == -1 then the array is unbounded and we do not emit
1407  // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1408  // Count == 0, then the array has zero elements in which case we do not emit
1409  // an upper bound.
1410  int64_t LowerBound = SR.getLo();
1411  int64_t DefaultLowerBound = getDefaultLowerBound();
1412  int64_t Count = SR.getCount();
1413
1414  if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1415    addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1416
1417  if (Count != -1 && Count != 0)
1418    // FIXME: An unbounded array should reference the expression that defines
1419    // the array.
1420    addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1421
1422  Buffer.addChild(DW_Subrange);
1423}
1424
1425/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1426void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1427                                        DICompositeType *CTy) {
1428  Buffer.setTag(dwarf::DW_TAG_array_type);
1429  if (CTy->isVector())
1430    addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1431
1432  // Emit derived type.
1433  addType(&Buffer, CTy->getTypeDerivedFrom());
1434  DIArray Elements = CTy->getTypeArray();
1435
1436  // Get an anonymous type for index type.
1437  // FIXME: This type should be passed down from the front end
1438  // as different languages may have different sizes for indexes.
1439  DIE *IdxTy = getIndexTyDie();
1440  if (!IdxTy) {
1441    // Construct an anonymous type for index type.
1442    IdxTy = new DIE(dwarf::DW_TAG_base_type);
1443    addString(IdxTy, dwarf::DW_AT_name, "int");
1444    addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1445    addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1446            dwarf::DW_ATE_signed);
1447    addDie(IdxTy);
1448    setIndexTyDie(IdxTy);
1449  }
1450
1451  // Add subranges to array type.
1452  for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1453    DIDescriptor Element = Elements.getElement(i);
1454    if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1455      constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1456  }
1457}
1458
1459/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1460DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1461  DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1462  StringRef Name = ETy.getName();
1463  addString(Enumerator, dwarf::DW_AT_name, Name);
1464  int64_t Value = ETy.getEnumValue();
1465  addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1466  return Enumerator;
1467}
1468
1469/// constructContainingTypeDIEs - Construct DIEs for types that contain
1470/// vtables.
1471void CompileUnit::constructContainingTypeDIEs() {
1472  for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1473         CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1474    DIE *SPDie = CI->first;
1475    const MDNode *N = CI->second;
1476    if (!N) continue;
1477    DIE *NDie = getDIE(N);
1478    if (!NDie) continue;
1479    addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1480  }
1481}
1482
1483/// constructVariableDIE - Construct a DIE for the given DbgVariable.
1484DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1485  StringRef Name = DV->getName();
1486
1487  // Translate tag to proper Dwarf tag.
1488  unsigned Tag = DV->getTag();
1489
1490  // Define variable debug information entry.
1491  DIE *VariableDie = new DIE(Tag);
1492  DbgVariable *AbsVar = DV->getAbstractVariable();
1493  DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1494  if (AbsDIE)
1495    addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1496                            dwarf::DW_FORM_ref4, AbsDIE);
1497  else {
1498    addString(VariableDie, dwarf::DW_AT_name, Name);
1499    addSourceLine(VariableDie, DV->getVariable());
1500    addType(VariableDie, DV->getType());
1501  }
1502
1503  if (DV->isArtificial())
1504    addFlag(VariableDie, dwarf::DW_AT_artificial);
1505
1506  if (isScopeAbstract) {
1507    DV->setDIE(VariableDie);
1508    return VariableDie;
1509  }
1510
1511  // Add variable address.
1512
1513  unsigned Offset = DV->getDotDebugLocOffset();
1514  if (Offset != ~0U) {
1515    addLabel(VariableDie, dwarf::DW_AT_location,
1516                         dwarf::DW_FORM_data4,
1517                         Asm->GetTempSymbol("debug_loc", Offset));
1518    DV->setDIE(VariableDie);
1519    return VariableDie;
1520  }
1521
1522  // Check if variable is described by a DBG_VALUE instruction.
1523  if (const MachineInstr *DVInsn = DV->getMInsn()) {
1524    bool updated = false;
1525    if (DVInsn->getNumOperands() == 3) {
1526      if (DVInsn->getOperand(0).isReg()) {
1527        const MachineOperand RegOp = DVInsn->getOperand(0);
1528        const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1529        if (DVInsn->getOperand(1).isImm() &&
1530            TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1531          unsigned FrameReg = 0;
1532          const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1533          int Offset =
1534            TFI->getFrameIndexReference(*Asm->MF,
1535                                        DVInsn->getOperand(1).getImm(),
1536                                        FrameReg);
1537          MachineLocation Location(FrameReg, Offset);
1538          addVariableAddress(DV, VariableDie, Location);
1539
1540        } else if (RegOp.getReg())
1541          addVariableAddress(DV, VariableDie,
1542                                         MachineLocation(RegOp.getReg()));
1543        updated = true;
1544      }
1545      else if (DVInsn->getOperand(0).isImm())
1546        updated =
1547          addConstantValue(VariableDie, DVInsn->getOperand(0),
1548                                       DV->getType());
1549      else if (DVInsn->getOperand(0).isFPImm())
1550        updated =
1551          addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1552      else if (DVInsn->getOperand(0).isCImm())
1553        updated =
1554          addConstantValue(VariableDie,
1555                                       DVInsn->getOperand(0).getCImm(),
1556                                       DV->getType().isUnsignedDIType());
1557    } else {
1558      addVariableAddress(DV, VariableDie,
1559                                     Asm->getDebugValueLocation(DVInsn));
1560      updated = true;
1561    }
1562    if (!updated) {
1563      // If variableDie is not updated then DBG_VALUE instruction does not
1564      // have valid variable info.
1565      delete VariableDie;
1566      return NULL;
1567    }
1568    DV->setDIE(VariableDie);
1569    return VariableDie;
1570  } else {
1571    // .. else use frame index.
1572    int FI = DV->getFrameIndex();
1573    if (FI != ~0) {
1574      unsigned FrameReg = 0;
1575      const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1576      int Offset =
1577        TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1578      MachineLocation Location(FrameReg, Offset);
1579      addVariableAddress(DV, VariableDie, Location);
1580    }
1581  }
1582
1583  DV->setDIE(VariableDie);
1584  return VariableDie;
1585}
1586
1587/// createMemberDIE - Create new member DIE.
1588DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1589  DIE *MemberDie = new DIE(DT.getTag());
1590  StringRef Name = DT.getName();
1591  if (!Name.empty())
1592    addString(MemberDie, dwarf::DW_AT_name, Name);
1593
1594  addType(MemberDie, DT.getTypeDerivedFrom());
1595
1596  addSourceLine(MemberDie, DT);
1597
1598  DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1599  addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1600
1601  uint64_t Size = DT.getSizeInBits();
1602  uint64_t FieldSize = DT.getOriginalTypeSize();
1603
1604  if (Size != FieldSize) {
1605    // Handle bitfield.
1606    addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1607    addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1608
1609    uint64_t Offset = DT.getOffsetInBits();
1610    uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1611    uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1612    uint64_t FieldOffset = (HiMark - FieldSize);
1613    Offset -= FieldOffset;
1614
1615    // Maybe we need to work from the other end.
1616    if (Asm->getDataLayout().isLittleEndian())
1617      Offset = FieldSize - (Offset + Size);
1618    addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1619
1620    // Here WD_AT_data_member_location points to the anonymous
1621    // field that includes this bit field.
1622    addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1623
1624  } else
1625    // This is not a bitfield.
1626    addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1627
1628  if (DT.getTag() == dwarf::DW_TAG_inheritance
1629      && DT.isVirtual()) {
1630
1631    // For C++, virtual base classes are not at fixed offset. Use following
1632    // expression to extract appropriate offset from vtable.
1633    // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1634
1635    DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1636    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1637    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1638    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1639    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1640    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1641    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1642    addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1643
1644    addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1645             VBaseLocationDie);
1646  } else
1647    addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1648
1649  if (DT.isProtected())
1650    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1651            dwarf::DW_ACCESS_protected);
1652  else if (DT.isPrivate())
1653    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1654            dwarf::DW_ACCESS_private);
1655  // Otherwise C++ member and base classes are considered public.
1656  else
1657    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1658            dwarf::DW_ACCESS_public);
1659  if (DT.isVirtual())
1660    addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1661            dwarf::DW_VIRTUALITY_virtual);
1662
1663  // Objective-C properties.
1664  if (MDNode *PNode = DT.getObjCProperty())
1665    if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1666      MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1667                          PropertyDie);
1668
1669  if (DT.isArtificial())
1670    addFlag(MemberDie, dwarf::DW_AT_artificial);
1671
1672  // This is only for backward compatibility.
1673  StringRef PropertyName = DT.getObjCPropertyName();
1674  if (!PropertyName.empty()) {
1675    addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1676    StringRef GetterName = DT.getObjCPropertyGetterName();
1677    if (!GetterName.empty())
1678      addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1679    StringRef SetterName = DT.getObjCPropertySetterName();
1680    if (!SetterName.empty())
1681      addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1682    unsigned PropertyAttributes = 0;
1683    if (DT.isReadOnlyObjCProperty())
1684      PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1685    if (DT.isReadWriteObjCProperty())
1686      PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1687    if (DT.isAssignObjCProperty())
1688      PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1689    if (DT.isRetainObjCProperty())
1690      PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1691    if (DT.isCopyObjCProperty())
1692      PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1693    if (DT.isNonAtomicObjCProperty())
1694      PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1695    if (PropertyAttributes)
1696      addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1697              PropertyAttributes);
1698  }
1699  return MemberDie;
1700}
1701
1702/// createStaticMemberDIE - Create new DIE for C++ static member.
1703DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1704  if (!DT.Verify())
1705    return NULL;
1706
1707  DIE *StaticMemberDIE = new DIE(DT.getTag());
1708  DIType Ty = DT.getTypeDerivedFrom();
1709
1710  addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1711  addType(StaticMemberDIE, Ty);
1712  addSourceLine(StaticMemberDIE, DT);
1713  addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1714  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1715
1716  // FIXME: We could omit private if the parent is a class_type, and
1717  // public if the parent is something else.
1718  if (DT.isProtected())
1719    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1720            dwarf::DW_ACCESS_protected);
1721  else if (DT.isPrivate())
1722    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1723            dwarf::DW_ACCESS_private);
1724  else
1725    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1726            dwarf::DW_ACCESS_public);
1727
1728  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1729    addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1730  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1731    addConstantFPValue(StaticMemberDIE, CFP);
1732
1733  insertDIE(DT, StaticMemberDIE);
1734  return StaticMemberDIE;
1735}
1736