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 #include "DwarfUnit.h"
16 #include "DwarfAccelTable.h"
17 #include "DwarfCompileUnit.h"
18 #include "DwarfDebug.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DIBuilder.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/MCContext.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetSubtargetInfo.h"
37 using namespace llvm;
39 #define DEBUG_TYPE "dwarfdebug"
41 static cl::opt<bool>
42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
43 cl::desc("Generate DWARF4 type units."),
44 cl::init(false));
46 /// Unit - Unit constructor.
47 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
48 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
49 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
50 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr),
51 Skeleton(nullptr) {
52 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
53 UnitTag == dwarf::DW_TAG_type_unit);
54 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
55 }
57 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
58 DwarfDebug *DW, DwarfFile *DWU,
59 MCDwarfDwoLineTable *SplitLineTable)
60 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
61 CU(CU), SplitLineTable(SplitLineTable) {
62 if (SplitLineTable)
63 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
64 }
66 /// ~Unit - Destructor for compile unit.
67 DwarfUnit::~DwarfUnit() {
68 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
69 DIEBlocks[j]->~DIEBlock();
70 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
71 DIELocs[j]->~DIELoc();
72 }
74 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
75 /// information entry.
76 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
77 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
78 return Value;
79 }
81 /// getDefaultLowerBound - Return the default lower bound for an array. If the
82 /// DWARF version doesn't handle the language, return -1.
83 int64_t DwarfUnit::getDefaultLowerBound() const {
84 switch (getLanguage()) {
85 default:
86 break;
88 case dwarf::DW_LANG_C89:
89 case dwarf::DW_LANG_C99:
90 case dwarf::DW_LANG_C:
91 case dwarf::DW_LANG_C_plus_plus:
92 case dwarf::DW_LANG_ObjC:
93 case dwarf::DW_LANG_ObjC_plus_plus:
94 return 0;
96 case dwarf::DW_LANG_Fortran77:
97 case dwarf::DW_LANG_Fortran90:
98 case dwarf::DW_LANG_Fortran95:
99 return 1;
101 // The languages below have valid values only if the DWARF version >= 4.
102 case dwarf::DW_LANG_Java:
103 case dwarf::DW_LANG_Python:
104 case dwarf::DW_LANG_UPC:
105 case dwarf::DW_LANG_D:
106 if (dwarf::DWARF_VERSION >= 4)
107 return 0;
108 break;
110 case dwarf::DW_LANG_Ada83:
111 case dwarf::DW_LANG_Ada95:
112 case dwarf::DW_LANG_Cobol74:
113 case dwarf::DW_LANG_Cobol85:
114 case dwarf::DW_LANG_Modula2:
115 case dwarf::DW_LANG_Pascal83:
116 case dwarf::DW_LANG_PLI:
117 if (dwarf::DWARF_VERSION >= 4)
118 return 1;
119 break;
120 }
122 return -1;
123 }
125 /// Check whether the DIE for this MDNode can be shared across CUs.
126 static bool isShareableAcrossCUs(DIDescriptor D) {
127 // When the MDNode can be part of the type system, the DIE can be shared
128 // across CUs.
129 // Combining type units and cross-CU DIE sharing is lower value (since
130 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
131 // level already) but may be implementable for some value in projects
132 // building multiple independent libraries with LTO and then linking those
133 // together.
134 return (D.isType() ||
135 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
136 !GenerateDwarfTypeUnits;
137 }
139 /// getDIE - Returns the debug information entry map slot for the
140 /// specified debug variable. We delegate the request to DwarfDebug
141 /// when the DIE for this MDNode can be shared across CUs. The mappings
142 /// will be kept in DwarfDebug for shareable DIEs.
143 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
144 if (isShareableAcrossCUs(D))
145 return DD->getDIE(D);
146 return MDNodeToDieMap.lookup(D);
147 }
149 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
150 /// when the DIE for this MDNode can be shared across CUs. The mappings
151 /// will be kept in DwarfDebug for shareable DIEs.
152 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
153 if (isShareableAcrossCUs(Desc)) {
154 DD->insertDIE(Desc, D);
155 return;
156 }
157 MDNodeToDieMap.insert(std::make_pair(Desc, D));
158 }
160 /// addFlag - Add a flag that is true.
161 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
162 if (DD->getDwarfVersion() >= 4)
163 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
164 else
165 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
166 }
168 /// addUInt - Add an unsigned integer attribute data and value.
169 ///
170 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
171 Optional<dwarf::Form> Form, uint64_t Integer) {
172 if (!Form)
173 Form = DIEInteger::BestForm(false, Integer);
174 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
175 DIEInteger(Integer);
176 Die.addValue(Attribute, *Form, Value);
177 }
179 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
180 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
181 }
183 /// addSInt - Add an signed integer attribute data and value.
184 ///
185 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
186 Optional<dwarf::Form> Form, int64_t Integer) {
187 if (!Form)
188 Form = DIEInteger::BestForm(true, Integer);
189 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
190 Die.addValue(Attribute, *Form, Value);
191 }
193 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
194 int64_t Integer) {
195 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
196 }
198 /// addString - Add a string attribute data and value. We always emit a
199 /// reference to the string pool instead of immediate strings so that DIEs have
200 /// more predictable sizes. In the case of split dwarf we emit an index
201 /// into another table which gets us the static offset into the string
202 /// table.
203 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
204 StringRef String) {
206 if (!DD->useSplitDwarf())
207 return addLocalString(Die, Attribute, String);
209 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
210 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
211 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
212 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
213 }
215 /// addLocalString - Add a string attribute data and value. This is guaranteed
216 /// to be in the local string pool instead of indirected.
217 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
218 StringRef String) {
219 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
220 DIEValue *Value;
221 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
222 Value = new (DIEValueAllocator) DIELabel(Symb);
223 else
224 Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
225 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
226 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
227 }
229 /// addExpr - Add a Dwarf expression attribute data and value.
230 ///
231 void DwarfUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) {
232 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
233 Die.addValue((dwarf::Attribute)0, Form, Value);
234 }
236 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
237 ///
238 void DwarfUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
239 unsigned Index) {
240 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
241 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
242 : dwarf::DW_FORM_data4;
243 Die.addValue(Attribute, Form, Value);
244 }
246 /// addLabel - Add a Dwarf label attribute data and value.
247 ///
248 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
249 const MCSymbol *Label) {
250 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
251 Die.addValue(Attribute, Form, Value);
252 }
254 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
255 addLabel(Die, (dwarf::Attribute)0, Form, Label);
256 }
258 /// addSectionOffset - Add an offset into a section attribute data and value.
259 ///
260 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
261 uint64_t Integer) {
262 if (DD->getDwarfVersion() >= 4)
263 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
264 else
265 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
266 }
268 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
269 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
270 : getCU().getOrCreateSourceID(FileName, DirName);
271 }
273 /// addOpAddress - Add a dwarf op address data and value using the
274 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
275 ///
276 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
277 if (!DD->useSplitDwarf()) {
278 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
279 addLabel(Die, dwarf::DW_FORM_udata, Sym);
280 } else {
281 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
282 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
283 DD->getAddressPool().getIndex(Sym));
284 }
285 }
287 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
288 const MCSymbol *Hi, const MCSymbol *Lo) {
289 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
290 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
291 }
293 /// addDIEEntry - Add a DIE attribute data and value.
294 ///
295 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
296 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
297 }
299 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
300 // Flag the type unit reference as a declaration so that if it contains
301 // members (implicit special members, static data member definitions, member
302 // declarations for definitions in this CU, etc) consumers don't get confused
303 // and think this is a full definition.
304 addFlag(Die, dwarf::DW_AT_declaration);
306 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
307 new (DIEValueAllocator) DIETypeSignature(Type));
308 }
310 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
311 DIEEntry *Entry) {
312 const DIE *DieCU = Die.getUnitOrNull();
313 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
314 if (!DieCU)
315 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
316 DieCU = &getUnitDie();
317 if (!EntryCU)
318 EntryCU = &getUnitDie();
319 Die.addValue(Attribute,
320 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
321 Entry);
322 }
324 /// Create a DIE with the given Tag, add the DIE to its parent, and
325 /// call insertDIE if MD is not null.
326 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
327 assert(Tag != dwarf::DW_TAG_auto_variable &&
328 Tag != dwarf::DW_TAG_arg_variable);
329 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
330 DIE &Die = *Parent.getChildren().back();
331 if (N)
332 insertDIE(N, &Die);
333 return Die;
334 }
336 /// addBlock - Add block data.
337 ///
338 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
339 Loc->ComputeSize(Asm);
340 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
341 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
342 }
344 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
345 DIEBlock *Block) {
346 Block->ComputeSize(Asm);
347 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
348 Die.addValue(Attribute, Block->BestForm(), Block);
349 }
351 /// addSourceLine - Add location information to specified debug information
352 /// entry.
353 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
354 StringRef Directory) {
355 if (Line == 0)
356 return;
358 unsigned FileID = getOrCreateSourceID(File, Directory);
359 assert(FileID && "Invalid file id");
360 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
361 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
362 }
364 /// addSourceLine - Add location information to specified debug information
365 /// entry.
366 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
367 assert(V.isVariable());
369 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
370 V.getContext().getDirectory());
371 }
373 /// addSourceLine - Add location information to specified debug information
374 /// entry.
375 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
376 assert(G.isGlobalVariable());
378 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
379 }
381 /// addSourceLine - Add location information to specified debug information
382 /// entry.
383 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
384 assert(SP.isSubprogram());
386 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
387 }
389 /// addSourceLine - Add location information to specified debug information
390 /// entry.
391 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
392 assert(Ty.isType());
394 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
395 }
397 /// addSourceLine - Add location information to specified debug information
398 /// entry.
399 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
400 assert(Ty.isObjCProperty());
402 DIFile File = Ty.getFile();
403 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
404 File.getDirectory());
405 }
407 /// addSourceLine - Add location information to specified debug information
408 /// entry.
409 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
410 assert(NS.Verify());
412 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
413 }
415 /// addVariableAddress - Add DW_AT_location attribute for a
416 /// DbgVariable based on provided MachineLocation.
417 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
418 MachineLocation Location) {
419 if (DV.variableHasComplexAddress())
420 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
421 else if (DV.isBlockByrefVariable())
422 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
423 else
424 addAddress(Die, dwarf::DW_AT_location, Location,
425 DV.getVariable().isIndirect());
426 }
428 /// addRegisterOp - Add register operand.
429 // FIXME: Ideally, this would share the implementation with
430 // AsmPrinter::EmitDwarfRegOpPiece.
431 void DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
432 unsigned SizeInBits, unsigned OffsetInBits) {
433 const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
434 int DWReg = RI->getDwarfRegNum(Reg, false);
435 bool isSubRegister = DWReg < 0;
437 unsigned Idx = 0;
439 // Go up the super-register chain until we hit a valid dwarf register number.
440 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
441 DWReg = RI->getDwarfRegNum(*SR, false);
442 if (DWReg >= 0)
443 Idx = RI->getSubRegIndex(*SR, Reg);
444 }
446 if (DWReg < 0) {
447 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
448 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
449 return;
450 }
452 // Emit register.
453 if (DWReg < 32)
454 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
455 else {
456 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
457 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
458 }
460 // Emit mask.
461 bool isPiece = SizeInBits > 0;
462 if (isSubRegister || isPiece) {
463 const unsigned SizeOfByte = 8;
464 unsigned RegSizeInBits = RI->getSubRegIdxSize(Idx);
465 unsigned RegOffsetInBits = RI->getSubRegIdxOffset(Idx);
466 unsigned PieceSizeInBits = std::max(SizeInBits, RegSizeInBits);
467 unsigned PieceOffsetInBits = OffsetInBits ? OffsetInBits : RegOffsetInBits;
468 assert(RegSizeInBits >= SizeInBits && "register smaller than value");
470 if (RegOffsetInBits != PieceOffsetInBits) {
471 // Manually shift the value into place, since the DW_OP_piece
472 // describes the part of the variable, not the position of the
473 // subregister.
474 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
475 addUInt(TheDie, dwarf::DW_FORM_data1, RegOffsetInBits);
476 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_shr);
477 }
479 if (PieceOffsetInBits > 0 || PieceSizeInBits % SizeOfByte) {
480 assert(PieceSizeInBits > 0 && "piece has zero size");
481 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
482 addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits);
483 addUInt(TheDie, dwarf::DW_FORM_data1, PieceOffsetInBits);
484 } else {
485 assert(PieceSizeInBits > 0 && "piece has zero size");
486 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
487 addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits/SizeOfByte);
488 }
489 }
490 }
492 /// addRegisterOffset - Add register offset.
493 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
494 int64_t Offset) {
495 const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
496 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
497 const TargetRegisterInfo *TRI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
498 if (Reg == TRI->getFrameRegister(*Asm->MF))
499 // If variable offset is based in frame register then use fbreg.
500 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
501 else if (DWReg < 32)
502 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
503 else {
504 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
505 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
506 }
507 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
508 }
510 /// addAddress - Add an address attribute to a die based on the location
511 /// provided.
512 void DwarfUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
513 const MachineLocation &Location, bool Indirect) {
514 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
516 if (Location.isReg() && !Indirect)
517 addRegisterOpPiece(*Loc, Location.getReg());
518 else {
519 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
520 if (Indirect && !Location.isReg()) {
521 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
522 }
523 }
525 // Now attach the location information to the DIE.
526 addBlock(Die, Attribute, Loc);
527 }
529 /// addComplexAddress - Start with the address based on the location provided,
530 /// and generate the DWARF information necessary to find the actual variable
531 /// given the extra address information encoded in the DbgVariable, starting
532 /// from the starting location. Add the DWARF information to the die.
533 ///
534 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
535 dwarf::Attribute Attribute,
536 const MachineLocation &Location) {
537 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
538 unsigned N = DV.getNumAddrElements();
539 unsigned i = 0;
540 if (Location.isReg()) {
541 if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_plus) {
542 assert(!DV.getVariable().isIndirect() &&
543 "double indirection not handled");
544 // If first address element is OpPlus then emit
545 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
546 addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1));
547 i = 2;
548 } else if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_deref) {
549 assert(!DV.getVariable().isIndirect() &&
550 "double indirection not handled");
551 addRegisterOpPiece(*Loc, Location.getReg(),
552 DV.getExpression().getPieceSize(),
553 DV.getExpression().getPieceOffset());
554 i = 3;
555 } else
556 addRegisterOpPiece(*Loc, Location.getReg());
557 } else
558 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
560 for (; i < N; ++i) {
561 uint64_t Element = DV.getAddrElement(i);
562 if (Element == dwarf::DW_OP_plus) {
563 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
564 addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
566 } else if (Element == dwarf::DW_OP_deref) {
567 if (!Location.isReg())
568 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
570 } else if (Element == dwarf::DW_OP_piece) {
571 const unsigned SizeOfByte = 8;
572 unsigned PieceOffsetInBits = DV.getAddrElement(++i)*SizeOfByte;
573 unsigned PieceSizeInBits = DV.getAddrElement(++i)*SizeOfByte;
574 // Emit DW_OP_bit_piece Size Offset.
575 assert(PieceSizeInBits > 0 && "piece has zero size");
576 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
577 addUInt(*Loc, dwarf::DW_FORM_udata, PieceSizeInBits);
578 addUInt(*Loc, dwarf::DW_FORM_udata, PieceOffsetInBits);
580 } else
581 llvm_unreachable("unknown DIBuilder Opcode");
582 }
584 // Now attach the location information to the DIE.
585 addBlock(Die, Attribute, Loc);
586 }
588 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
589 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
590 gives the variable VarName either the struct, or a pointer to the struct, as
591 its type. This is necessary for various behind-the-scenes things the
592 compiler needs to do with by-reference variables in Blocks.
594 However, as far as the original *programmer* is concerned, the variable
595 should still have type 'SomeType', as originally declared.
597 The function getBlockByrefType dives into the __Block_byref_x_VarName
598 struct to find the original type of the variable, which is then assigned to
599 the variable's Debug Information Entry as its real type. So far, so good.
600 However now the debugger will expect the variable VarName to have the type
601 SomeType. So we need the location attribute for the variable to be an
602 expression that explains to the debugger how to navigate through the
603 pointers and struct to find the actual variable of type SomeType.
605 The following function does just that. We start by getting
606 the "normal" location for the variable. This will be the location
607 of either the struct __Block_byref_x_VarName or the pointer to the
608 struct __Block_byref_x_VarName.
610 The struct will look something like:
612 struct __Block_byref_x_VarName {
613 ... <various fields>
614 struct __Block_byref_x_VarName *forwarding;
615 ... <various other fields>
616 SomeType VarName;
617 ... <maybe more fields>
618 };
620 If we are given the struct directly (as our starting point) we
621 need to tell the debugger to:
623 1). Add the offset of the forwarding field.
625 2). Follow that pointer to get the real __Block_byref_x_VarName
626 struct to use (the real one may have been copied onto the heap).
628 3). Add the offset for the field VarName, to find the actual variable.
630 If we started with a pointer to the struct, then we need to
631 dereference that pointer first, before the other steps.
632 Translating this into DWARF ops, we will need to append the following
633 to the current location description for the variable:
635 DW_OP_deref -- optional, if we start with a pointer
636 DW_OP_plus_uconst <forward_fld_offset>
637 DW_OP_deref
638 DW_OP_plus_uconst <varName_fld_offset>
640 That is what this function does. */
642 /// addBlockByrefAddress - Start with the address based on the location
643 /// provided, and generate the DWARF information necessary to find the
644 /// actual Block variable (navigating the Block struct) based on the
645 /// starting location. Add the DWARF information to the die. For
646 /// more information, read large comment just above here.
647 ///
648 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
649 dwarf::Attribute Attribute,
650 const MachineLocation &Location) {
651 DIType Ty = DV.getType();
652 DIType TmpTy = Ty;
653 uint16_t Tag = Ty.getTag();
654 bool isPointer = false;
656 StringRef varName = DV.getName();
658 if (Tag == dwarf::DW_TAG_pointer_type) {
659 DIDerivedType DTy(Ty);
660 TmpTy = resolve(DTy.getTypeDerivedFrom());
661 isPointer = true;
662 }
664 DICompositeType blockStruct(TmpTy);
666 // Find the __forwarding field and the variable field in the __Block_byref
667 // struct.
668 DIArray Fields = blockStruct.getElements();
669 DIDerivedType varField;
670 DIDerivedType forwardingField;
672 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
673 DIDerivedType DT(Fields.getElement(i));
674 StringRef fieldName = DT.getName();
675 if (fieldName == "__forwarding")
676 forwardingField = DT;
677 else if (fieldName == varName)
678 varField = DT;
679 }
681 // Get the offsets for the forwarding field and the variable field.
682 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
683 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
685 // Decode the original location, and use that as the start of the byref
686 // variable's location.
687 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
689 if (Location.isReg())
690 addRegisterOpPiece(*Loc, Location.getReg());
691 else
692 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
694 // If we started with a pointer to the __Block_byref... struct, then
695 // the first thing we need to do is dereference the pointer (DW_OP_deref).
696 if (isPointer)
697 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
699 // Next add the offset for the '__forwarding' field:
700 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
701 // adding the offset if it's 0.
702 if (forwardingFieldOffset > 0) {
703 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
704 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
705 }
707 // Now dereference the __forwarding field to get to the real __Block_byref
708 // struct: DW_OP_deref.
709 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
711 // Now that we've got the real __Block_byref... struct, add the offset
712 // for the variable's field to get to the location of the actual variable:
713 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
714 if (varFieldOffset > 0) {
715 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
716 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
717 }
719 // Now attach the location information to the DIE.
720 addBlock(Die, Attribute, Loc);
721 }
723 /// Return true if type encoding is unsigned.
724 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
725 DIDerivedType DTy(Ty);
726 if (DTy.isDerivedType()) {
727 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
728 // Encode pointer constants as unsigned bytes. This is used at least for
729 // null pointer constant emission.
730 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
731 // here, but accept them for now due to a bug in SROA producing bogus
732 // dbg.values.
733 if (T == dwarf::DW_TAG_pointer_type ||
734 T == dwarf::DW_TAG_ptr_to_member_type ||
735 T == dwarf::DW_TAG_reference_type ||
736 T == dwarf::DW_TAG_rvalue_reference_type)
737 return true;
738 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
739 T == dwarf::DW_TAG_volatile_type ||
740 T == dwarf::DW_TAG_restrict_type ||
741 T == dwarf::DW_TAG_enumeration_type);
742 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
743 return isUnsignedDIType(DD, DD->resolve(Deriv));
744 // FIXME: Enums without a fixed underlying type have unknown signedness
745 // here, leading to incorrectly emitted constants.
746 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
747 return false;
748 }
750 DIBasicType BTy(Ty);
751 assert(BTy.isBasicType());
752 unsigned Encoding = BTy.getEncoding();
753 assert((Encoding == dwarf::DW_ATE_unsigned ||
754 Encoding == dwarf::DW_ATE_unsigned_char ||
755 Encoding == dwarf::DW_ATE_signed ||
756 Encoding == dwarf::DW_ATE_signed_char ||
757 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) &&
758 "Unsupported encoding");
759 return (Encoding == dwarf::DW_ATE_unsigned ||
760 Encoding == dwarf::DW_ATE_unsigned_char ||
761 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean);
762 }
764 /// If this type is derived from a base type then return base type size.
765 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
766 unsigned Tag = Ty.getTag();
768 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
769 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
770 Tag != dwarf::DW_TAG_restrict_type)
771 return Ty.getSizeInBits();
773 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
775 // If this type is not derived from any type or the type is a declaration then
776 // take conservative approach.
777 if (!BaseType.isValid() || BaseType.isForwardDecl())
778 return Ty.getSizeInBits();
780 // If this is a derived type, go ahead and get the base type, unless it's a
781 // reference then it's just the size of the field. Pointer types have no need
782 // of this since they're a different type of qualification on the type.
783 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
784 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
785 return Ty.getSizeInBits();
787 if (BaseType.isDerivedType())
788 return getBaseTypeSize(DD, DIDerivedType(BaseType));
790 return BaseType.getSizeInBits();
791 }
793 /// addConstantFPValue - Add constant value entry in variable DIE.
794 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
795 assert(MO.isFPImm() && "Invalid machine operand!");
796 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
797 APFloat FPImm = MO.getFPImm()->getValueAPF();
799 // Get the raw data form of the floating point.
800 const APInt FltVal = FPImm.bitcastToAPInt();
801 const char *FltPtr = (const char *)FltVal.getRawData();
803 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
804 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
805 int Incr = (LittleEndian ? 1 : -1);
806 int Start = (LittleEndian ? 0 : NumBytes - 1);
807 int Stop = (LittleEndian ? NumBytes : -1);
809 // Output the constant to DWARF one byte at a time.
810 for (; Start != Stop; Start += Incr)
811 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
813 addBlock(Die, dwarf::DW_AT_const_value, Block);
814 }
816 /// addConstantFPValue - Add constant value entry in variable DIE.
817 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
818 // Pass this down to addConstantValue as an unsigned bag of bits.
819 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
820 }
822 /// addConstantValue - Add constant value entry in variable DIE.
823 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
824 addConstantValue(Die, CI->getValue(), Ty);
825 }
827 /// addConstantValue - Add constant value entry in variable DIE.
828 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
829 DIType Ty) {
830 assert(MO.isImm() && "Invalid machine operand!");
832 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
833 }
835 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
836 // FIXME: This is a bit conservative/simple - it emits negative values always
837 // sign extended to 64 bits rather than minimizing the number of bytes.
838 addUInt(Die, dwarf::DW_AT_const_value,
839 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
840 }
842 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
843 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
844 }
846 // addConstantValue - Add constant value entry in variable DIE.
847 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
848 unsigned CIBitWidth = Val.getBitWidth();
849 if (CIBitWidth <= 64) {
850 addConstantValue(Die, Unsigned,
851 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
852 return;
853 }
855 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
857 // Get the raw data form of the large APInt.
858 const uint64_t *Ptr64 = Val.getRawData();
860 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
861 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
863 // Output the constant to DWARF one byte at a time.
864 for (int i = 0; i < NumBytes; i++) {
865 uint8_t c;
866 if (LittleEndian)
867 c = Ptr64[i / 8] >> (8 * (i & 7));
868 else
869 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
870 addUInt(*Block, dwarf::DW_FORM_data1, c);
871 }
873 addBlock(Die, dwarf::DW_AT_const_value, Block);
874 }
876 /// addTemplateParams - Add template parameters into buffer.
877 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
878 // Add template parameters.
879 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
880 DIDescriptor Element = TParams.getElement(i);
881 if (Element.isTemplateTypeParameter())
882 constructTemplateTypeParameterDIE(Buffer,
883 DITemplateTypeParameter(Element));
884 else if (Element.isTemplateValueParameter())
885 constructTemplateValueParameterDIE(Buffer,
886 DITemplateValueParameter(Element));
887 }
888 }
890 /// getOrCreateContextDIE - Get context owner's DIE.
891 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
892 if (!Context || Context.isFile())
893 return &getUnitDie();
894 if (Context.isType())
895 return getOrCreateTypeDIE(DIType(Context));
896 if (Context.isNameSpace())
897 return getOrCreateNameSpace(DINameSpace(Context));
898 if (Context.isSubprogram())
899 return getOrCreateSubprogramDIE(DISubprogram(Context));
900 return getDIE(Context);
901 }
903 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
904 DIScope Context = resolve(Ty.getContext());
905 DIE *ContextDIE = getOrCreateContextDIE(Context);
907 if (DIE *TyDIE = getDIE(Ty))
908 return TyDIE;
910 // Create new type.
911 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
913 constructTypeDIE(TyDIE, Ty);
915 updateAcceleratorTables(Context, Ty, TyDIE);
916 return &TyDIE;
917 }
919 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
920 /// given DIType.
921 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
922 if (!TyNode)
923 return nullptr;
925 DIType Ty(TyNode);
926 assert(Ty.isType());
927 assert(Ty == resolve(Ty.getRef()) &&
928 "type was not uniqued, possible ODR violation.");
930 // DW_TAG_restrict_type is not supported in DWARF2
931 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
932 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
934 // Construct the context before querying for the existence of the DIE in case
935 // such construction creates the DIE.
936 DIScope Context = resolve(Ty.getContext());
937 DIE *ContextDIE = getOrCreateContextDIE(Context);
938 assert(ContextDIE);
940 if (DIE *TyDIE = getDIE(Ty))
941 return TyDIE;
943 // Create new type.
944 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
946 updateAcceleratorTables(Context, Ty, TyDIE);
948 if (Ty.isBasicType())
949 constructTypeDIE(TyDIE, DIBasicType(Ty));
950 else if (Ty.isCompositeType()) {
951 DICompositeType CTy(Ty);
952 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
953 if (MDString *TypeId = CTy.getIdentifier()) {
954 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
955 // Skip updating the accelerator tables since this is not the full type.
956 return &TyDIE;
957 }
958 constructTypeDIE(TyDIE, CTy);
959 } else {
960 assert(Ty.isDerivedType() && "Unknown kind of DIType");
961 constructTypeDIE(TyDIE, DIDerivedType(Ty));
962 }
964 return &TyDIE;
965 }
967 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
968 const DIE &TyDIE) {
969 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
970 bool IsImplementation = 0;
971 if (Ty.isCompositeType()) {
972 DICompositeType CT(Ty);
973 // A runtime language of 0 actually means C/C++ and that any
974 // non-negative value is some version of Objective-C/C++.
975 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
976 }
977 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
978 DD->addAccelType(Ty.getName(), TyDIE, Flags);
980 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
981 Context.isNameSpace()) &&
982 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
983 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
984 &TyDIE;
985 }
986 }
988 /// addType - Add a new type attribute to the specified entity.
989 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
990 assert(Ty && "Trying to add a type that doesn't exist?");
992 // Check for pre-existence.
993 DIEEntry *Entry = getDIEEntry(Ty);
994 // If it exists then use the existing value.
995 if (Entry) {
996 addDIEEntry(Entity, Attribute, Entry);
997 return;
998 }
1000 // Construct type.
1001 DIE *Buffer = getOrCreateTypeDIE(Ty);
1003 // Set up proxy.
1004 Entry = createDIEEntry(*Buffer);
1005 insertDIEEntry(Ty, Entry);
1006 addDIEEntry(Entity, Attribute, Entry);
1007 }
1009 /// addGlobalName - Add a new global name to the compile unit.
1010 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1011 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1012 return;
1013 std::string FullName = getParentContextString(Context) + Name.str();
1014 GlobalNames[FullName] = &Die;
1015 }
1017 /// getParentContextString - Walks the metadata parent chain in a language
1018 /// specific manner (using the compile unit language) and returns
1019 /// it as a string. This is done at the metadata level because DIEs may
1020 /// not currently have been added to the parent context and walking the
1021 /// DIEs looking for names is more expensive than walking the metadata.
1022 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1023 if (!Context)
1024 return "";
1026 // FIXME: Decide whether to implement this for non-C++ languages.
1027 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1028 return "";
1030 std::string CS;
1031 SmallVector<DIScope, 1> Parents;
1032 while (!Context.isCompileUnit()) {
1033 Parents.push_back(Context);
1034 if (Context.getContext())
1035 Context = resolve(Context.getContext());
1036 else
1037 // Structure, etc types will have a NULL context if they're at the top
1038 // level.
1039 break;
1040 }
1042 // Reverse iterate over our list to go from the outermost construct to the
1043 // innermost.
1044 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1045 E = Parents.rend();
1046 I != E; ++I) {
1047 DIScope Ctx = *I;
1048 StringRef Name = Ctx.getName();
1049 if (Name.empty() && Ctx.isNameSpace())
1050 Name = "(anonymous namespace)";
1051 if (!Name.empty()) {
1052 CS += Name;
1053 CS += "::";
1054 }
1055 }
1056 return CS;
1057 }
1059 /// constructTypeDIE - Construct basic type die from DIBasicType.
1060 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1061 // Get core information.
1062 StringRef Name = BTy.getName();
1063 // Add name if not anonymous or intermediate type.
1064 if (!Name.empty())
1065 addString(Buffer, dwarf::DW_AT_name, Name);
1067 // An unspecified type only has a name attribute.
1068 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1069 return;
1071 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1072 BTy.getEncoding());
1074 uint64_t Size = BTy.getSizeInBits() >> 3;
1075 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1076 }
1078 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1079 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1080 // Get core information.
1081 StringRef Name = DTy.getName();
1082 uint64_t Size = DTy.getSizeInBits() >> 3;
1083 uint16_t Tag = Buffer.getTag();
1085 // Map to main type, void will not have a type.
1086 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1087 if (FromTy)
1088 addType(Buffer, FromTy);
1090 // Add name if not anonymous or intermediate type.
1091 if (!Name.empty())
1092 addString(Buffer, dwarf::DW_AT_name, Name);
1094 // Add size if non-zero (derived types might be zero-sized.)
1095 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1096 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1098 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1099 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1100 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1101 // Add source line info if available and TyDesc is not a forward declaration.
1102 if (!DTy.isForwardDecl())
1103 addSourceLine(Buffer, DTy);
1104 }
1106 /// constructSubprogramArguments - Construct function argument DIEs.
1107 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1108 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1109 DIType Ty = resolve(Args.getElement(i));
1110 if (!Ty) {
1111 assert(i == N-1 && "Unspecified parameter must be the last argument");
1112 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1113 } else {
1114 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1115 addType(Arg, DIType(Ty));
1116 if (DIType(Ty).isArtificial())
1117 addFlag(Arg, dwarf::DW_AT_artificial);
1118 }
1119 }
1120 }
1122 std::unique_ptr<DIE>
1123 DwarfUnit::constructImportedEntityDIE(const DIImportedEntity &Module) {
1124 assert(Module.Verify() &&
1125 "Use one of the MDNode * overloads to handle invalid metadata");
1126 std::unique_ptr<DIE> IMDie = make_unique<DIE>((dwarf::Tag)Module.getTag());
1127 insertDIE(Module, IMDie.get());
1128 DIE *EntityDie;
1129 DIDescriptor Entity = resolve(Module.getEntity());
1130 if (Entity.isNameSpace())
1131 EntityDie = getOrCreateNameSpace(DINameSpace(Entity));
1132 else if (Entity.isSubprogram())
1133 EntityDie = getOrCreateSubprogramDIE(DISubprogram(Entity));
1134 else if (Entity.isType())
1135 EntityDie = getOrCreateTypeDIE(DIType(Entity));
1136 else
1137 EntityDie = getDIE(Entity);
1138 assert(EntityDie);
1139 addSourceLine(*IMDie, Module.getLineNumber(),
1140 Module.getContext().getFilename(),
1141 Module.getContext().getDirectory());
1142 addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
1143 StringRef Name = Module.getName();
1144 if (!Name.empty())
1145 addString(*IMDie, dwarf::DW_AT_name, Name);
1147 return IMDie;
1148 }
1150 /// constructTypeDIE - Construct type DIE from DICompositeType.
1151 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1152 // Add name if not anonymous or intermediate type.
1153 StringRef Name = CTy.getName();
1155 uint64_t Size = CTy.getSizeInBits() >> 3;
1156 uint16_t Tag = Buffer.getTag();
1158 switch (Tag) {
1159 case dwarf::DW_TAG_array_type:
1160 constructArrayTypeDIE(Buffer, CTy);
1161 break;
1162 case dwarf::DW_TAG_enumeration_type:
1163 constructEnumTypeDIE(Buffer, CTy);
1164 break;
1165 case dwarf::DW_TAG_subroutine_type: {
1166 // Add return type. A void return won't have a type.
1167 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1168 DIType RTy(resolve(Elements.getElement(0)));
1169 if (RTy)
1170 addType(Buffer, RTy);
1172 bool isPrototyped = true;
1173 if (Elements.getNumElements() == 2 &&
1174 !Elements.getElement(1))
1175 isPrototyped = false;
1177 constructSubprogramArguments(Buffer, Elements);
1179 // Add prototype flag if we're dealing with a C language and the
1180 // function has been prototyped.
1181 uint16_t Language = getLanguage();
1182 if (isPrototyped &&
1183 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1184 Language == dwarf::DW_LANG_ObjC))
1185 addFlag(Buffer, dwarf::DW_AT_prototyped);
1187 if (CTy.isLValueReference())
1188 addFlag(Buffer, dwarf::DW_AT_reference);
1190 if (CTy.isRValueReference())
1191 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1192 } break;
1193 case dwarf::DW_TAG_structure_type:
1194 case dwarf::DW_TAG_union_type:
1195 case dwarf::DW_TAG_class_type: {
1196 // Add elements to structure type.
1197 DIArray Elements = CTy.getElements();
1198 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1199 DIDescriptor Element = Elements.getElement(i);
1200 if (Element.isSubprogram())
1201 getOrCreateSubprogramDIE(DISubprogram(Element));
1202 else if (Element.isDerivedType()) {
1203 DIDerivedType DDTy(Element);
1204 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1205 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1206 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1207 dwarf::DW_AT_friend);
1208 } else if (DDTy.isStaticMember()) {
1209 getOrCreateStaticMemberDIE(DDTy);
1210 } else {
1211 constructMemberDIE(Buffer, DDTy);
1212 }
1213 } else if (Element.isObjCProperty()) {
1214 DIObjCProperty Property(Element);
1215 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1216 StringRef PropertyName = Property.getObjCPropertyName();
1217 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1218 if (Property.getType())
1219 addType(ElemDie, Property.getType());
1220 addSourceLine(ElemDie, Property);
1221 StringRef GetterName = Property.getObjCPropertyGetterName();
1222 if (!GetterName.empty())
1223 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1224 StringRef SetterName = Property.getObjCPropertySetterName();
1225 if (!SetterName.empty())
1226 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1227 unsigned PropertyAttributes = 0;
1228 if (Property.isReadOnlyObjCProperty())
1229 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1230 if (Property.isReadWriteObjCProperty())
1231 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1232 if (Property.isAssignObjCProperty())
1233 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1234 if (Property.isRetainObjCProperty())
1235 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1236 if (Property.isCopyObjCProperty())
1237 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1238 if (Property.isNonAtomicObjCProperty())
1239 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1240 if (PropertyAttributes)
1241 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1242 PropertyAttributes);
1244 DIEEntry *Entry = getDIEEntry(Element);
1245 if (!Entry) {
1246 Entry = createDIEEntry(ElemDie);
1247 insertDIEEntry(Element, Entry);
1248 }
1249 } else
1250 continue;
1251 }
1253 if (CTy.isAppleBlockExtension())
1254 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1256 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1257 if (ContainingType)
1258 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1259 *getOrCreateTypeDIE(ContainingType));
1261 if (CTy.isObjcClassComplete())
1262 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1264 // Add template parameters to a class, structure or union types.
1265 // FIXME: The support isn't in the metadata for this yet.
1266 if (Tag == dwarf::DW_TAG_class_type ||
1267 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1268 addTemplateParams(Buffer, CTy.getTemplateParams());
1270 break;
1271 }
1272 default:
1273 break;
1274 }
1276 // Add name if not anonymous or intermediate type.
1277 if (!Name.empty())
1278 addString(Buffer, dwarf::DW_AT_name, Name);
1280 if (Tag == dwarf::DW_TAG_enumeration_type ||
1281 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1282 Tag == dwarf::DW_TAG_union_type) {
1283 // Add size if non-zero (derived types might be zero-sized.)
1284 // TODO: Do we care about size for enum forward declarations?
1285 if (Size)
1286 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1287 else if (!CTy.isForwardDecl())
1288 // Add zero size if it is not a forward declaration.
1289 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1291 // If we're a forward decl, say so.
1292 if (CTy.isForwardDecl())
1293 addFlag(Buffer, dwarf::DW_AT_declaration);
1295 // Add source line info if available.
1296 if (!CTy.isForwardDecl())
1297 addSourceLine(Buffer, CTy);
1299 // No harm in adding the runtime language to the declaration.
1300 unsigned RLang = CTy.getRunTimeLang();
1301 if (RLang)
1302 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1303 RLang);
1304 }
1305 }
1307 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1308 /// DITemplateTypeParameter.
1309 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1310 DITemplateTypeParameter TP) {
1311 DIE &ParamDIE =
1312 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1313 // Add the type if it exists, it could be void and therefore no type.
1314 if (TP.getType())
1315 addType(ParamDIE, resolve(TP.getType()));
1316 if (!TP.getName().empty())
1317 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1318 }
1320 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1321 /// DITemplateValueParameter.
1322 void
1323 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1324 DITemplateValueParameter VP) {
1325 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1327 // Add the type if there is one, template template and template parameter
1328 // packs will not have a type.
1329 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1330 addType(ParamDIE, resolve(VP.getType()));
1331 if (!VP.getName().empty())
1332 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1333 if (Value *Val = VP.getValue()) {
1334 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1335 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1336 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1337 // For declaration non-type template parameters (such as global values and
1338 // functions)
1339 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1340 addOpAddress(*Loc, Asm->getSymbol(GV));
1341 // Emit DW_OP_stack_value to use the address as the immediate value of the
1342 // parameter, rather than a pointer to it.
1343 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1344 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1345 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1346 assert(isa<MDString>(Val));
1347 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1348 cast<MDString>(Val)->getString());
1349 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1350 assert(isa<MDNode>(Val));
1351 DIArray A(cast<MDNode>(Val));
1352 addTemplateParams(ParamDIE, A);
1353 }
1354 }
1355 }
1357 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1358 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1359 // Construct the context before querying for the existence of the DIE in case
1360 // such construction creates the DIE.
1361 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1363 if (DIE *NDie = getDIE(NS))
1364 return NDie;
1365 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1367 StringRef Name = NS.getName();
1368 if (!Name.empty())
1369 addString(NDie, dwarf::DW_AT_name, NS.getName());
1370 else
1371 Name = "(anonymous namespace)";
1372 DD->addAccelNamespace(Name, NDie);
1373 addGlobalName(Name, NDie, NS.getContext());
1374 addSourceLine(NDie, NS);
1375 return &NDie;
1376 }
1378 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1379 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1380 // Construct the context before querying for the existence of the DIE in case
1381 // such construction creates the DIE (as is the case for member function
1382 // declarations).
1383 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1385 if (DIE *SPDie = getDIE(SP))
1386 return SPDie;
1388 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1389 // Add subprogram definitions to the CU die directly.
1390 ContextDIE = &getUnitDie();
1391 // Build the decl now to ensure it precedes the definition.
1392 getOrCreateSubprogramDIE(SPDecl);
1393 }
1395 // DW_TAG_inlined_subroutine may refer to this DIE.
1396 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1398 // Stop here and fill this in later, depending on whether or not this
1399 // subprogram turns out to have inlined instances or not.
1400 if (SP.isDefinition())
1401 return &SPDie;
1403 applySubprogramAttributes(SP, SPDie);
1404 return &SPDie;
1405 }
1407 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) {
1408 DISubprogram SPDecl = SP.getFunctionDeclaration();
1409 DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
1410 applySubprogramAttributes(SP, SPDie);
1411 addGlobalName(SP.getName(), SPDie, Context);
1412 }
1414 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1415 DIE *DeclDie = nullptr;
1416 StringRef DeclLinkageName;
1417 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1418 DeclDie = getDIE(SPDecl);
1419 assert(DeclDie && "This DIE should've already been constructed when the "
1420 "definition DIE was created in "
1421 "getOrCreateSubprogramDIE");
1422 DeclLinkageName = SPDecl.getLinkageName();
1423 }
1425 // Add function template parameters.
1426 addTemplateParams(SPDie, SP.getTemplateParams());
1428 // Add the linkage name if we have one and it isn't in the Decl.
1429 StringRef LinkageName = SP.getLinkageName();
1430 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1431 LinkageName == DeclLinkageName) &&
1432 "decl has a linkage name and it is different");
1433 if (!LinkageName.empty() && DeclLinkageName.empty())
1434 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1435 GlobalValue::getRealLinkageName(LinkageName));
1437 if (DeclDie) {
1438 // Refer to the function declaration where all the other attributes will be
1439 // found.
1440 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1441 return;
1442 }
1444 // Constructors and operators for anonymous aggregates do not have names.
1445 if (!SP.getName().empty())
1446 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1448 // Skip the rest of the attributes under -gmlt to save space.
1449 if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1450 return;
1452 addSourceLine(SPDie, SP);
1454 // Add the prototype if we have a prototype and we have a C like
1455 // language.
1456 uint16_t Language = getLanguage();
1457 if (SP.isPrototyped() &&
1458 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1459 Language == dwarf::DW_LANG_ObjC))
1460 addFlag(SPDie, dwarf::DW_AT_prototyped);
1462 DISubroutineType SPTy = SP.getType();
1463 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1464 "the type of a subprogram should be a subroutine");
1466 DITypeArray Args = SPTy.getTypeArray();
1467 // Add a return type. If this is a type like a C/C++ void type we don't add a
1468 // return type.
1469 if (resolve(Args.getElement(0)))
1470 addType(SPDie, DIType(resolve(Args.getElement(0))));
1472 unsigned VK = SP.getVirtuality();
1473 if (VK) {
1474 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1475 DIELoc *Block = getDIELoc();
1476 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1477 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1478 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1479 ContainingTypeMap.insert(
1480 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1481 }
1483 if (!SP.isDefinition()) {
1484 addFlag(SPDie, dwarf::DW_AT_declaration);
1486 // Add arguments. Do not add arguments for subprogram definition. They will
1487 // be handled while processing variables.
1488 constructSubprogramArguments(SPDie, Args);
1489 }
1491 if (SP.isArtificial())
1492 addFlag(SPDie, dwarf::DW_AT_artificial);
1494 if (!SP.isLocalToUnit())
1495 addFlag(SPDie, dwarf::DW_AT_external);
1497 if (SP.isOptimized())
1498 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1500 if (unsigned isa = Asm->getISAEncoding()) {
1501 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1502 }
1504 if (SP.isLValueReference())
1505 addFlag(SPDie, dwarf::DW_AT_reference);
1507 if (SP.isRValueReference())
1508 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1510 if (SP.isProtected())
1511 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1512 dwarf::DW_ACCESS_protected);
1513 else if (SP.isPrivate())
1514 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1515 dwarf::DW_ACCESS_private);
1516 else if (SP.isPublic())
1517 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1518 dwarf::DW_ACCESS_public);
1520 if (SP.isExplicit())
1521 addFlag(SPDie, dwarf::DW_AT_explicit);
1522 }
1524 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var,
1525 DIE &VariableDie) {
1526 StringRef Name = Var.getName();
1527 if (!Name.empty())
1528 addString(VariableDie, dwarf::DW_AT_name, Name);
1529 addSourceLine(VariableDie, Var.getVariable());
1530 addType(VariableDie, Var.getType());
1531 if (Var.isArtificial())
1532 addFlag(VariableDie, dwarf::DW_AT_artificial);
1533 }
1535 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1536 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1537 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1538 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1540 // The LowerBound value defines the lower bounds which is typically zero for
1541 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1542 // Count == -1 then the array is unbounded and we do not emit
1543 // DW_AT_lower_bound and DW_AT_count attributes.
1544 int64_t LowerBound = SR.getLo();
1545 int64_t DefaultLowerBound = getDefaultLowerBound();
1546 int64_t Count = SR.getCount();
1548 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1549 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1551 if (Count != -1)
1552 // FIXME: An unbounded array should reference the expression that defines
1553 // the array.
1554 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1555 }
1557 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1558 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1559 if (CTy.isVector())
1560 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1562 // Emit the element type.
1563 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1565 // Get an anonymous type for index type.
1566 // FIXME: This type should be passed down from the front end
1567 // as different languages may have different sizes for indexes.
1568 DIE *IdxTy = getIndexTyDie();
1569 if (!IdxTy) {
1570 // Construct an integer type to use for indexes.
1571 IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1572 addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1573 addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1574 addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1575 dwarf::DW_ATE_unsigned);
1576 setIndexTyDie(IdxTy);
1577 }
1579 // Add subranges to array type.
1580 DIArray Elements = CTy.getElements();
1581 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1582 DIDescriptor Element = Elements.getElement(i);
1583 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1584 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1585 }
1586 }
1588 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1589 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1590 DIArray Elements = CTy.getElements();
1592 // Add enumerators to enumeration type.
1593 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1594 DIEnumerator Enum(Elements.getElement(i));
1595 if (Enum.isEnumerator()) {
1596 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1597 StringRef Name = Enum.getName();
1598 addString(Enumerator, dwarf::DW_AT_name, Name);
1599 int64_t Value = Enum.getEnumValue();
1600 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1601 Value);
1602 }
1603 }
1604 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1605 if (DTy) {
1606 addType(Buffer, DTy);
1607 addFlag(Buffer, dwarf::DW_AT_enum_class);
1608 }
1609 }
1611 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1612 /// vtables.
1613 void DwarfUnit::constructContainingTypeDIEs() {
1614 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1615 CE = ContainingTypeMap.end();
1616 CI != CE; ++CI) {
1617 DIE &SPDie = *CI->first;
1618 DIDescriptor D(CI->second);
1619 if (!D)
1620 continue;
1621 DIE *NDie = getDIE(D);
1622 if (!NDie)
1623 continue;
1624 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1625 }
1626 }
1628 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1629 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
1630 bool Abstract) {
1631 auto D = constructVariableDIEImpl(DV, Abstract);
1632 DV.setDIE(*D);
1633 return D;
1634 }
1636 std::unique_ptr<DIE> DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
1637 bool Abstract) {
1638 // Define variable debug information entry.
1639 auto VariableDie = make_unique<DIE>(DV.getTag());
1641 if (Abstract) {
1642 applyVariableAttributes(DV, *VariableDie);
1643 return VariableDie;
1644 }
1646 // Add variable address.
1648 unsigned Offset = DV.getDotDebugLocOffset();
1649 if (Offset != ~0U) {
1650 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
1651 return VariableDie;
1652 }
1654 // Check if variable is described by a DBG_VALUE instruction.
1655 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1656 assert(DVInsn->getNumOperands() == 4);
1657 if (DVInsn->getOperand(0).isReg()) {
1658 const MachineOperand RegOp = DVInsn->getOperand(0);
1659 // If the second operand is an immediate, this is an indirect value.
1660 if (DVInsn->getOperand(1).isImm()) {
1661 MachineLocation Location(RegOp.getReg(),
1662 DVInsn->getOperand(1).getImm());
1663 addVariableAddress(DV, *VariableDie, Location);
1664 } else if (RegOp.getReg())
1665 addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
1666 } else if (DVInsn->getOperand(0).isImm())
1667 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
1668 else if (DVInsn->getOperand(0).isFPImm())
1669 addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
1670 else if (DVInsn->getOperand(0).isCImm())
1671 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
1672 DV.getType());
1674 return VariableDie;
1675 }
1677 // .. else use frame index.
1678 int FI = DV.getFrameIndex();
1679 if (FI != ~0) {
1680 unsigned FrameReg = 0;
1681 const TargetFrameLowering *TFI =
1682 Asm->TM.getSubtargetImpl()->getFrameLowering();
1683 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1684 MachineLocation Location(FrameReg, Offset);
1685 addVariableAddress(DV, *VariableDie, Location);
1686 }
1688 return VariableDie;
1689 }
1691 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1692 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1693 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1694 StringRef Name = DT.getName();
1695 if (!Name.empty())
1696 addString(MemberDie, dwarf::DW_AT_name, Name);
1698 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1700 addSourceLine(MemberDie, DT);
1702 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1704 // For C++, virtual base classes are not at fixed offset. Use following
1705 // expression to extract appropriate offset from vtable.
1706 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1708 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1709 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1710 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1711 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1712 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1713 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1714 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1715 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1717 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1718 } else {
1719 uint64_t Size = DT.getSizeInBits();
1720 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1721 uint64_t OffsetInBytes;
1723 if (Size != FieldSize) {
1724 // Handle bitfield, assume bytes are 8 bits.
1725 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1726 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1728 uint64_t Offset = DT.getOffsetInBits();
1729 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1730 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1731 uint64_t FieldOffset = (HiMark - FieldSize);
1732 Offset -= FieldOffset;
1734 // Maybe we need to work from the other end.
1735 if (Asm->getDataLayout().isLittleEndian())
1736 Offset = FieldSize - (Offset + Size);
1737 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1739 // Here DW_AT_data_member_location points to the anonymous
1740 // field that includes this bit field.
1741 OffsetInBytes = FieldOffset >> 3;
1742 } else
1743 // This is not a bitfield.
1744 OffsetInBytes = DT.getOffsetInBits() >> 3;
1746 if (DD->getDwarfVersion() <= 2) {
1747 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1748 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1749 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1750 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1751 } else
1752 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1753 OffsetInBytes);
1754 }
1756 if (DT.isProtected())
1757 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1758 dwarf::DW_ACCESS_protected);
1759 else if (DT.isPrivate())
1760 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1761 dwarf::DW_ACCESS_private);
1762 // Otherwise C++ member and base classes are considered public.
1763 else if (DT.isPublic())
1764 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1765 dwarf::DW_ACCESS_public);
1766 if (DT.isVirtual())
1767 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1768 dwarf::DW_VIRTUALITY_virtual);
1770 // Objective-C properties.
1771 if (MDNode *PNode = DT.getObjCProperty())
1772 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1773 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1774 PropertyDie);
1776 if (DT.isArtificial())
1777 addFlag(MemberDie, dwarf::DW_AT_artificial);
1778 }
1780 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1781 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1782 if (!DT.Verify())
1783 return nullptr;
1785 // Construct the context before querying for the existence of the DIE in case
1786 // such construction creates the DIE.
1787 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1788 assert(dwarf::isType(ContextDIE->getTag()) &&
1789 "Static member should belong to a type.");
1791 if (DIE *StaticMemberDIE = getDIE(DT))
1792 return StaticMemberDIE;
1794 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1796 DIType Ty = resolve(DT.getTypeDerivedFrom());
1798 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1799 addType(StaticMemberDIE, Ty);
1800 addSourceLine(StaticMemberDIE, DT);
1801 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1802 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1804 // FIXME: We could omit private if the parent is a class_type, and
1805 // public if the parent is something else.
1806 if (DT.isProtected())
1807 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1808 dwarf::DW_ACCESS_protected);
1809 else if (DT.isPrivate())
1810 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1811 dwarf::DW_ACCESS_private);
1812 else if (DT.isPublic())
1813 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1814 dwarf::DW_ACCESS_public);
1816 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1817 addConstantValue(StaticMemberDIE, CI, Ty);
1818 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1819 addConstantFPValue(StaticMemberDIE, CFP);
1821 return &StaticMemberDIE;
1822 }
1824 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1825 Asm->OutStreamer.AddComment("DWARF version number");
1826 Asm->EmitInt16(DD->getDwarfVersion());
1827 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1828 // We share one abbreviations table across all units so it's always at the
1829 // start of the section. Use a relocatable offset where needed to ensure
1830 // linking doesn't invalidate that offset.
1831 if (ASectionSym)
1832 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1833 else
1834 // Use a constant value when no symbol is provided.
1835 Asm->EmitInt32(0);
1836 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1837 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1838 }
1840 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1841 DwarfUnit::emitHeader(ASectionSym);
1842 Asm->OutStreamer.AddComment("Type Signature");
1843 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1844 Asm->OutStreamer.AddComment("Type DIE Offset");
1845 // In a skeleton type unit there is no type DIE so emit a zero offset.
1846 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1847 sizeof(Ty->getOffset()));
1848 }
1850 void DwarfTypeUnit::initSection(const MCSection *Section) {
1851 assert(!this->Section);
1852 this->Section = Section;
1853 // Since each type unit is contained in its own COMDAT section, the begin
1854 // label and the section label are the same. Using the begin label emission in
1855 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
1856 // the only other alternative of lazily constructing start-of-section labels
1857 // and storing a mapping in DwarfDebug (or AsmPrinter).
1858 this->SectionSym = this->LabelBegin =
1859 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
1860 this->LabelEnd =
1861 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
1862 }