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