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