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