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