Mercurial > hg > CbC > CbC_llvm

comparison lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp @ 0:95c75e76d11b LLVM3.4

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