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