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