1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for constructing a dwarf compile unit.
12 //===----------------------------------------------------------------------===//
14 #include "DwarfUnit.h"
15 #include "DwarfAccelTable.h"
16 #include "DwarfDebug.h"
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DIBuilder.h"
20 #include "llvm/IR/DataLayout.h"
21 #include "llvm/IR/GlobalVariable.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/IR/Mangler.h"
24 #include "llvm/MC/MCAsmInfo.h"
25 #include "llvm/MC/MCContext.h"
26 #include "llvm/MC/MCSection.h"
27 #include "llvm/MC/MCStreamer.h"
28 #include "llvm/Support/CommandLine.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
36 #define DEBUG_TYPE "dwarfdebug"
39 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
40 cl::desc("Generate DWARF4 type units."),
43 /// Unit - Unit constructor.
44 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
45 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
46 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
47 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr),
49 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
50 UnitTag == dwarf::DW_TAG_type_unit);
51 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
54 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DICompileUnit Node,
55 AsmPrinter *A, DwarfDebug *DW,
57 : DwarfUnit(UID, dwarf::DW_TAG_compile_unit, Node, A, DW, DWU) {
58 insertDIE(Node, &getUnitDie());
61 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
62 DwarfDebug *DW, DwarfFile *DWU,
63 MCDwarfDwoLineTable *SplitLineTable)
64 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
65 CU(CU), SplitLineTable(SplitLineTable) {
67 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
70 /// ~Unit - Destructor for compile unit.
71 DwarfUnit::~DwarfUnit() {
72 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
73 DIEBlocks[j]->~DIEBlock();
74 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
75 DIELocs[j]->~DIELoc();
78 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
79 /// information entry.
80 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
81 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
85 /// getDefaultLowerBound - Return the default lower bound for an array. If the
86 /// DWARF version doesn't handle the language, return -1.
87 int64_t DwarfUnit::getDefaultLowerBound() const {
88 switch (getLanguage()) {
92 case dwarf::DW_LANG_C89:
93 case dwarf::DW_LANG_C99:
94 case dwarf::DW_LANG_C:
95 case dwarf::DW_LANG_C_plus_plus:
96 case dwarf::DW_LANG_ObjC:
97 case dwarf::DW_LANG_ObjC_plus_plus:
100 case dwarf::DW_LANG_Fortran77:
101 case dwarf::DW_LANG_Fortran90:
102 case dwarf::DW_LANG_Fortran95:
105 // The languages below have valid values only if the DWARF version >= 4.
106 case dwarf::DW_LANG_Java:
107 case dwarf::DW_LANG_Python:
108 case dwarf::DW_LANG_UPC:
109 case dwarf::DW_LANG_D:
110 if (dwarf::DWARF_VERSION >= 4)
114 case dwarf::DW_LANG_Ada83:
115 case dwarf::DW_LANG_Ada95:
116 case dwarf::DW_LANG_Cobol74:
117 case dwarf::DW_LANG_Cobol85:
118 case dwarf::DW_LANG_Modula2:
119 case dwarf::DW_LANG_Pascal83:
120 case dwarf::DW_LANG_PLI:
121 if (dwarf::DWARF_VERSION >= 4)
129 /// Check whether the DIE for this MDNode can be shared across CUs.
130 static bool isShareableAcrossCUs(DIDescriptor D) {
131 // When the MDNode can be part of the type system, the DIE can be shared
133 // Combining type units and cross-CU DIE sharing is lower value (since
134 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
135 // level already) but may be implementable for some value in projects
136 // building multiple independent libraries with LTO and then linking those
138 return (D.isType() ||
139 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
140 !GenerateDwarfTypeUnits;
143 /// getDIE - Returns the debug information entry map slot for the
144 /// specified debug variable. We delegate the request to DwarfDebug
145 /// when the DIE for this MDNode can be shared across CUs. The mappings
146 /// will be kept in DwarfDebug for shareable DIEs.
147 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
148 if (isShareableAcrossCUs(D))
149 return DD->getDIE(D);
150 return MDNodeToDieMap.lookup(D);
153 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
154 /// when the DIE for this MDNode can be shared across CUs. The mappings
155 /// will be kept in DwarfDebug for shareable DIEs.
156 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
157 if (isShareableAcrossCUs(Desc)) {
158 DD->insertDIE(Desc, D);
161 MDNodeToDieMap.insert(std::make_pair(Desc, D));
164 /// addFlag - Add a flag that is true.
165 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
166 if (DD->getDwarfVersion() >= 4)
167 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
169 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
172 /// addUInt - Add an unsigned integer attribute data and value.
174 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
175 Optional<dwarf::Form> Form, uint64_t Integer) {
177 Form = DIEInteger::BestForm(false, Integer);
178 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
180 Die.addValue(Attribute, *Form, Value);
183 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
184 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
187 /// addSInt - Add an signed integer attribute data and value.
189 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
190 Optional<dwarf::Form> Form, int64_t Integer) {
192 Form = DIEInteger::BestForm(true, Integer);
193 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
194 Die.addValue(Attribute, *Form, Value);
197 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
199 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
202 /// addString - Add a string attribute data and value. We always emit a
203 /// reference to the string pool instead of immediate strings so that DIEs have
204 /// more predictable sizes. In the case of split dwarf we emit an index
205 /// into another table which gets us the static offset into the string
207 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
210 if (!DD->useSplitDwarf())
211 return addLocalString(Die, Attribute, String);
213 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
214 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
215 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
216 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
219 /// addLocalString - Add a string attribute data and value. This is guaranteed
220 /// to be in the local string pool instead of indirected.
221 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
223 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
225 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
226 Value = new (DIEValueAllocator) DIELabel(Symb);
228 MCSymbol *StringPool = DU->getStringPool().getSectionSymbol();
229 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
231 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
232 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
235 /// addExpr - Add a Dwarf expression attribute data and value.
237 void DwarfUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) {
238 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
239 Die.addValue((dwarf::Attribute)0, Form, Value);
242 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
244 void DwarfUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
246 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
247 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
248 : dwarf::DW_FORM_data4;
249 Die.addValue(Attribute, Form, Value);
252 /// addLabel - Add a Dwarf label attribute data and value.
254 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
255 const MCSymbol *Label) {
256 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
257 Die.addValue(Attribute, Form, Value);
260 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
261 addLabel(Die, (dwarf::Attribute)0, Form, Label);
264 /// addSectionLabel - Add a Dwarf section label attribute data and value.
266 void DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
267 const MCSymbol *Label) {
268 if (DD->getDwarfVersion() >= 4)
269 addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
271 addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
274 /// addSectionOffset - Add an offset into a section attribute data and value.
276 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
278 if (DD->getDwarfVersion() >= 4)
279 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
281 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
284 /// addLabelAddress - Add a dwarf label attribute data and value using
285 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
287 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
288 const MCSymbol *Label) {
290 if (!DD->useSplitDwarf())
291 return addLocalLabelAddress(Die, Attribute, Label);
294 DD->addArangeLabel(SymbolCU(this, Label));
296 unsigned idx = DD->getAddressPool().getIndex(Label);
297 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
298 Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
301 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
302 dwarf::Attribute Attribute,
303 const MCSymbol *Label) {
305 DD->addArangeLabel(SymbolCU(this, Label));
307 Die.addValue(Attribute, dwarf::DW_FORM_addr,
308 Label ? (DIEValue *)new (DIEValueAllocator) DIELabel(Label)
309 : new (DIEValueAllocator) DIEInteger(0));
312 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
313 // If we print assembly, we can't separate .file entries according to
314 // compile units. Thus all files will belong to the default compile unit.
316 // FIXME: add a better feature test than hasRawTextSupport. Even better,
317 // extend .file to support this.
318 return Asm->OutStreamer.EmitDwarfFileDirective(
319 0, DirName, FileName,
320 Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID());
323 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
324 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
325 : getCU().getOrCreateSourceID(FileName, DirName);
328 /// addOpAddress - Add a dwarf op address data and value using the
329 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
331 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
332 if (!DD->useSplitDwarf()) {
333 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
334 addLabel(Die, dwarf::DW_FORM_udata, Sym);
336 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
337 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
338 DD->getAddressPool().getIndex(Sym));
342 /// addSectionDelta - Add a section label delta attribute data and value.
344 void DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
345 const MCSymbol *Hi, const MCSymbol *Lo) {
346 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
347 Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
348 : dwarf::DW_FORM_data4,
352 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
353 const MCSymbol *Hi, const MCSymbol *Lo) {
354 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
355 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
358 /// addDIEEntry - Add a DIE attribute data and value.
360 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
361 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
364 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
365 // Flag the type unit reference as a declaration so that if it contains
366 // members (implicit special members, static data member definitions, member
367 // declarations for definitions in this CU, etc) consumers don't get confused
368 // and think this is a full definition.
369 addFlag(Die, dwarf::DW_AT_declaration);
371 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
372 new (DIEValueAllocator) DIETypeSignature(Type));
375 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
377 const DIE *DieCU = Die.getUnitOrNull();
378 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
380 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
381 DieCU = &getUnitDie();
383 EntryCU = &getUnitDie();
384 Die.addValue(Attribute,
385 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
389 /// Create a DIE with the given Tag, add the DIE to its parent, and
390 /// call insertDIE if MD is not null.
391 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
392 assert(Tag != dwarf::DW_TAG_auto_variable &&
393 Tag != dwarf::DW_TAG_arg_variable);
394 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
395 DIE &Die = *Parent.getChildren().back();
401 /// addBlock - Add block data.
403 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
404 Loc->ComputeSize(Asm);
405 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
406 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
409 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
411 Block->ComputeSize(Asm);
412 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
413 Die.addValue(Attribute, Block->BestForm(), Block);
416 /// addSourceLine - Add location information to specified debug information
418 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
419 StringRef Directory) {
423 unsigned FileID = getOrCreateSourceID(File, Directory);
424 assert(FileID && "Invalid file id");
425 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
426 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
429 /// addSourceLine - Add location information to specified debug information
431 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
432 assert(V.isVariable());
434 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
435 V.getContext().getDirectory());
438 /// addSourceLine - Add location information to specified debug information
440 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
441 assert(G.isGlobalVariable());
443 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
446 /// addSourceLine - Add location information to specified debug information
448 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
449 assert(SP.isSubprogram());
451 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
454 /// addSourceLine - Add location information to specified debug information
456 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
459 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
462 /// addSourceLine - Add location information to specified debug information
464 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
465 assert(Ty.isObjCProperty());
467 DIFile File = Ty.getFile();
468 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
469 File.getDirectory());
472 /// addSourceLine - Add location information to specified debug information
474 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
477 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
480 /// addVariableAddress - Add DW_AT_location attribute for a
481 /// DbgVariable based on provided MachineLocation.
482 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
483 MachineLocation Location) {
484 if (DV.variableHasComplexAddress())
485 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
486 else if (DV.isBlockByrefVariable())
487 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
489 addAddress(Die, dwarf::DW_AT_location, Location,
490 DV.getVariable().isIndirect());
493 /// addRegisterOp - Add register operand.
494 void DwarfUnit::addRegisterOp(DIELoc &TheDie, unsigned Reg) {
495 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
496 int DWReg = RI->getDwarfRegNum(Reg, false);
497 bool isSubRegister = DWReg < 0;
501 // Go up the super-register chain until we hit a valid dwarf register number.
502 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
503 DWReg = RI->getDwarfRegNum(*SR, false);
505 Idx = RI->getSubRegIndex(*SR, Reg);
509 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
510 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
516 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
518 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
519 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
524 unsigned Size = RI->getSubRegIdxSize(Idx);
525 unsigned Offset = RI->getSubRegIdxOffset(Idx);
527 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
528 addUInt(TheDie, dwarf::DW_FORM_data1, Size);
529 addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
531 unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
532 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
533 addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
538 /// addRegisterOffset - Add register offset.
539 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
541 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
542 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
543 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
544 if (Reg == TRI->getFrameRegister(*Asm->MF))
545 // If variable offset is based in frame register then use fbreg.
546 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
548 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
550 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
551 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
553 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
556 /// addAddress - Add an address attribute to a die based on the location
558 void DwarfUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
559 const MachineLocation &Location, bool Indirect) {
560 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
562 if (Location.isReg() && !Indirect)
563 addRegisterOp(*Loc, Location.getReg());
565 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
566 if (Indirect && !Location.isReg()) {
567 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
571 // Now attach the location information to the DIE.
572 addBlock(Die, Attribute, Loc);
575 /// addComplexAddress - Start with the address based on the location provided,
576 /// and generate the DWARF information necessary to find the actual variable
577 /// given the extra address information encoded in the DbgVariable, starting
578 /// from the starting location. Add the DWARF information to the die.
580 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
581 dwarf::Attribute Attribute,
582 const MachineLocation &Location) {
583 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
584 unsigned N = DV.getNumAddrElements();
586 if (Location.isReg()) {
587 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
588 // If first address element is OpPlus then emit
589 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
590 addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1));
593 addRegisterOp(*Loc, Location.getReg());
595 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
598 uint64_t Element = DV.getAddrElement(i);
599 if (Element == DIBuilder::OpPlus) {
600 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
601 addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
602 } else if (Element == DIBuilder::OpDeref) {
603 if (!Location.isReg())
604 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
606 llvm_unreachable("unknown DIBuilder Opcode");
609 // Now attach the location information to the DIE.
610 addBlock(Die, Attribute, Loc);
613 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
614 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
615 gives the variable VarName either the struct, or a pointer to the struct, as
616 its type. This is necessary for various behind-the-scenes things the
617 compiler needs to do with by-reference variables in Blocks.
619 However, as far as the original *programmer* is concerned, the variable
620 should still have type 'SomeType', as originally declared.
622 The function getBlockByrefType dives into the __Block_byref_x_VarName
623 struct to find the original type of the variable, which is then assigned to
624 the variable's Debug Information Entry as its real type. So far, so good.
625 However now the debugger will expect the variable VarName to have the type
626 SomeType. So we need the location attribute for the variable to be an
627 expression that explains to the debugger how to navigate through the
628 pointers and struct to find the actual variable of type SomeType.
630 The following function does just that. We start by getting
631 the "normal" location for the variable. This will be the location
632 of either the struct __Block_byref_x_VarName or the pointer to the
633 struct __Block_byref_x_VarName.
635 The struct will look something like:
637 struct __Block_byref_x_VarName {
639 struct __Block_byref_x_VarName *forwarding;
640 ... <various other fields>
642 ... <maybe more fields>
645 If we are given the struct directly (as our starting point) we
646 need to tell the debugger to:
648 1). Add the offset of the forwarding field.
650 2). Follow that pointer to get the real __Block_byref_x_VarName
651 struct to use (the real one may have been copied onto the heap).
653 3). Add the offset for the field VarName, to find the actual variable.
655 If we started with a pointer to the struct, then we need to
656 dereference that pointer first, before the other steps.
657 Translating this into DWARF ops, we will need to append the following
658 to the current location description for the variable:
660 DW_OP_deref -- optional, if we start with a pointer
661 DW_OP_plus_uconst <forward_fld_offset>
663 DW_OP_plus_uconst <varName_fld_offset>
665 That is what this function does. */
667 /// addBlockByrefAddress - Start with the address based on the location
668 /// provided, and generate the DWARF information necessary to find the
669 /// actual Block variable (navigating the Block struct) based on the
670 /// starting location. Add the DWARF information to the die. For
671 /// more information, read large comment just above here.
673 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
674 dwarf::Attribute Attribute,
675 const MachineLocation &Location) {
676 DIType Ty = DV.getType();
678 uint16_t Tag = Ty.getTag();
679 bool isPointer = false;
681 StringRef varName = DV.getName();
683 if (Tag == dwarf::DW_TAG_pointer_type) {
684 DIDerivedType DTy(Ty);
685 TmpTy = resolve(DTy.getTypeDerivedFrom());
689 DICompositeType blockStruct(TmpTy);
691 // Find the __forwarding field and the variable field in the __Block_byref
693 DIArray Fields = blockStruct.getTypeArray();
694 DIDerivedType varField;
695 DIDerivedType forwardingField;
697 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
698 DIDerivedType DT(Fields.getElement(i));
699 StringRef fieldName = DT.getName();
700 if (fieldName == "__forwarding")
701 forwardingField = DT;
702 else if (fieldName == varName)
706 // Get the offsets for the forwarding field and the variable field.
707 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
708 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
710 // Decode the original location, and use that as the start of the byref
711 // variable's location.
712 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
714 if (Location.isReg())
715 addRegisterOp(*Loc, Location.getReg());
717 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
719 // If we started with a pointer to the __Block_byref... struct, then
720 // the first thing we need to do is dereference the pointer (DW_OP_deref).
722 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
724 // Next add the offset for the '__forwarding' field:
725 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
726 // adding the offset if it's 0.
727 if (forwardingFieldOffset > 0) {
728 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
729 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
732 // Now dereference the __forwarding field to get to the real __Block_byref
733 // struct: DW_OP_deref.
734 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
736 // Now that we've got the real __Block_byref... struct, add the offset
737 // for the variable's field to get to the location of the actual variable:
738 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
739 if (varFieldOffset > 0) {
740 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
741 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
744 // Now attach the location information to the DIE.
745 addBlock(Die, Attribute, Loc);
748 /// Return true if type encoding is unsigned.
749 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
750 DIDerivedType DTy(Ty);
751 if (DTy.isDerivedType()) {
752 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
753 // Encode pointer constants as unsigned bytes. This is used at least for
754 // null pointer constant emission.
755 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
756 // here, but accept them for now due to a bug in SROA producing bogus
758 if (T == dwarf::DW_TAG_pointer_type ||
759 T == dwarf::DW_TAG_ptr_to_member_type ||
760 T == dwarf::DW_TAG_reference_type ||
761 T == dwarf::DW_TAG_rvalue_reference_type)
763 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
764 T == dwarf::DW_TAG_volatile_type ||
765 T == dwarf::DW_TAG_restrict_type ||
766 T == dwarf::DW_TAG_enumeration_type);
767 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
768 return isUnsignedDIType(DD, DD->resolve(Deriv));
769 // FIXME: Enums without a fixed underlying type have unknown signedness
770 // here, leading to incorrectly emitted constants.
771 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
776 assert(BTy.isBasicType());
777 unsigned Encoding = BTy.getEncoding();
778 assert((Encoding == dwarf::DW_ATE_unsigned ||
779 Encoding == dwarf::DW_ATE_unsigned_char ||
780 Encoding == dwarf::DW_ATE_signed ||
781 Encoding == dwarf::DW_ATE_signed_char ||
782 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) &&
783 "Unsupported encoding");
784 return (Encoding == dwarf::DW_ATE_unsigned ||
785 Encoding == dwarf::DW_ATE_unsigned_char ||
786 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean);
789 /// If this type is derived from a base type then return base type size.
790 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
791 unsigned Tag = Ty.getTag();
793 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
794 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
795 Tag != dwarf::DW_TAG_restrict_type)
796 return Ty.getSizeInBits();
798 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
800 // If this type is not derived from any type or the type is a declaration then
801 // take conservative approach.
802 if (!BaseType.isValid() || BaseType.isForwardDecl())
803 return Ty.getSizeInBits();
805 // If this is a derived type, go ahead and get the base type, unless it's a
806 // reference then it's just the size of the field. Pointer types have no need
807 // of this since they're a different type of qualification on the type.
808 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
809 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
810 return Ty.getSizeInBits();
812 if (BaseType.isDerivedType())
813 return getBaseTypeSize(DD, DIDerivedType(BaseType));
815 return BaseType.getSizeInBits();
818 /// addConstantFPValue - Add constant value entry in variable DIE.
819 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
820 assert(MO.isFPImm() && "Invalid machine operand!");
821 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
822 APFloat FPImm = MO.getFPImm()->getValueAPF();
824 // Get the raw data form of the floating point.
825 const APInt FltVal = FPImm.bitcastToAPInt();
826 const char *FltPtr = (const char *)FltVal.getRawData();
828 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
829 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
830 int Incr = (LittleEndian ? 1 : -1);
831 int Start = (LittleEndian ? 0 : NumBytes - 1);
832 int Stop = (LittleEndian ? NumBytes : -1);
834 // Output the constant to DWARF one byte at a time.
835 for (; Start != Stop; Start += Incr)
836 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
838 addBlock(Die, dwarf::DW_AT_const_value, Block);
841 /// addConstantFPValue - Add constant value entry in variable DIE.
842 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
843 // Pass this down to addConstantValue as an unsigned bag of bits.
844 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
847 /// addConstantValue - Add constant value entry in variable DIE.
848 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
849 addConstantValue(Die, CI->getValue(), Ty);
852 /// addConstantValue - Add constant value entry in variable DIE.
853 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
855 assert(MO.isImm() && "Invalid machine operand!");
857 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
860 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
861 // FIXME: This is a bit conservative/simple - it emits negative values always
862 // sign extended to 64 bits rather than minimizing the number of bytes.
863 addUInt(Die, dwarf::DW_AT_const_value,
864 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
867 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
868 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
871 // addConstantValue - Add constant value entry in variable DIE.
872 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
873 unsigned CIBitWidth = Val.getBitWidth();
874 if (CIBitWidth <= 64) {
875 addConstantValue(Die, Unsigned,
876 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
880 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
882 // Get the raw data form of the large APInt.
883 const uint64_t *Ptr64 = Val.getRawData();
885 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
886 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
888 // Output the constant to DWARF one byte at a time.
889 for (int i = 0; i < NumBytes; i++) {
892 c = Ptr64[i / 8] >> (8 * (i & 7));
894 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
895 addUInt(*Block, dwarf::DW_FORM_data1, c);
898 addBlock(Die, dwarf::DW_AT_const_value, Block);
901 /// addTemplateParams - Add template parameters into buffer.
902 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
903 // Add template parameters.
904 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
905 DIDescriptor Element = TParams.getElement(i);
906 if (Element.isTemplateTypeParameter())
907 constructTemplateTypeParameterDIE(Buffer,
908 DITemplateTypeParameter(Element));
909 else if (Element.isTemplateValueParameter())
910 constructTemplateValueParameterDIE(Buffer,
911 DITemplateValueParameter(Element));
915 /// getOrCreateContextDIE - Get context owner's DIE.
916 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
917 if (!Context || Context.isFile())
918 return &getUnitDie();
919 if (Context.isType())
920 return getOrCreateTypeDIE(DIType(Context));
921 if (Context.isNameSpace())
922 return getOrCreateNameSpace(DINameSpace(Context));
923 if (Context.isSubprogram())
924 return getOrCreateSubprogramDIE(DISubprogram(Context));
925 return getDIE(Context);
928 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
929 DIScope Context = resolve(Ty.getContext());
930 DIE *ContextDIE = getOrCreateContextDIE(Context);
932 if (DIE *TyDIE = getDIE(Ty))
936 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
938 constructTypeDIE(TyDIE, Ty);
940 updateAcceleratorTables(Context, Ty, TyDIE);
944 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
946 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
952 assert(Ty == resolve(Ty.getRef()) &&
953 "type was not uniqued, possible ODR violation.");
955 // DW_TAG_restrict_type is not supported in DWARF2
956 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
957 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
959 // Construct the context before querying for the existence of the DIE in case
960 // such construction creates the DIE.
961 DIScope Context = resolve(Ty.getContext());
962 DIE *ContextDIE = getOrCreateContextDIE(Context);
965 if (DIE *TyDIE = getDIE(Ty))
969 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
971 updateAcceleratorTables(Context, Ty, TyDIE);
973 if (Ty.isBasicType())
974 constructTypeDIE(TyDIE, DIBasicType(Ty));
975 else if (Ty.isCompositeType()) {
976 DICompositeType CTy(Ty);
977 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
978 if (MDString *TypeId = CTy.getIdentifier()) {
979 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
980 // Skip updating the accelerator tables since this is not the full type.
983 constructTypeDIE(TyDIE, CTy);
985 assert(Ty.isDerivedType() && "Unknown kind of DIType");
986 constructTypeDIE(TyDIE, DIDerivedType(Ty));
992 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
994 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
995 bool IsImplementation = 0;
996 if (Ty.isCompositeType()) {
997 DICompositeType CT(Ty);
998 // A runtime language of 0 actually means C/C++ and that any
999 // non-negative value is some version of Objective-C/C++.
1000 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1002 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1003 DD->addAccelType(Ty.getName(), TyDIE, Flags);
1005 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1006 Context.isNameSpace()) &&
1007 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1008 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
1013 /// addType - Add a new type attribute to the specified entity.
1014 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
1015 assert(Ty && "Trying to add a type that doesn't exist?");
1017 // Check for pre-existence.
1018 DIEEntry *Entry = getDIEEntry(Ty);
1019 // If it exists then use the existing value.
1021 addDIEEntry(Entity, Attribute, Entry);
1026 DIE *Buffer = getOrCreateTypeDIE(Ty);
1029 Entry = createDIEEntry(*Buffer);
1030 insertDIEEntry(Ty, Entry);
1031 addDIEEntry(Entity, Attribute, Entry);
1034 /// addGlobalName - Add a new global name to the compile unit.
1035 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1036 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1038 std::string FullName = getParentContextString(Context) + Name.str();
1039 GlobalNames[FullName] = &Die;
1042 /// getParentContextString - Walks the metadata parent chain in a language
1043 /// specific manner (using the compile unit language) and returns
1044 /// it as a string. This is done at the metadata level because DIEs may
1045 /// not currently have been added to the parent context and walking the
1046 /// DIEs looking for names is more expensive than walking the metadata.
1047 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1051 // FIXME: Decide whether to implement this for non-C++ languages.
1052 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1056 SmallVector<DIScope, 1> Parents;
1057 while (!Context.isCompileUnit()) {
1058 Parents.push_back(Context);
1059 if (Context.getContext())
1060 Context = resolve(Context.getContext());
1062 // Structure, etc types will have a NULL context if they're at the top
1067 // Reverse iterate over our list to go from the outermost construct to the
1069 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1073 StringRef Name = Ctx.getName();
1074 if (!Name.empty()) {
1082 /// constructTypeDIE - Construct basic type die from DIBasicType.
1083 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1084 // Get core information.
1085 StringRef Name = BTy.getName();
1086 // Add name if not anonymous or intermediate type.
1088 addString(Buffer, dwarf::DW_AT_name, Name);
1090 // An unspecified type only has a name attribute.
1091 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1094 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1097 uint64_t Size = BTy.getSizeInBits() >> 3;
1098 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1101 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1102 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1103 // Get core information.
1104 StringRef Name = DTy.getName();
1105 uint64_t Size = DTy.getSizeInBits() >> 3;
1106 uint16_t Tag = Buffer.getTag();
1108 // Map to main type, void will not have a type.
1109 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1111 addType(Buffer, FromTy);
1113 // Add name if not anonymous or intermediate type.
1115 addString(Buffer, dwarf::DW_AT_name, Name);
1117 // Add size if non-zero (derived types might be zero-sized.)
1118 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1119 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1121 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1122 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1123 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1124 // Add source line info if available and TyDesc is not a forward declaration.
1125 if (!DTy.isForwardDecl())
1126 addSourceLine(Buffer, DTy);
1129 /// constructSubprogramArguments - Construct function argument DIEs.
1130 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1131 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1132 DIDescriptor Ty = Args.getElement(i);
1133 if (Ty.isUnspecifiedParameter()) {
1134 assert(i == N-1 && "Unspecified parameter must be the last argument");
1135 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1137 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1138 addType(Arg, DIType(Ty));
1139 if (DIType(Ty).isArtificial())
1140 addFlag(Arg, dwarf::DW_AT_artificial);
1145 /// constructTypeDIE - Construct type DIE from DICompositeType.
1146 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1147 // Add name if not anonymous or intermediate type.
1148 StringRef Name = CTy.getName();
1150 uint64_t Size = CTy.getSizeInBits() >> 3;
1151 uint16_t Tag = Buffer.getTag();
1154 case dwarf::DW_TAG_array_type:
1155 constructArrayTypeDIE(Buffer, CTy);
1157 case dwarf::DW_TAG_enumeration_type:
1158 constructEnumTypeDIE(Buffer, CTy);
1160 case dwarf::DW_TAG_subroutine_type: {
1161 // Add return type. A void return won't have a type.
1162 DIArray Elements = CTy.getTypeArray();
1163 DIType RTy(Elements.getElement(0));
1165 addType(Buffer, RTy);
1167 bool isPrototyped = true;
1168 if (Elements.getNumElements() == 2 &&
1169 Elements.getElement(1).isUnspecifiedParameter())
1170 isPrototyped = false;
1172 constructSubprogramArguments(Buffer, Elements);
1174 // Add prototype flag if we're dealing with a C language and the
1175 // function has been prototyped.
1176 uint16_t Language = getLanguage();
1178 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1179 Language == dwarf::DW_LANG_ObjC))
1180 addFlag(Buffer, dwarf::DW_AT_prototyped);
1182 if (CTy.isLValueReference())
1183 addFlag(Buffer, dwarf::DW_AT_reference);
1185 if (CTy.isRValueReference())
1186 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1188 case dwarf::DW_TAG_structure_type:
1189 case dwarf::DW_TAG_union_type:
1190 case dwarf::DW_TAG_class_type: {
1191 // Add elements to structure type.
1192 DIArray Elements = CTy.getTypeArray();
1193 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1194 DIDescriptor Element = Elements.getElement(i);
1195 if (Element.isSubprogram())
1196 getOrCreateSubprogramDIE(DISubprogram(Element));
1197 else if (Element.isDerivedType()) {
1198 DIDerivedType DDTy(Element);
1199 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1200 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1201 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1202 dwarf::DW_AT_friend);
1203 } else if (DDTy.isStaticMember()) {
1204 getOrCreateStaticMemberDIE(DDTy);
1206 constructMemberDIE(Buffer, DDTy);
1208 } else if (Element.isObjCProperty()) {
1209 DIObjCProperty Property(Element);
1210 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1211 StringRef PropertyName = Property.getObjCPropertyName();
1212 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1213 if (Property.getType())
1214 addType(ElemDie, Property.getType());
1215 addSourceLine(ElemDie, Property);
1216 StringRef GetterName = Property.getObjCPropertyGetterName();
1217 if (!GetterName.empty())
1218 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1219 StringRef SetterName = Property.getObjCPropertySetterName();
1220 if (!SetterName.empty())
1221 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1222 unsigned PropertyAttributes = 0;
1223 if (Property.isReadOnlyObjCProperty())
1224 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1225 if (Property.isReadWriteObjCProperty())
1226 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1227 if (Property.isAssignObjCProperty())
1228 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1229 if (Property.isRetainObjCProperty())
1230 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1231 if (Property.isCopyObjCProperty())
1232 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1233 if (Property.isNonAtomicObjCProperty())
1234 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1235 if (PropertyAttributes)
1236 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1237 PropertyAttributes);
1239 DIEEntry *Entry = getDIEEntry(Element);
1241 Entry = createDIEEntry(ElemDie);
1242 insertDIEEntry(Element, Entry);
1248 if (CTy.isAppleBlockExtension())
1249 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1251 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1253 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1254 *getOrCreateTypeDIE(ContainingType));
1256 if (CTy.isObjcClassComplete())
1257 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1259 // Add template parameters to a class, structure or union types.
1260 // FIXME: The support isn't in the metadata for this yet.
1261 if (Tag == dwarf::DW_TAG_class_type ||
1262 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1263 addTemplateParams(Buffer, CTy.getTemplateParams());
1271 // Add name if not anonymous or intermediate type.
1273 addString(Buffer, dwarf::DW_AT_name, Name);
1275 if (Tag == dwarf::DW_TAG_enumeration_type ||
1276 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1277 Tag == dwarf::DW_TAG_union_type) {
1278 // Add size if non-zero (derived types might be zero-sized.)
1279 // TODO: Do we care about size for enum forward declarations?
1281 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1282 else if (!CTy.isForwardDecl())
1283 // Add zero size if it is not a forward declaration.
1284 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1286 // If we're a forward decl, say so.
1287 if (CTy.isForwardDecl())
1288 addFlag(Buffer, dwarf::DW_AT_declaration);
1290 // Add source line info if available.
1291 if (!CTy.isForwardDecl())
1292 addSourceLine(Buffer, CTy);
1294 // No harm in adding the runtime language to the declaration.
1295 unsigned RLang = CTy.getRunTimeLang();
1297 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1302 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1303 /// DITemplateTypeParameter.
1304 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1305 DITemplateTypeParameter TP) {
1307 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1308 // Add the type if it exists, it could be void and therefore no type.
1310 addType(ParamDIE, resolve(TP.getType()));
1311 if (!TP.getName().empty())
1312 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1315 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1316 /// DITemplateValueParameter.
1318 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1319 DITemplateValueParameter VP) {
1320 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1322 // Add the type if there is one, template template and template parameter
1323 // packs will not have a type.
1324 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1325 addType(ParamDIE, resolve(VP.getType()));
1326 if (!VP.getName().empty())
1327 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1328 if (Value *Val = VP.getValue()) {
1329 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1330 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1331 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1332 // For declaration non-type template parameters (such as global values and
1334 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1335 addOpAddress(*Loc, Asm->getSymbol(GV));
1336 // Emit DW_OP_stack_value to use the address as the immediate value of the
1337 // parameter, rather than a pointer to it.
1338 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1339 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1340 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1341 assert(isa<MDString>(Val));
1342 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1343 cast<MDString>(Val)->getString());
1344 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1345 assert(isa<MDNode>(Val));
1346 DIArray A(cast<MDNode>(Val));
1347 addTemplateParams(ParamDIE, A);
1352 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1353 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1354 // Construct the context before querying for the existence of the DIE in case
1355 // such construction creates the DIE.
1356 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1358 if (DIE *NDie = getDIE(NS))
1360 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1362 if (!NS.getName().empty()) {
1363 addString(NDie, dwarf::DW_AT_name, NS.getName());
1364 DD->addAccelNamespace(NS.getName(), NDie);
1365 addGlobalName(NS.getName(), NDie, NS.getContext());
1367 DD->addAccelNamespace("(anonymous namespace)", NDie);
1368 addSourceLine(NDie, NS);
1372 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1373 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1374 // Construct the context before querying for the existence of the DIE in case
1375 // such construction creates the DIE (as is the case for member function
1377 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1379 if (DIE *SPDie = getDIE(SP))
1382 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1383 // Add subprogram definitions to the CU die directly.
1384 ContextDIE = &getUnitDie();
1385 // Build the decl now to ensure it preceeds the definition.
1386 getOrCreateSubprogramDIE(SPDecl);
1389 // DW_TAG_inlined_subroutine may refer to this DIE.
1390 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1392 applySubprogramAttributes(SP, SPDie);
1396 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1397 DIE *DeclDie = nullptr;
1398 StringRef DeclLinkageName;
1399 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1400 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1401 DeclLinkageName = SPDecl.getLinkageName();
1404 // Add function template parameters.
1405 addTemplateParams(SPDie, SP.getTemplateParams());
1407 // Add the linkage name if we have one and it isn't in the Decl.
1408 StringRef LinkageName = SP.getLinkageName();
1409 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1410 LinkageName == DeclLinkageName) &&
1411 "decl has a linkage name and it is different");
1412 if (!LinkageName.empty() && DeclLinkageName.empty())
1413 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1414 GlobalValue::getRealLinkageName(LinkageName));
1417 // Refer to the function declaration where all the other attributes will be
1419 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1423 // Constructors and operators for anonymous aggregates do not have names.
1424 if (!SP.getName().empty())
1425 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1427 addSourceLine(SPDie, SP);
1429 // Add the prototype if we have a prototype and we have a C like
1431 uint16_t Language = getLanguage();
1432 if (SP.isPrototyped() &&
1433 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1434 Language == dwarf::DW_LANG_ObjC))
1435 addFlag(SPDie, dwarf::DW_AT_prototyped);
1437 DICompositeType SPTy = SP.getType();
1438 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1439 "the type of a subprogram should be a subroutine");
1441 DIArray Args = SPTy.getTypeArray();
1442 // Add a return type. If this is a type like a C/C++ void type we don't add a
1444 if (Args.getElement(0))
1445 addType(SPDie, DIType(Args.getElement(0)));
1447 unsigned VK = SP.getVirtuality();
1449 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1450 DIELoc *Block = getDIELoc();
1451 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1452 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1453 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1454 ContainingTypeMap.insert(
1455 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1458 if (!SP.isDefinition()) {
1459 addFlag(SPDie, dwarf::DW_AT_declaration);
1461 // Add arguments. Do not add arguments for subprogram definition. They will
1462 // be handled while processing variables.
1463 constructSubprogramArguments(SPDie, Args);
1466 if (SP.isArtificial())
1467 addFlag(SPDie, dwarf::DW_AT_artificial);
1469 if (!SP.isLocalToUnit())
1470 addFlag(SPDie, dwarf::DW_AT_external);
1472 if (SP.isOptimized())
1473 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1475 if (unsigned isa = Asm->getISAEncoding()) {
1476 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1479 if (SP.isLValueReference())
1480 addFlag(SPDie, dwarf::DW_AT_reference);
1482 if (SP.isRValueReference())
1483 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1485 if (SP.isProtected())
1486 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1487 dwarf::DW_ACCESS_protected);
1488 else if (SP.isPrivate())
1489 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1490 dwarf::DW_ACCESS_private);
1492 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1493 dwarf::DW_ACCESS_public);
1495 if (SP.isExplicit())
1496 addFlag(SPDie, dwarf::DW_AT_explicit);
1499 // Return const expression if value is a GEP to access merged global
1501 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1502 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1503 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1504 if (!CE || CE->getNumOperands() != 3 ||
1505 CE->getOpcode() != Instruction::GetElementPtr)
1508 // First operand points to a global struct.
1509 Value *Ptr = CE->getOperand(0);
1510 if (!isa<GlobalValue>(Ptr) ||
1511 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1514 // Second operand is zero.
1515 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1516 if (!CI || !CI->isZero())
1519 // Third operand is offset.
1520 if (!isa<ConstantInt>(CE->getOperand(2)))
1526 /// createGlobalVariableDIE - create global variable DIE.
1527 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1528 // Check for pre-existence.
1532 assert(GV.isGlobalVariable());
1534 DIScope GVContext = GV.getContext();
1535 DIType GTy = DD->resolve(GV.getType());
1537 // If this is a static data member definition, some attributes belong
1538 // to the declaration DIE.
1539 DIE *VariableDIE = nullptr;
1540 bool IsStaticMember = false;
1541 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1542 if (SDMDecl.Verify()) {
1543 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1544 // We need the declaration DIE that is in the static member's class.
1545 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1546 IsStaticMember = true;
1549 // If this is not a static data member definition, create the variable
1550 // DIE and add the initial set of attributes to it.
1552 // Construct the context before querying for the existence of the DIE in
1553 // case such construction creates the DIE.
1554 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1557 VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1559 // Add name and type.
1560 addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1561 addType(*VariableDIE, GTy);
1563 // Add scoping info.
1564 if (!GV.isLocalToUnit())
1565 addFlag(*VariableDIE, dwarf::DW_AT_external);
1567 // Add line number info.
1568 addSourceLine(*VariableDIE, GV);
1572 bool addToAccelTable = false;
1573 DIE *VariableSpecDIE = nullptr;
1574 bool isGlobalVariable = GV.getGlobal() != nullptr;
1575 if (isGlobalVariable) {
1576 addToAccelTable = true;
1577 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1578 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1579 if (GV.getGlobal()->isThreadLocal()) {
1580 // FIXME: Make this work with -gsplit-dwarf.
1581 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1582 assert((PointerSize == 4 || PointerSize == 8) &&
1583 "Add support for other sizes if necessary");
1584 // Based on GCC's support for TLS:
1585 if (!DD->useSplitDwarf()) {
1586 // 1) Start with a constNu of the appropriate pointer size
1587 addUInt(*Loc, dwarf::DW_FORM_data1,
1588 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1589 // 2) containing the (relocated) offset of the TLS variable
1590 // within the module's TLS block.
1591 addExpr(*Loc, dwarf::DW_FORM_udata,
1592 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1594 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1595 addUInt(*Loc, dwarf::DW_FORM_udata,
1596 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
1598 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1599 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1601 DD->addArangeLabel(SymbolCU(this, Sym));
1602 addOpAddress(*Loc, Sym);
1604 // Do not create specification DIE if context is either compile unit
1606 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1607 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1608 // Create specification DIE.
1609 VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie);
1610 addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE);
1611 addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc);
1612 // A static member's declaration is already flagged as such.
1613 if (!SDMDecl.Verify())
1614 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
1616 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1618 // Add the linkage name.
1619 StringRef LinkageName = GV.getLinkageName();
1620 if (!LinkageName.empty())
1621 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1622 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1624 addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE
1626 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1627 : dwarf::DW_AT_MIPS_linkage_name,
1628 GlobalValue::getRealLinkageName(LinkageName));
1629 } else if (const ConstantInt *CI =
1630 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1631 // AT_const_value was added when the static member was created. To avoid
1632 // emitting AT_const_value multiple times, we only add AT_const_value when
1633 // it is not a static member.
1634 if (!IsStaticMember)
1635 addConstantValue(*VariableDIE, CI, GTy);
1636 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1637 addToAccelTable = true;
1638 // GV is a merged global.
1639 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1640 Value *Ptr = CE->getOperand(0);
1641 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1642 DD->addArangeLabel(SymbolCU(this, Sym));
1643 addOpAddress(*Loc, Sym);
1644 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1645 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1646 addUInt(*Loc, dwarf::DW_FORM_udata,
1647 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1648 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1649 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1652 if (addToAccelTable) {
1653 DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE;
1654 DD->addAccelName(GV.getName(), AddrDIE);
1656 // If the linkage name is different than the name, go ahead and output
1657 // that as well into the name table.
1658 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1659 DD->addAccelName(GV.getLinkageName(), AddrDIE);
1662 if (!GV.isLocalToUnit())
1663 addGlobalName(GV.getName(),
1664 VariableSpecDIE ? *VariableSpecDIE : *VariableDIE,
1668 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1669 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1670 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1671 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1673 // The LowerBound value defines the lower bounds which is typically zero for
1674 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1675 // Count == -1 then the array is unbounded and we do not emit
1676 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1677 // Count == 0, then the array has zero elements in which case we do not emit
1679 int64_t LowerBound = SR.getLo();
1680 int64_t DefaultLowerBound = getDefaultLowerBound();
1681 int64_t Count = SR.getCount();
1683 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1684 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1686 if (Count != -1 && Count != 0)
1687 // FIXME: An unbounded array should reference the expression that defines
1689 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1690 LowerBound + Count - 1);
1693 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1694 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1696 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1698 // Emit the element type.
1699 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1701 // Get an anonymous type for index type.
1702 // FIXME: This type should be passed down from the front end
1703 // as different languages may have different sizes for indexes.
1704 DIE *IdxTy = getIndexTyDie();
1706 // Construct an integer type to use for indexes.
1707 IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1708 addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1709 addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1710 addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1711 dwarf::DW_ATE_unsigned);
1712 setIndexTyDie(IdxTy);
1715 // Add subranges to array type.
1716 DIArray Elements = CTy.getTypeArray();
1717 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1718 DIDescriptor Element = Elements.getElement(i);
1719 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1720 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1724 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1725 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1726 DIArray Elements = CTy.getTypeArray();
1728 // Add enumerators to enumeration type.
1729 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1730 DIEnumerator Enum(Elements.getElement(i));
1731 if (Enum.isEnumerator()) {
1732 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1733 StringRef Name = Enum.getName();
1734 addString(Enumerator, dwarf::DW_AT_name, Name);
1735 int64_t Value = Enum.getEnumValue();
1736 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1740 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1742 addType(Buffer, DTy);
1743 addFlag(Buffer, dwarf::DW_AT_enum_class);
1747 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1749 void DwarfUnit::constructContainingTypeDIEs() {
1750 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1751 CE = ContainingTypeMap.end();
1753 DIE &SPDie = *CI->first;
1754 DIDescriptor D(CI->second);
1757 DIE *NDie = getDIE(D);
1760 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1764 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1765 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
1766 AbstractOrInlined AbsIn) {
1767 auto D = constructVariableDIEImpl(DV, AbsIn);
1772 std::unique_ptr<DIE>
1773 DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
1774 AbstractOrInlined AbsIn) {
1775 StringRef Name = DV.getName();
1777 // Define variable debug information entry.
1778 auto VariableDie = make_unique<DIE>(DV.getTag());
1779 DbgVariable *AbsVar = DV.getAbstractVariable();
1780 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : nullptr;
1782 addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, *AbsDIE);
1785 addString(*VariableDie, dwarf::DW_AT_name, Name);
1786 addSourceLine(*VariableDie, DV.getVariable());
1787 addType(*VariableDie, DV.getType());
1790 if (AbsIn != AOI_Inlined && DV.isArtificial())
1791 addFlag(*VariableDie, dwarf::DW_AT_artificial);
1793 if (AbsIn == AOI_Abstract)
1796 // Add variable address.
1798 unsigned Offset = DV.getDotDebugLocOffset();
1799 if (Offset != ~0U) {
1800 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
1804 // Check if variable is described by a DBG_VALUE instruction.
1805 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1806 assert(DVInsn->getNumOperands() == 3);
1807 if (DVInsn->getOperand(0).isReg()) {
1808 const MachineOperand RegOp = DVInsn->getOperand(0);
1809 // If the second operand is an immediate, this is an indirect value.
1810 if (DVInsn->getOperand(1).isImm()) {
1811 MachineLocation Location(RegOp.getReg(),
1812 DVInsn->getOperand(1).getImm());
1813 addVariableAddress(DV, *VariableDie, Location);
1814 } else if (RegOp.getReg())
1815 addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
1816 } else if (DVInsn->getOperand(0).isImm())
1817 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
1818 else if (DVInsn->getOperand(0).isFPImm())
1819 addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
1820 else if (DVInsn->getOperand(0).isCImm())
1821 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
1827 // .. else use frame index.
1828 int FI = DV.getFrameIndex();
1830 unsigned FrameReg = 0;
1831 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1832 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1833 MachineLocation Location(FrameReg, Offset);
1834 addVariableAddress(DV, *VariableDie, Location);
1840 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1841 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1842 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1843 StringRef Name = DT.getName();
1845 addString(MemberDie, dwarf::DW_AT_name, Name);
1847 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1849 addSourceLine(MemberDie, DT);
1851 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1853 // For C++, virtual base classes are not at fixed offset. Use following
1854 // expression to extract appropriate offset from vtable.
1855 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1857 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1858 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1859 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1860 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1861 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1862 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1863 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1864 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1866 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1868 uint64_t Size = DT.getSizeInBits();
1869 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1870 uint64_t OffsetInBytes;
1872 if (Size != FieldSize) {
1873 // Handle bitfield, assume bytes are 8 bits.
1874 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1875 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1877 uint64_t Offset = DT.getOffsetInBits();
1878 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1879 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1880 uint64_t FieldOffset = (HiMark - FieldSize);
1881 Offset -= FieldOffset;
1883 // Maybe we need to work from the other end.
1884 if (Asm->getDataLayout().isLittleEndian())
1885 Offset = FieldSize - (Offset + Size);
1886 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1888 // Here DW_AT_data_member_location points to the anonymous
1889 // field that includes this bit field.
1890 OffsetInBytes = FieldOffset >> 3;
1892 // This is not a bitfield.
1893 OffsetInBytes = DT.getOffsetInBits() >> 3;
1895 if (DD->getDwarfVersion() <= 2) {
1896 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1897 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1898 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1899 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1901 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1905 if (DT.isProtected())
1906 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1907 dwarf::DW_ACCESS_protected);
1908 else if (DT.isPrivate())
1909 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1910 dwarf::DW_ACCESS_private);
1911 // Otherwise C++ member and base classes are considered public.
1913 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1914 dwarf::DW_ACCESS_public);
1916 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1917 dwarf::DW_VIRTUALITY_virtual);
1919 // Objective-C properties.
1920 if (MDNode *PNode = DT.getObjCProperty())
1921 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1922 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1925 if (DT.isArtificial())
1926 addFlag(MemberDie, dwarf::DW_AT_artificial);
1929 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1930 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1934 // Construct the context before querying for the existence of the DIE in case
1935 // such construction creates the DIE.
1936 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1937 assert(dwarf::isType(ContextDIE->getTag()) &&
1938 "Static member should belong to a type.");
1940 if (DIE *StaticMemberDIE = getDIE(DT))
1941 return StaticMemberDIE;
1943 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1945 DIType Ty = resolve(DT.getTypeDerivedFrom());
1947 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1948 addType(StaticMemberDIE, Ty);
1949 addSourceLine(StaticMemberDIE, DT);
1950 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1951 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1953 // FIXME: We could omit private if the parent is a class_type, and
1954 // public if the parent is something else.
1955 if (DT.isProtected())
1956 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1957 dwarf::DW_ACCESS_protected);
1958 else if (DT.isPrivate())
1959 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1960 dwarf::DW_ACCESS_private);
1962 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1963 dwarf::DW_ACCESS_public);
1965 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1966 addConstantValue(StaticMemberDIE, CI, Ty);
1967 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1968 addConstantFPValue(StaticMemberDIE, CFP);
1970 return &StaticMemberDIE;
1973 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1974 Asm->OutStreamer.AddComment("DWARF version number");
1975 Asm->EmitInt16(DD->getDwarfVersion());
1976 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1977 // We share one abbreviations table across all units so it's always at the
1978 // start of the section. Use a relocatable offset where needed to ensure
1979 // linking doesn't invalidate that offset.
1981 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1983 // Use a constant value when no symbol is provided.
1985 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1986 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1989 void DwarfUnit::addRange(RangeSpan Range) {
1990 // Only add a range for this unit if we're emitting full debug.
1991 if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
1992 // If we have no current ranges just add the range and return, otherwise,
1993 // check the current section and CU against the previous section and CU we
1994 // emitted into and the subprogram was contained within. If these are the
1995 // same then extend our current range, otherwise add this as a new range.
1996 if (CURanges.size() == 0 ||
1997 this != DD->getPrevCU() ||
1998 Asm->getCurrentSection() != DD->getPrevSection()) {
1999 CURanges.push_back(Range);
2003 assert(&(CURanges.back().getEnd()->getSection()) ==
2004 &(Range.getEnd()->getSection()) &&
2005 "We can only append to a range in the same section!");
2006 CURanges.back().setEnd(Range.getEnd());
2010 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2011 // Define start line table label for each Compile Unit.
2012 MCSymbol *LineTableStartSym =
2013 Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
2015 stmtListIndex = UnitDie.getValues().size();
2017 // DW_AT_stmt_list is a offset of line number information for this
2018 // compile unit in debug_line section. For split dwarf this is
2019 // left in the skeleton CU and so not included.
2020 // The line table entries are not always emitted in assembly, so it
2021 // is not okay to use line_table_start here.
2022 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2023 addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym);
2025 addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
2026 DwarfLineSectionSym);
2029 void DwarfCompileUnit::applyStmtList(DIE &D) {
2030 D.addValue(dwarf::DW_AT_stmt_list,
2031 UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
2032 UnitDie.getValues()[stmtListIndex]);
2035 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2036 DwarfUnit::emitHeader(ASectionSym);
2037 Asm->OutStreamer.AddComment("Type Signature");
2038 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2039 Asm->OutStreamer.AddComment("Type DIE Offset");
2040 // In a skeleton type unit there is no type DIE so emit a zero offset.
2041 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2042 sizeof(Ty->getOffset()));
2045 void DwarfTypeUnit::initSection(const MCSection *Section) {
2046 assert(!this->Section);
2047 this->Section = Section;
2048 // Since each type unit is contained in its own COMDAT section, the begin
2049 // label and the section label are the same. Using the begin label emission in
2050 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2051 // the only other alternative of lazily constructing start-of-section labels
2052 // and storing a mapping in DwarfDebug (or AsmPrinter).
2053 this->SectionSym = this->LabelBegin =
2054 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2056 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());