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