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