blob: 9d17767f3bc6998a44f43b7cc48eda946a1a5f84 [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
Eric Christopherc36145f2012-01-06 04:35:23 +000016#include "DwarfAccelTable.h"
Devang Patel161b2f42011-04-12 23:21:44 +000017#include "DwarfCompileUnit.h"
18#include "DwarfDebug.h"
19#include "llvm/Constants.h"
Bill Wendling16eeb6f2012-06-29 08:32:07 +000020#include "llvm/DIBuilder.h"
Devang Patel6f9d8ff2011-08-15 17:57:41 +000021#include "llvm/GlobalVariable.h"
22#include "llvm/Instructions.h"
Eric Christopherd61c34b2011-11-11 03:16:32 +000023#include "llvm/Support/Debug.h"
Devang Patel6f9d8ff2011-08-15 17:57:41 +000024#include "llvm/Target/Mangler.h"
Devang Patel161b2f42011-04-12 23:21:44 +000025#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
32using namespace llvm;
33
34/// CompileUnit - Compile unit constructor.
Eric Christopher438b0922012-02-22 08:46:13 +000035CompileUnit::CompileUnit(unsigned I, unsigned L, DIE *D, AsmPrinter *A,
Eric Christopher4d069bf2012-05-22 18:45:24 +000036 DwarfDebug *DW)
Eric Christopher438b0922012-02-22 08:46:13 +000037 : ID(I), Language(L), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
Devang Patel161b2f42011-04-12 23:21:44 +000038 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
39}
40
41/// ~CompileUnit - Destructor for compile unit.
42CompileUnit::~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.
49DIEEntry *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///
56void 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///
66void 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
Nick Lewycky6a7efcf2011-10-28 05:29:47 +000073/// 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.
Nick Lewycky390c40d2011-10-27 06:44:11 +000076void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
Nick Lewycky6a7efcf2011-10-28 05:29:47 +000077 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);
Nick Lewycky390c40d2011-10-27 06:44:11 +000084 }
Nick Lewycky6a7efcf2011-10-28 05:29:47 +000085 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
Devang Patel161b2f42011-04-12 23:21:44 +000086}
87
88/// addLabel - Add a Dwarf label attribute data and value.
89///
90void 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///
98void 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///
106void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
107 DIE *Entry) {
108 Die->addValue(Attribute, Form, createDIEEntry(Entry));
109}
110
Devang Patel161b2f42011-04-12 23:21:44 +0000111/// addBlock - Add block data.
112///
113void 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.
122void 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.
139void 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;
Nick Lewycky746cb672011-10-26 22:55:33 +0000147 unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(), G.getDirectory());
Devang Patel161b2f42011-04-12 23:21:44 +0000148 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.
155void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
156 // Verify subprogram.
157 if (!SP.Verify())
158 return;
Eric Christopher2125d5a2012-03-15 23:55:40 +0000159
Devang Patel161b2f42011-04-12 23:21:44 +0000160 // If the line number is 0, don't add it.
Eric Christopher2125d5a2012-03-15 23:55:40 +0000161 unsigned Line = SP.getLineNumber();
162 if (Line == 0)
Devang Patel161b2f42011-04-12 23:21:44 +0000163 return;
164
Nick Lewycky746cb672011-10-26 22:55:33 +0000165 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
166 SP.getDirectory());
Devang Patel161b2f42011-04-12 23:21:44 +0000167 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.
174void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
175 // Verify type.
176 if (!Ty.Verify())
177 return;
178
179 unsigned Line = Ty.getLineNumber();
Eric Christopher2125d5a2012-03-15 23:55:40 +0000180 if (Line == 0)
Devang Patel161b2f42011-04-12 23:21:44 +0000181 return;
Nick Lewycky746cb672011-10-26 22:55:33 +0000182 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
183 Ty.getDirectory());
Devang Patel161b2f42011-04-12 23:21:44 +0000184 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.
Eric Christopherb8ca9882012-03-29 08:42:56 +0000191void 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(),
Eric Christopher4d069bf2012-05-22 18:45:24 +0000201 File.getDirectory());
Eric Christopherb8ca9882012-03-29 08:42:56 +0000202 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.
Devang Patel161b2f42011-04-12 23:21:44 +0000209void 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
Devang Patele1cdf842011-04-27 22:45:24 +0000225/// addVariableAddress - Add DW_AT_location attribute for a
226/// DbgVariable based on provided MachineLocation.
227void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
228 MachineLocation Location) {
Devang Patel161b2f42011-04-12 23:21:44 +0000229 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
Devang Patel116da2f2011-04-26 19:06:18 +0000237/// addRegisterOp - Add register operand.
238void 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.
250void 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.
269void 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
Devang Patel161b2f42011-04-12 23:21:44 +0000282/// 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///
287void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
288 unsigned Attribute,
289 const MachineLocation &Location) {
Devang Patel161b2f42011-04-12 23:21:44 +0000290 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patelc26f5442011-04-28 02:22:40 +0000291 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 }
Devang Patel116da2f2011-04-26 19:06:18 +0000302 else
303 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
Devang Patel161b2f42011-04-12 23:21:44 +0000304
Devang Patelc26f5442011-04-28 02:22:40 +0000305 for (;i < N; ++i) {
Devang Patel161b2f42011-04-12 23:21:44 +0000306 uint64_t Element = DV->getAddrElement(i);
Devang Patel161b2f42011-04-12 23:21:44 +0000307 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) {
Eric Christopher50120762012-05-08 18:56:00 +0000311 if (!Location.isReg())
312 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Devang Patel161b2f42011-04-12 23:21:44 +0000313 } 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///
380void 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
Devang Patel4ec14b02011-07-20 21:57:04 +0000473/// isTypeSigned - Return true if the type is signed.
474static 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
Devang Patel161b2f42011-04-12 23:21:44 +0000486/// addConstantValue - Add constant value entry in variable DIE.
Devang Patelb58128e2011-05-27 16:45:18 +0000487bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
488 DIType Ty) {
Nick Lewycky746cb672011-10-26 22:55:33 +0000489 assert(MO.isImm() && "Invalid machine operand!");
Devang Patel161b2f42011-04-12 23:21:44 +0000490 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel4ec14b02011-07-20 21:57:04 +0000491 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;
Devang Patel045c1d42011-05-27 19:13:26 +0000499 default: break;
500 }
Devang Patel4ec14b02011-07-20 21:57:04 +0000501 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
502 : addUInt(Block, 0, Form, MO.getImm());
Devang Patel72f0d9c2011-05-27 18:15:52 +0000503
Devang Patel161b2f42011-04-12 23:21:44 +0000504 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
505 return true;
506}
507
508/// addConstantFPValue - Add constant value entry in variable DIE.
509bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
Nick Lewycky390c40d2011-10-27 06:44:11 +0000510 assert (MO.isFPImm() && "Invalid machine operand!");
Devang Patel161b2f42011-04-12 23:21:44 +0000511 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.
Devang Patel8594d422011-06-24 20:46:11 +0000534bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
Devang Patel161b2f42011-04-12 23:21:44 +0000535 bool Unsigned) {
Devang Pateld6a81362011-05-28 00:39:18 +0000536 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 }
Devang Patel161b2f42011-04-12 23:21:44 +0000547 if (Unsigned)
Devang Pateld6a81362011-05-28 00:39:18 +0000548 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
Devang Patel161b2f42011-04-12 23:21:44 +0000549 else
Devang Pateld6a81362011-05-28 00:39:18 +0000550 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
Devang Patel161b2f42011-04-12 23:21:44 +0000551 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();
NAKAMURA Takumic3e48c32011-10-28 14:12:22 +0000558 const uint64_t *Ptr64 = Val.getRawData();
Devang Patel161b2f42011-04-12 23:21:44 +0000559
560 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
561 bool LittleEndian = Asm->getTargetData().isLittleEndian();
Devang Patel161b2f42011-04-12 23:21:44 +0000562
563 // Output the constant to DWARF one byte at a time.
NAKAMURA Takumic3e48c32011-10-28 14:12:22 +0000564 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 }
Devang Patel161b2f42011-04-12 23:21:44 +0000572
573 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
574 return true;
575}
576
577/// addTemplateParams - Add template parameters in buffer.
578void 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 }
Devang Patel161b2f42011-04-12 23:21:44 +0000589}
Nick Lewycky746cb672011-10-26 22:55:33 +0000590
Devang Patel161b2f42011-04-12 23:21:44 +0000591/// addToContextOwner - Add Die into the list of its context owner's children.
592void 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()) {
Devang Pateldbc64af2011-08-15 17:24:54 +0000600 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
Devang Patel161b2f42011-04-12 23:21:44 +0000601 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.
Devang Patel94c7ddb2011-08-16 22:09:43 +0000610DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
611 DIType Ty(TyNode);
612 if (!Ty.Verify())
613 return NULL;
Devang Patel161b2f42011-04-12 23:21:44 +0000614 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 }
Eric Christopher1b3f9192011-11-10 19:52:58 +0000629 // If this is a named finished type then include it in the list of types
630 // for the accelerator tables.
Eric Christopherc36145f2012-01-06 04:35:23 +0000631 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
632 bool IsImplementation = 0;
633 if (Ty.isCompositeType()) {
634 DICompositeType CT(Ty);
Eric Christophere0167892012-01-06 23:03:37 +0000635 // A runtime language of 0 actually means C/C++ and that any
636 // non-negative value is some version of Objective-C/C++.
Eric Christopherc36145f2012-01-06 04:35:23 +0000637 IsImplementation = (CT.getRunTimeLang() == 0) ||
Eric Christophere2dc9332012-02-22 08:46:02 +0000638 CT.isObjcClassComplete();
Eric Christopherc36145f2012-01-06 04:35:23 +0000639 }
Eric Christophere0167892012-01-06 23:03:37 +0000640 unsigned Flags = IsImplementation ?
641 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
642 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
Eric Christopherc36145f2012-01-06 04:35:23 +0000643 }
Eric Christopher1b3f9192011-11-10 19:52:58 +0000644
Devang Patel161b2f42011-04-12 23:21:44 +0000645 addToContextOwner(TyDIE, Ty.getContext());
646 return TyDIE;
647}
648
649/// addType - Add a new type attribute to the specified entity.
Eric Christopher4d069bf2012-05-22 18:45:24 +0000650void CompileUnit::addType(DIE *Entity, DIType Ty, unsigned Attribute) {
Devang Patel161b2f42011-04-12 23:21:44 +0000651 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) {
Eric Christopher663e0cf2012-03-28 07:34:31 +0000658 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
Devang Patel161b2f42011-04-12 23:21:44 +0000659 return;
660 }
661
662 // Construct type.
663 DIE *Buffer = getOrCreateTypeDIE(Ty);
664
665 // Set up proxy.
666 Entry = createDIEEntry(Buffer);
667 insertDIEEntry(Ty, Entry);
Eric Christopher663e0cf2012-03-28 07:34:31 +0000668 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
Devang Patele9ae06c2011-05-31 22:56:51 +0000669
670 // If this is a complete composite type then include it in the
671 // list of global types.
Devang Patelc20bdf12011-06-01 00:23:24 +0000672 addGlobalType(Ty);
Devang Patel66658e42011-05-31 23:30:30 +0000673}
674
675/// addGlobalType - Add a new global type to the compile unit.
676///
Devang Patelc20bdf12011-06-01 00:23:24 +0000677void CompileUnit::addGlobalType(DIType Ty) {
Devang Patele9ae06c2011-05-31 22:56:51 +0000678 DIDescriptor Context = Ty.getContext();
679 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
Devang Patel94c7ddb2011-08-16 22:09:43 +0000680 && (!Context || Context.isCompileUnit() || Context.isFile()
681 || Context.isNameSpace()))
Devang Patelc20bdf12011-06-01 00:23:24 +0000682 if (DIEEntry *Entry = getDIEEntry(Ty))
683 GlobalTypes[Ty.getName()] = Entry->getEntry();
Devang Patel161b2f42011-04-12 23:21:44 +0000684}
685
Devang Patel31c5d052011-05-06 16:57:54 +0000686/// addPubTypes - Add type for pubtypes section.
687void 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;
Devang Patelc20bdf12011-06-01 00:23:24 +0000698 addGlobalType(ATy);
Devang Patel31c5d052011-05-06 16:57:54 +0000699 }
700}
701
Devang Patel161b2f42011-04-12 23:21:44 +0000702/// constructTypeDIE - Construct basic type die from DIBasicType.
703void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
704 // Get core information.
705 StringRef Name = BTy.getName();
Devang Patel161b2f42011-04-12 23:21:44 +0000706 // Add name if not anonymous or intermediate type.
707 if (!Name.empty())
Nick Lewycky390c40d2011-10-27 06:44:11 +0000708 addString(&Buffer, dwarf::DW_AT_name, Name);
Devang Patel734a67c2011-09-14 23:13:28 +0000709
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);
Nick Lewycky746cb672011-10-26 22:55:33 +0000717 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Patel30d409c2012-02-07 23:33:58 +0000718 BTy.getEncoding());
Devang Patel734a67c2011-09-14 23:13:28 +0000719
Devang Patel161b2f42011-04-12 23:21:44 +0000720 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.
725void 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())
Nick Lewycky390c40d2011-10-27 06:44:11 +0000742 addString(&Buffer, dwarf::DW_AT_name, Name);
Devang Patel161b2f42011-04-12 23:21:44 +0000743
744 // Add size if non-zero (derived types might be zero-sized.)
Eric Christopher35f225a2012-02-21 22:25:53 +0000745 if (Size && Tag != dwarf::DW_TAG_pointer_type)
Devang Patel161b2f42011-04-12 23:21:44 +0000746 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.
754void 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 }
Eric Christopherbb0f6ea2012-05-23 00:09:20 +0000779 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 }
Devang Patel161b2f42011-04-12 23:21:44 +0000784 }
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 }
Eric Christopher8b6fe6b2012-02-22 08:46:21 +0000806 // Add prototype flag if we're dealing with a C language and the
807 // function has been prototyped.
808 if (isPrototyped &&
Eric Christopher4d069bf2012-05-22 18:45:24 +0000809 (Language == dwarf::DW_LANG_C89 ||
810 Language == dwarf::DW_LANG_C99 ||
811 Language == dwarf::DW_LANG_ObjC))
Devang Patel161b2f42011-04-12 23:21:44 +0000812 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);
Devang Pateldbc64af2011-08-15 17:24:54 +0000832 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
Devang Patel161b2f42011-04-12 23:21:44 +0000833 if (SP.isProtected())
Nick Lewycky13aaca52011-12-13 05:09:11 +0000834 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +0000835 dwarf::DW_ACCESS_protected);
836 else if (SP.isPrivate())
Nick Lewycky13aaca52011-12-13 05:09:11 +0000837 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +0000838 dwarf::DW_ACCESS_private);
839 else
Nick Lewycky13aaca52011-12-13 05:09:11 +0000840 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +0000841 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);
Nick Lewycky390c40d2011-10-27 06:44:11 +0000848 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
Devang Patel161b2f42011-04-12 23:21:44 +0000849 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);
Eric Christopher663e0cf2012-03-28 07:34:31 +0000853 } else if (Element.isDerivedType()) {
Eric Christopher4d069bf2012-05-22 18:45:24 +0000854 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));
Eric Christopher663e0cf2012-03-28 07:34:31 +0000860 } else if (Element.isObjCProperty()) {
Devang Patel30d409c2012-02-07 23:33:58 +0000861 DIObjCProperty Property(Element);
862 ElemDie = new DIE(Property.getTag());
863 StringRef PropertyName = Property.getObjCPropertyName();
864 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
Eric Christopher4d069bf2012-05-22 18:45:24 +0000865 addType(ElemDie, Property.getType());
866 addSourceLine(ElemDie, Property);
Devang Patel30d409c2012-02-07 23:33:58 +0000867 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;
Devang Patel9e11eb12012-02-04 01:30:32 +0000874 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);
Devang Patel6588abf2012-02-06 17:49:43 +0000889
Devang Patel30d409c2012-02-07 23:33:58 +0000890 DIEEntry *Entry = getDIEEntry(Element);
891 if (!Entry) {
892 Entry = createDIEEntry(ElemDie);
893 insertDIEEntry(Element, Entry);
894 }
Devang Patel9e11eb12012-02-04 01:30:32 +0000895 } else
Devang Patel161b2f42011-04-12 23:21:44 +0000896 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
Devang Patel161b2f42011-04-12 23:21:44 +0000903 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
Devang Patel201e6cd2011-05-12 21:29:42 +0000912 if (CTy.isObjcClassComplete())
913 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
Devang Patelb11f80e2011-05-12 19:06:16 +0000914 dwarf::DW_FORM_flag, 1);
915
Eric Christopher1a8e8862011-12-16 23:42:42 +0000916 // 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)
Devang Patel161b2f42011-04-12 23:21:44 +0000921 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())
Nick Lewycky390c40d2011-10-27 06:44:11 +0000931 addString(&Buffer, dwarf::DW_AT_name, Name);
Devang Patel161b2f42011-04-12 23:21:44 +0000932
Eric Christopher4a5d8392012-05-22 18:45:18 +0000933 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) {
Devang Patel161b2f42011-04-12 23:21:44 +0000937 // Add size if non-zero (derived types might be zero-sized.)
Eric Christopherfc4199b2012-06-01 00:22:32 +0000938 // TODO: Do we care about size for enum forward declarations?
Devang Patel161b2f42011-04-12 23:21:44 +0000939 if (Size)
940 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Eric Christopherfc4199b2012-06-01 00:22:32 +0000941 else if (!CTy.isForwardDecl())
Devang Patel161b2f42011-04-12 23:21:44 +0000942 // Add zero size if it is not a forward declaration.
Eric Christopherfc4199b2012-06-01 00:22:32 +0000943 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
944
945 // If we're a forward decl, say so.
946 if (CTy.isForwardDecl())
947 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel161b2f42011-04-12 23:21:44 +0000948
949 // Add source line info if available.
950 if (!CTy.isForwardDecl())
951 addSourceLine(&Buffer, CTy);
Eric Christopher89388952012-03-07 00:15:19 +0000952
953 // No harm in adding the runtime language to the declaration.
954 unsigned RLang = CTy.getRunTimeLang();
955 if (RLang)
956 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
957 dwarf::DW_FORM_data1, RLang);
Devang Patel161b2f42011-04-12 23:21:44 +0000958 }
959}
960
961/// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
962/// for the given DITemplateTypeParameter.
963DIE *
964CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
965 DIE *ParamDIE = getDIE(TP);
966 if (ParamDIE)
967 return ParamDIE;
968
969 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
970 addType(ParamDIE, TP.getType());
Nick Lewycky390c40d2011-10-27 06:44:11 +0000971 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
Devang Patel161b2f42011-04-12 23:21:44 +0000972 return ParamDIE;
973}
974
975/// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
976/// for the given DITemplateValueParameter.
977DIE *
Eric Christopher4d069bf2012-05-22 18:45:24 +0000978CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){
Devang Patel161b2f42011-04-12 23:21:44 +0000979 DIE *ParamDIE = getDIE(TPV);
980 if (ParamDIE)
981 return ParamDIE;
982
983 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
984 addType(ParamDIE, TPV.getType());
985 if (!TPV.getName().empty())
Nick Lewycky390c40d2011-10-27 06:44:11 +0000986 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
Devang Patel161b2f42011-04-12 23:21:44 +0000987 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
988 TPV.getValue());
989 return ParamDIE;
990}
991
Devang Patel31c5d052011-05-06 16:57:54 +0000992/// getOrCreateNameSpace - Create a DIE for DINameSpace.
993DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
994 DIE *NDie = getDIE(NS);
995 if (NDie)
996 return NDie;
997 NDie = new DIE(dwarf::DW_TAG_namespace);
998 insertDIE(NS, NDie);
Eric Christopher09ac3d82011-11-07 09:24:32 +0000999 if (!NS.getName().empty()) {
Nick Lewycky390c40d2011-10-27 06:44:11 +00001000 addString(NDie, dwarf::DW_AT_name, NS.getName());
Eric Christopher09ac3d82011-11-07 09:24:32 +00001001 addAccelNamespace(NS.getName(), NDie);
1002 } else
1003 addAccelNamespace("(anonymous namespace)", NDie);
Devang Patel31c5d052011-05-06 16:57:54 +00001004 addSourceLine(NDie, NS);
1005 addToContextOwner(NDie, NS.getContext());
1006 return NDie;
1007}
1008
Devang Pateldbc64af2011-08-15 17:24:54 +00001009/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1010/// printer to not emit usual symbol prefix before the symbol name is used then
1011/// return linkage name after skipping this special LLVM prefix.
1012static StringRef getRealLinkageName(StringRef LinkageName) {
1013 char One = '\1';
1014 if (LinkageName.startswith(StringRef(&One, 1)))
1015 return LinkageName.substr(1);
1016 return LinkageName;
1017}
1018
1019/// getOrCreateSubprogramDIE - Create new DIE using SP.
1020DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1021 DIE *SPDie = getDIE(SP);
1022 if (SPDie)
1023 return SPDie;
1024
Peter Collingbourne27302f02012-05-27 18:36:44 +00001025 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1026
1027 // DW_TAG_inlined_subroutine may refer to this DIE.
1028 insertDIE(SP, SPDie);
1029
Rafael Espindola01b55b42011-11-10 22:34:29 +00001030 DISubprogram SPDecl = SP.getFunctionDeclaration();
1031 DIE *DeclDie = NULL;
1032 if (SPDecl.isSubprogram()) {
1033 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1034 }
1035
Devang Pateldbc64af2011-08-15 17:24:54 +00001036 // Add to context owner.
1037 addToContextOwner(SPDie, SP.getContext());
1038
1039 // Add function template parameters.
1040 addTemplateParams(*SPDie, SP.getTemplateParams());
1041
Eric Christophere9722e12012-04-16 23:54:23 +00001042 // Unfortunately this code needs to stay here instead of below the
1043 // AT_specification code in order to work around a bug in older
1044 // gdbs that requires the linkage name to resolve multiple template
1045 // functions.
Eric Christopher8d101c32012-03-15 08:19:33 +00001046 StringRef LinkageName = SP.getLinkageName();
1047 if (!LinkageName.empty())
1048 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1049 getRealLinkageName(LinkageName));
1050
Devang Pateldbc64af2011-08-15 17:24:54 +00001051 // If this DIE is going to refer declaration info using AT_specification
1052 // then there is no need to add other attributes.
Rafael Espindola01b55b42011-11-10 22:34:29 +00001053 if (DeclDie) {
1054 // Refer function declaration directly.
1055 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1056 DeclDie);
1057
Devang Pateldbc64af2011-08-15 17:24:54 +00001058 return SPDie;
Rafael Espindola01b55b42011-11-10 22:34:29 +00001059 }
Devang Pateldbc64af2011-08-15 17:24:54 +00001060
1061 // Constructors and operators for anonymous aggregates do not have names.
1062 if (!SP.getName().empty())
Nick Lewycky390c40d2011-10-27 06:44:11 +00001063 addString(SPDie, dwarf::DW_AT_name, SP.getName());
Devang Pateldbc64af2011-08-15 17:24:54 +00001064
1065 addSourceLine(SPDie, SP);
1066
Eric Christopher8b6fe6b2012-02-22 08:46:21 +00001067 // Add the prototype if we have a prototype and we have a C like
1068 // language.
1069 if (SP.isPrototyped() &&
1070 (Language == dwarf::DW_LANG_C89 ||
1071 Language == dwarf::DW_LANG_C99 ||
1072 Language == dwarf::DW_LANG_ObjC))
Devang Pateldbc64af2011-08-15 17:24:54 +00001073 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1074
1075 // Add Return Type.
1076 DICompositeType SPTy = SP.getType();
1077 DIArray Args = SPTy.getTypeArray();
1078 unsigned SPTag = SPTy.getTag();
1079
1080 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1081 addType(SPDie, SPTy);
1082 else
1083 addType(SPDie, DIType(Args.getElement(0)));
1084
1085 unsigned VK = SP.getVirtuality();
1086 if (VK) {
Nick Lewycky798313d2011-12-14 00:56:07 +00001087 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
Devang Pateldbc64af2011-08-15 17:24:54 +00001088 DIEBlock *Block = getDIEBlock();
1089 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1090 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1091 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1092 ContainingTypeMap.insert(std::make_pair(SPDie,
1093 SP.getContainingType()));
1094 }
1095
1096 if (!SP.isDefinition()) {
1097 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1098
1099 // Add arguments. Do not add arguments for subprogram definition. They will
1100 // be handled while processing variables.
1101 DICompositeType SPTy = SP.getType();
1102 DIArray Args = SPTy.getTypeArray();
1103 unsigned SPTag = SPTy.getTag();
1104
1105 if (SPTag == dwarf::DW_TAG_subroutine_type)
1106 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1107 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1108 DIType ATy = DIType(DIType(Args.getElement(i)));
1109 addType(Arg, ATy);
1110 if (ATy.isArtificial())
1111 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1112 SPDie->addChild(Arg);
1113 }
1114 }
1115
1116 if (SP.isArtificial())
1117 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1118
1119 if (!SP.isLocalToUnit())
1120 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1121
1122 if (SP.isOptimized())
1123 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1124
1125 if (unsigned isa = Asm->getISAEncoding()) {
1126 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1127 }
1128
1129 return SPDie;
1130}
1131
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001132// Return const expression if value is a GEP to access merged global
1133// constant. e.g.
1134// i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1135static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1136 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1137 if (!CE || CE->getNumOperands() != 3 ||
1138 CE->getOpcode() != Instruction::GetElementPtr)
1139 return NULL;
1140
1141 // First operand points to a global struct.
1142 Value *Ptr = CE->getOperand(0);
1143 if (!isa<GlobalValue>(Ptr) ||
1144 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1145 return NULL;
1146
1147 // Second operand is zero.
1148 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1149 if (!CI || !CI->isZero())
1150 return NULL;
1151
1152 // Third operand is offset.
1153 if (!isa<ConstantInt>(CE->getOperand(2)))
1154 return NULL;
1155
1156 return CE;
1157}
1158
1159/// createGlobalVariableDIE - create global variable DIE.
1160void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001161 // Check for pre-existence.
Devang Patel49e2f032011-08-18 22:21:50 +00001162 if (getDIE(N))
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001163 return;
1164
Devang Patel49e2f032011-08-18 22:21:50 +00001165 DIGlobalVariable GV(N);
Devang Patel28bea082011-08-18 23:17:55 +00001166 if (!GV.Verify())
1167 return;
1168
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001169 DIE *VariableDIE = new DIE(GV.getTag());
Devang Patel49e2f032011-08-18 22:21:50 +00001170 // Add to map.
1171 insertDIE(N, VariableDIE);
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001172
1173 // Add name.
Nick Lewycky390c40d2011-10-27 06:44:11 +00001174 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001175 StringRef LinkageName = GV.getLinkageName();
Devang Patel49e2f032011-08-18 22:21:50 +00001176 bool isGlobalVariable = GV.getGlobal() != NULL;
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001177 if (!LinkageName.empty() && isGlobalVariable)
Nick Lewycky746cb672011-10-26 22:55:33 +00001178 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
Nick Lewycky390c40d2011-10-27 06:44:11 +00001179 getRealLinkageName(LinkageName));
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001180 // Add type.
Devang Patel49e2f032011-08-18 22:21:50 +00001181 DIType GTy = GV.getType();
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001182 addType(VariableDIE, GTy);
1183
1184 // Add scoping info.
Eric Christopherdfa30e12011-11-09 05:24:07 +00001185 if (!GV.isLocalToUnit())
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001186 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Eric Christopherdfa30e12011-11-09 05:24:07 +00001187
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001188 // Add line number info.
1189 addSourceLine(VariableDIE, GV);
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001190 // Add to context owner.
1191 DIDescriptor GVContext = GV.getContext();
1192 addToContextOwner(VariableDIE, GVContext);
1193 // Add location.
Eric Christopher09ac3d82011-11-07 09:24:32 +00001194 bool addToAccelTable = false;
Eric Christopherd61c34b2011-11-11 03:16:32 +00001195 DIE *VariableSpecDIE = NULL;
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001196 if (isGlobalVariable) {
Eric Christopher09ac3d82011-11-07 09:24:32 +00001197 addToAccelTable = true;
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001198 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1199 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1200 addLabel(Block, 0, dwarf::DW_FORM_udata,
1201 Asm->Mang->getSymbol(GV.getGlobal()));
1202 // Do not create specification DIE if context is either compile unit
1203 // or a subprogram.
Devang Patel1dd4e562011-09-21 23:41:11 +00001204 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001205 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1206 // Create specification DIE.
Eric Christopherd117fbb2011-11-11 01:55:22 +00001207 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001208 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1209 dwarf::DW_FORM_ref4, VariableDIE);
1210 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1211 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1212 1);
1213 addDie(VariableSpecDIE);
1214 } else {
1215 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
Eric Christopher09ac3d82011-11-07 09:24:32 +00001216 }
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001217 } else if (const ConstantInt *CI =
1218 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1219 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1220 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
Eric Christopher09ac3d82011-11-07 09:24:32 +00001221 addToAccelTable = true;
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001222 // GV is a merged global.
1223 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1224 Value *Ptr = CE->getOperand(0);
1225 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1226 addLabel(Block, 0, dwarf::DW_FORM_udata,
1227 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1228 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1229 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1230 addUInt(Block, 0, dwarf::DW_FORM_udata,
1231 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1232 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1233 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1234 }
1235
Eric Christopherd117fbb2011-11-11 01:55:22 +00001236 if (addToAccelTable) {
1237 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1238 addAccelName(GV.getName(), AddrDIE);
Eric Christopher09ac3d82011-11-07 09:24:32 +00001239
Eric Christopherd117fbb2011-11-11 01:55:22 +00001240 // If the linkage name is different than the name, go ahead and output
1241 // that as well into the name table.
1242 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1243 addAccelName(GV.getLinkageName(), AddrDIE);
1244 }
Eric Christopher74d8a872011-11-08 21:56:23 +00001245
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001246 return;
1247}
1248
Devang Patel161b2f42011-04-12 23:21:44 +00001249/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
Eric Christopher4d069bf2012-05-22 18:45:24 +00001250void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1251 DIE *IndexTy) {
Devang Patel161b2f42011-04-12 23:21:44 +00001252 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1253 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patelce35d8b2011-11-17 23:43:15 +00001254 uint64_t L = SR.getLo();
1255 uint64_t H = SR.getHi();
Devang Patel161b2f42011-04-12 23:21:44 +00001256
1257 // The L value defines the lower bounds which is typically zero for C/C++. The
1258 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1259 // of the array. If L > H then do not emit DW_AT_lower_bound and
1260 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1261 // array has one element and in such case do not emit lower bound.
1262
1263 if (L > H) {
1264 Buffer.addChild(DW_Subrange);
1265 return;
1266 }
1267 if (L)
Devang Patelce35d8b2011-11-17 23:43:15 +00001268 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1269 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Devang Patel161b2f42011-04-12 23:21:44 +00001270 Buffer.addChild(DW_Subrange);
1271}
1272
1273/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1274void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1275 DICompositeType *CTy) {
1276 Buffer.setTag(dwarf::DW_TAG_array_type);
1277 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1278 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1279
1280 // Emit derived type.
1281 addType(&Buffer, CTy->getTypeDerivedFrom());
1282 DIArray Elements = CTy->getTypeArray();
1283
1284 // Get an anonymous type for index type.
1285 DIE *IdxTy = getIndexTyDie();
1286 if (!IdxTy) {
1287 // Construct an anonymous type for index type.
1288 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1289 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1290 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1291 dwarf::DW_ATE_signed);
1292 addDie(IdxTy);
1293 setIndexTyDie(IdxTy);
1294 }
1295
1296 // Add subranges to array type.
1297 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1298 DIDescriptor Element = Elements.getElement(i);
1299 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1300 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1301 }
1302}
1303
1304/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1305DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1306 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1307 StringRef Name = ETy.getName();
Nick Lewycky390c40d2011-10-27 06:44:11 +00001308 addString(Enumerator, dwarf::DW_AT_name, Name);
Devang Patel161b2f42011-04-12 23:21:44 +00001309 int64_t Value = ETy.getEnumValue();
1310 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1311 return Enumerator;
1312}
1313
Devang Pateldbc64af2011-08-15 17:24:54 +00001314/// constructContainingTypeDIEs - Construct DIEs for types that contain
1315/// vtables.
1316void CompileUnit::constructContainingTypeDIEs() {
1317 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1318 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1319 DIE *SPDie = CI->first;
1320 const MDNode *N = CI->second;
1321 if (!N) continue;
1322 DIE *NDie = getDIE(N);
1323 if (!NDie) continue;
1324 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1325 }
1326}
1327
Devang Pateld0b5a5e2011-08-15 22:04:40 +00001328/// constructVariableDIE - Construct a DIE for the given DbgVariable.
1329DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1330 StringRef Name = DV->getName();
1331 if (Name.empty())
1332 return NULL;
1333
1334 // Translate tag to proper Dwarf tag.
1335 unsigned Tag = DV->getTag();
1336
1337 // Define variable debug information entry.
1338 DIE *VariableDie = new DIE(Tag);
1339 DbgVariable *AbsVar = DV->getAbstractVariable();
1340 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1341 if (AbsDIE)
1342 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1343 dwarf::DW_FORM_ref4, AbsDIE);
1344 else {
Nick Lewycky390c40d2011-10-27 06:44:11 +00001345 addString(VariableDie, dwarf::DW_AT_name, Name);
Devang Pateld0b5a5e2011-08-15 22:04:40 +00001346 addSourceLine(VariableDie, DV->getVariable());
1347 addType(VariableDie, DV->getType());
1348 }
1349
1350 if (DV->isArtificial())
1351 addUInt(VariableDie, dwarf::DW_AT_artificial,
1352 dwarf::DW_FORM_flag, 1);
1353
1354 if (isScopeAbstract) {
1355 DV->setDIE(VariableDie);
1356 return VariableDie;
1357 }
1358
1359 // Add variable address.
1360
1361 unsigned Offset = DV->getDotDebugLocOffset();
1362 if (Offset != ~0U) {
1363 addLabel(VariableDie, dwarf::DW_AT_location,
1364 dwarf::DW_FORM_data4,
1365 Asm->GetTempSymbol("debug_loc", Offset));
1366 DV->setDIE(VariableDie);
1367 return VariableDie;
1368 }
1369
Eric Christopher8cf5e742011-10-03 15:49:20 +00001370 // Check if variable is described by a DBG_VALUE instruction.
Devang Pateld0b5a5e2011-08-15 22:04:40 +00001371 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1372 bool updated = false;
1373 if (DVInsn->getNumOperands() == 3) {
1374 if (DVInsn->getOperand(0).isReg()) {
1375 const MachineOperand RegOp = DVInsn->getOperand(0);
1376 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1377 if (DVInsn->getOperand(1).isImm() &&
1378 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1379 unsigned FrameReg = 0;
1380 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1381 int Offset =
1382 TFI->getFrameIndexReference(*Asm->MF,
1383 DVInsn->getOperand(1).getImm(),
1384 FrameReg);
1385 MachineLocation Location(FrameReg, Offset);
1386 addVariableAddress(DV, VariableDie, Location);
1387
1388 } else if (RegOp.getReg())
1389 addVariableAddress(DV, VariableDie,
1390 MachineLocation(RegOp.getReg()));
1391 updated = true;
1392 }
1393 else if (DVInsn->getOperand(0).isImm())
1394 updated =
1395 addConstantValue(VariableDie, DVInsn->getOperand(0),
1396 DV->getType());
1397 else if (DVInsn->getOperand(0).isFPImm())
1398 updated =
1399 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1400 else if (DVInsn->getOperand(0).isCImm())
1401 updated =
1402 addConstantValue(VariableDie,
1403 DVInsn->getOperand(0).getCImm(),
1404 DV->getType().isUnsignedDIType());
1405 } else {
1406 addVariableAddress(DV, VariableDie,
1407 Asm->getDebugValueLocation(DVInsn));
1408 updated = true;
1409 }
1410 if (!updated) {
1411 // If variableDie is not updated then DBG_VALUE instruction does not
1412 // have valid variable info.
1413 delete VariableDie;
1414 return NULL;
1415 }
1416 DV->setDIE(VariableDie);
1417 return VariableDie;
1418 } else {
1419 // .. else use frame index.
1420 int FI = DV->getFrameIndex();
1421 if (FI != ~0) {
1422 unsigned FrameReg = 0;
1423 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1424 int Offset =
1425 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1426 MachineLocation Location(FrameReg, Offset);
1427 addVariableAddress(DV, VariableDie, Location);
1428 }
1429 }
1430
1431 DV->setDIE(VariableDie);
1432 return VariableDie;
1433}
1434
Devang Patel161b2f42011-04-12 23:21:44 +00001435/// createMemberDIE - Create new member DIE.
1436DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1437 DIE *MemberDie = new DIE(DT.getTag());
1438 StringRef Name = DT.getName();
1439 if (!Name.empty())
Nick Lewycky390c40d2011-10-27 06:44:11 +00001440 addString(MemberDie, dwarf::DW_AT_name, Name);
Devang Patel161b2f42011-04-12 23:21:44 +00001441
1442 addType(MemberDie, DT.getTypeDerivedFrom());
1443
1444 addSourceLine(MemberDie, DT);
1445
1446 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1447 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1448
1449 uint64_t Size = DT.getSizeInBits();
1450 uint64_t FieldSize = DT.getOriginalTypeSize();
1451
1452 if (Size != FieldSize) {
1453 // Handle bitfield.
1454 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1455 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1456
1457 uint64_t Offset = DT.getOffsetInBits();
1458 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1459 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1460 uint64_t FieldOffset = (HiMark - FieldSize);
1461 Offset -= FieldOffset;
1462
1463 // Maybe we need to work from the other end.
1464 if (Asm->getTargetData().isLittleEndian())
1465 Offset = FieldSize - (Offset + Size);
1466 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1467
1468 // Here WD_AT_data_member_location points to the anonymous
1469 // field that includes this bit field.
1470 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1471
1472 } else
1473 // This is not a bitfield.
1474 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1475
1476 if (DT.getTag() == dwarf::DW_TAG_inheritance
1477 && DT.isVirtual()) {
1478
1479 // For C++, virtual base classes are not at fixed offset. Use following
1480 // expression to extract appropriate offset from vtable.
1481 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1482
1483 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1484 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1485 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1486 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1487 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1488 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1489 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1490 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1491
1492 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1493 VBaseLocationDie);
1494 } else
1495 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1496
1497 if (DT.isProtected())
Nick Lewycky13aaca52011-12-13 05:09:11 +00001498 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +00001499 dwarf::DW_ACCESS_protected);
1500 else if (DT.isPrivate())
Nick Lewycky13aaca52011-12-13 05:09:11 +00001501 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +00001502 dwarf::DW_ACCESS_private);
1503 // Otherwise C++ member and base classes are considered public.
Devang Patel94c7ddb2011-08-16 22:09:43 +00001504 else
Nick Lewycky13aaca52011-12-13 05:09:11 +00001505 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +00001506 dwarf::DW_ACCESS_public);
1507 if (DT.isVirtual())
Nick Lewycky798313d2011-12-14 00:56:07 +00001508 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
Devang Patel161b2f42011-04-12 23:21:44 +00001509 dwarf::DW_VIRTUALITY_virtual);
Devang Patele9db5e22011-04-16 00:11:51 +00001510
1511 // Objective-C properties.
Devang Patel6588abf2012-02-06 17:49:43 +00001512 if (MDNode *PNode = DT.getObjCProperty())
1513 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1514 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1515 PropertyDie);
1516
Devang Patel9e11eb12012-02-04 01:30:32 +00001517 // This is only for backward compatibility.
Devang Patele9db5e22011-04-16 00:11:51 +00001518 StringRef PropertyName = DT.getObjCPropertyName();
1519 if (!PropertyName.empty()) {
Nick Lewycky390c40d2011-10-27 06:44:11 +00001520 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
Devang Patele9db5e22011-04-16 00:11:51 +00001521 StringRef GetterName = DT.getObjCPropertyGetterName();
1522 if (!GetterName.empty())
Nick Lewycky390c40d2011-10-27 06:44:11 +00001523 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
Devang Patele9db5e22011-04-16 00:11:51 +00001524 StringRef SetterName = DT.getObjCPropertySetterName();
1525 if (!SetterName.empty())
Nick Lewycky390c40d2011-10-27 06:44:11 +00001526 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
Devang Patele9db5e22011-04-16 00:11:51 +00001527 unsigned PropertyAttributes = 0;
1528 if (DT.isReadOnlyObjCProperty())
1529 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1530 if (DT.isReadWriteObjCProperty())
1531 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1532 if (DT.isAssignObjCProperty())
1533 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1534 if (DT.isRetainObjCProperty())
1535 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1536 if (DT.isCopyObjCProperty())
1537 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1538 if (DT.isNonAtomicObjCProperty())
1539 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1540 if (PropertyAttributes)
1541 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1542 PropertyAttributes);
1543 }
Devang Patel161b2f42011-04-12 23:21:44 +00001544 return MemberDie;
1545}