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 /// isTypeSigned - Return true if the type is signed.
749 static bool isTypeSigned(DwarfDebug *DD, DIType Ty) {
750 if (Ty.isDerivedType())
751 return isTypeSigned(DD,
752 DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
754 return Ty.isBasicType() &&
755 (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
756 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char);
759 /// Return true if type encoding is unsigned.
760 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
761 DIDerivedType DTy(Ty);
762 if (DTy.isDerivedType())
763 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
766 if (BTy.isBasicType()) {
767 unsigned Encoding = BTy.getEncoding();
768 if (Encoding == dwarf::DW_ATE_unsigned ||
769 Encoding == dwarf::DW_ATE_unsigned_char ||
770 Encoding == dwarf::DW_ATE_boolean)
776 /// If this type is derived from a base type then return base type size.
777 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
778 unsigned Tag = Ty.getTag();
780 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
781 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
782 Tag != dwarf::DW_TAG_restrict_type)
783 return Ty.getSizeInBits();
785 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
787 // If this type is not derived from any type or the type is a declaration then
788 // take conservative approach.
789 if (!BaseType.isValid() || BaseType.isForwardDecl())
790 return Ty.getSizeInBits();
792 // If this is a derived type, go ahead and get the base type, unless it's a
793 // reference then it's just the size of the field. Pointer types have no need
794 // of this since they're a different type of qualification on the type.
795 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
796 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
797 return Ty.getSizeInBits();
799 if (BaseType.isDerivedType())
800 return getBaseTypeSize(DD, DIDerivedType(BaseType));
802 return BaseType.getSizeInBits();
805 /// addConstantValue - Add constant value entry in variable DIE.
806 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
808 // FIXME: This is a bit conservative/simple - it emits negative values at
809 // their maximum bit width which is a bit unfortunate.
810 assert(MO.isImm() && "Invalid machine operand!");
812 addUInt(Die, dwarf::DW_AT_const_value,
813 isTypeSigned(DD, Ty) ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata,
817 /// addConstantFPValue - Add constant value entry in variable DIE.
818 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
819 assert(MO.isFPImm() && "Invalid machine operand!");
820 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
821 APFloat FPImm = MO.getFPImm()->getValueAPF();
823 // Get the raw data form of the floating point.
824 const APInt FltVal = FPImm.bitcastToAPInt();
825 const char *FltPtr = (const char *)FltVal.getRawData();
827 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
828 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
829 int Incr = (LittleEndian ? 1 : -1);
830 int Start = (LittleEndian ? 0 : NumBytes - 1);
831 int Stop = (LittleEndian ? NumBytes : -1);
833 // Output the constant to DWARF one byte at a time.
834 for (; Start != Stop; Start += Incr)
835 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
837 addBlock(Die, dwarf::DW_AT_const_value, Block);
840 /// addConstantFPValue - Add constant value entry in variable DIE.
841 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
842 // Pass this down to addConstantValue as an unsigned bag of bits.
843 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
846 /// addConstantValue - Add constant value entry in variable DIE.
847 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
849 addConstantValue(Die, CI->getValue(), Unsigned);
852 // addConstantValue - Add constant value entry in variable DIE.
853 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
854 unsigned CIBitWidth = Val.getBitWidth();
855 if (CIBitWidth <= 64) {
856 // If we're a signed constant definitely use sdata.
858 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
863 // Else use data for now unless it's larger than we can deal with.
865 switch (CIBitWidth) {
867 Form = dwarf::DW_FORM_data1;
870 Form = dwarf::DW_FORM_data2;
873 Form = dwarf::DW_FORM_data4;
876 Form = dwarf::DW_FORM_data8;
879 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
883 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
887 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
889 // Get the raw data form of the large APInt.
890 const uint64_t *Ptr64 = Val.getRawData();
892 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
893 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
895 // Output the constant to DWARF one byte at a time.
896 for (int i = 0; i < NumBytes; i++) {
899 c = Ptr64[i / 8] >> (8 * (i & 7));
901 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
902 addUInt(*Block, dwarf::DW_FORM_data1, c);
905 addBlock(Die, dwarf::DW_AT_const_value, Block);
908 /// addTemplateParams - Add template parameters into buffer.
909 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
910 // Add template parameters.
911 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
912 DIDescriptor Element = TParams.getElement(i);
913 if (Element.isTemplateTypeParameter())
914 constructTemplateTypeParameterDIE(Buffer,
915 DITemplateTypeParameter(Element));
916 else if (Element.isTemplateValueParameter())
917 constructTemplateValueParameterDIE(Buffer,
918 DITemplateValueParameter(Element));
922 /// getOrCreateContextDIE - Get context owner's DIE.
923 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
924 if (!Context || Context.isFile())
925 return &getUnitDie();
926 if (Context.isType())
927 return getOrCreateTypeDIE(DIType(Context));
928 if (Context.isNameSpace())
929 return getOrCreateNameSpace(DINameSpace(Context));
930 if (Context.isSubprogram())
931 return getOrCreateSubprogramDIE(DISubprogram(Context));
932 return getDIE(Context);
935 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
936 DIScope Context = resolve(Ty.getContext());
937 DIE *ContextDIE = getOrCreateContextDIE(Context);
939 if (DIE *TyDIE = getDIE(Ty))
943 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
945 constructTypeDIE(TyDIE, Ty);
947 updateAcceleratorTables(Context, Ty, TyDIE);
951 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
953 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
959 assert(Ty == resolve(Ty.getRef()) &&
960 "type was not uniqued, possible ODR violation.");
962 // DW_TAG_restrict_type is not supported in DWARF2
963 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
964 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
966 // Construct the context before querying for the existence of the DIE in case
967 // such construction creates the DIE.
968 DIScope Context = resolve(Ty.getContext());
969 DIE *ContextDIE = getOrCreateContextDIE(Context);
972 if (DIE *TyDIE = getDIE(Ty))
976 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
978 updateAcceleratorTables(Context, Ty, TyDIE);
980 if (Ty.isBasicType())
981 constructTypeDIE(TyDIE, DIBasicType(Ty));
982 else if (Ty.isCompositeType()) {
983 DICompositeType CTy(Ty);
984 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
985 if (MDString *TypeId = CTy.getIdentifier()) {
986 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
987 // Skip updating the accelerator tables since this is not the full type.
990 constructTypeDIE(TyDIE, CTy);
992 assert(Ty.isDerivedType() && "Unknown kind of DIType");
993 constructTypeDIE(TyDIE, DIDerivedType(Ty));
999 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
1001 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
1002 bool IsImplementation = 0;
1003 if (Ty.isCompositeType()) {
1004 DICompositeType CT(Ty);
1005 // A runtime language of 0 actually means C/C++ and that any
1006 // non-negative value is some version of Objective-C/C++.
1007 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1009 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1010 DD->addAccelType(Ty.getName(), TyDIE, Flags);
1012 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1013 Context.isNameSpace()) &&
1014 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1015 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
1020 /// addType - Add a new type attribute to the specified entity.
1021 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
1022 assert(Ty && "Trying to add a type that doesn't exist?");
1024 // Check for pre-existence.
1025 DIEEntry *Entry = getDIEEntry(Ty);
1026 // If it exists then use the existing value.
1028 addDIEEntry(Entity, Attribute, Entry);
1033 DIE *Buffer = getOrCreateTypeDIE(Ty);
1036 Entry = createDIEEntry(*Buffer);
1037 insertDIEEntry(Ty, Entry);
1038 addDIEEntry(Entity, Attribute, Entry);
1041 /// addGlobalName - Add a new global name to the compile unit.
1042 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1043 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1045 std::string FullName = getParentContextString(Context) + Name.str();
1046 GlobalNames[FullName] = &Die;
1049 /// getParentContextString - Walks the metadata parent chain in a language
1050 /// specific manner (using the compile unit language) and returns
1051 /// it as a string. This is done at the metadata level because DIEs may
1052 /// not currently have been added to the parent context and walking the
1053 /// DIEs looking for names is more expensive than walking the metadata.
1054 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1058 // FIXME: Decide whether to implement this for non-C++ languages.
1059 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1063 SmallVector<DIScope, 1> Parents;
1064 while (!Context.isCompileUnit()) {
1065 Parents.push_back(Context);
1066 if (Context.getContext())
1067 Context = resolve(Context.getContext());
1069 // Structure, etc types will have a NULL context if they're at the top
1074 // Reverse iterate over our list to go from the outermost construct to the
1076 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1080 StringRef Name = Ctx.getName();
1081 if (!Name.empty()) {
1089 /// constructTypeDIE - Construct basic type die from DIBasicType.
1090 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1091 // Get core information.
1092 StringRef Name = BTy.getName();
1093 // Add name if not anonymous or intermediate type.
1095 addString(Buffer, dwarf::DW_AT_name, Name);
1097 // An unspecified type only has a name attribute.
1098 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1101 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1104 uint64_t Size = BTy.getSizeInBits() >> 3;
1105 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1108 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1109 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1110 // Get core information.
1111 StringRef Name = DTy.getName();
1112 uint64_t Size = DTy.getSizeInBits() >> 3;
1113 uint16_t Tag = Buffer.getTag();
1115 // Map to main type, void will not have a type.
1116 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1118 addType(Buffer, FromTy);
1120 // Add name if not anonymous or intermediate type.
1122 addString(Buffer, dwarf::DW_AT_name, Name);
1124 // Add size if non-zero (derived types might be zero-sized.)
1125 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1126 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1128 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1129 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1130 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1131 // Add source line info if available and TyDesc is not a forward declaration.
1132 if (!DTy.isForwardDecl())
1133 addSourceLine(Buffer, DTy);
1136 /// constructSubprogramArguments - Construct function argument DIEs.
1137 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1138 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1139 DIDescriptor Ty = Args.getElement(i);
1140 if (Ty.isUnspecifiedParameter()) {
1141 assert(i == N-1 && "Unspecified parameter must be the last argument");
1142 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1144 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1145 addType(Arg, DIType(Ty));
1146 if (DIType(Ty).isArtificial())
1147 addFlag(Arg, dwarf::DW_AT_artificial);
1152 /// constructTypeDIE - Construct type DIE from DICompositeType.
1153 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1154 // Add name if not anonymous or intermediate type.
1155 StringRef Name = CTy.getName();
1157 uint64_t Size = CTy.getSizeInBits() >> 3;
1158 uint16_t Tag = Buffer.getTag();
1161 case dwarf::DW_TAG_array_type:
1162 constructArrayTypeDIE(Buffer, CTy);
1164 case dwarf::DW_TAG_enumeration_type:
1165 constructEnumTypeDIE(Buffer, CTy);
1167 case dwarf::DW_TAG_subroutine_type: {
1168 // Add return type. A void return won't have a type.
1169 DIArray Elements = CTy.getTypeArray();
1170 DIType RTy(Elements.getElement(0));
1172 addType(Buffer, RTy);
1174 bool isPrototyped = true;
1175 if (Elements.getNumElements() == 2 &&
1176 Elements.getElement(1).isUnspecifiedParameter())
1177 isPrototyped = false;
1179 constructSubprogramArguments(Buffer, Elements);
1181 // Add prototype flag if we're dealing with a C language and the
1182 // function has been prototyped.
1183 uint16_t Language = getLanguage();
1185 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1186 Language == dwarf::DW_LANG_ObjC))
1187 addFlag(Buffer, dwarf::DW_AT_prototyped);
1189 if (CTy.isLValueReference())
1190 addFlag(Buffer, dwarf::DW_AT_reference);
1192 if (CTy.isRValueReference())
1193 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1195 case dwarf::DW_TAG_structure_type:
1196 case dwarf::DW_TAG_union_type:
1197 case dwarf::DW_TAG_class_type: {
1198 // Add elements to structure type.
1199 DIArray Elements = CTy.getTypeArray();
1200 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1201 DIDescriptor Element = Elements.getElement(i);
1202 if (Element.isSubprogram())
1203 getOrCreateSubprogramDIE(DISubprogram(Element));
1204 else if (Element.isDerivedType()) {
1205 DIDerivedType DDTy(Element);
1206 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1207 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1208 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1209 dwarf::DW_AT_friend);
1210 } else if (DDTy.isStaticMember()) {
1211 getOrCreateStaticMemberDIE(DDTy);
1213 constructMemberDIE(Buffer, DDTy);
1215 } else if (Element.isObjCProperty()) {
1216 DIObjCProperty Property(Element);
1217 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1218 StringRef PropertyName = Property.getObjCPropertyName();
1219 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1220 if (Property.getType())
1221 addType(ElemDie, Property.getType());
1222 addSourceLine(ElemDie, Property);
1223 StringRef GetterName = Property.getObjCPropertyGetterName();
1224 if (!GetterName.empty())
1225 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1226 StringRef SetterName = Property.getObjCPropertySetterName();
1227 if (!SetterName.empty())
1228 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1229 unsigned PropertyAttributes = 0;
1230 if (Property.isReadOnlyObjCProperty())
1231 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1232 if (Property.isReadWriteObjCProperty())
1233 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1234 if (Property.isAssignObjCProperty())
1235 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1236 if (Property.isRetainObjCProperty())
1237 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1238 if (Property.isCopyObjCProperty())
1239 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1240 if (Property.isNonAtomicObjCProperty())
1241 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1242 if (PropertyAttributes)
1243 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1244 PropertyAttributes);
1246 DIEEntry *Entry = getDIEEntry(Element);
1248 Entry = createDIEEntry(ElemDie);
1249 insertDIEEntry(Element, Entry);
1255 if (CTy.isAppleBlockExtension())
1256 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1258 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1260 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1261 *getOrCreateTypeDIE(ContainingType));
1263 if (CTy.isObjcClassComplete())
1264 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1266 // Add template parameters to a class, structure or union types.
1267 // FIXME: The support isn't in the metadata for this yet.
1268 if (Tag == dwarf::DW_TAG_class_type ||
1269 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1270 addTemplateParams(Buffer, CTy.getTemplateParams());
1278 // Add name if not anonymous or intermediate type.
1280 addString(Buffer, dwarf::DW_AT_name, Name);
1282 if (Tag == dwarf::DW_TAG_enumeration_type ||
1283 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1284 Tag == dwarf::DW_TAG_union_type) {
1285 // Add size if non-zero (derived types might be zero-sized.)
1286 // TODO: Do we care about size for enum forward declarations?
1288 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1289 else if (!CTy.isForwardDecl())
1290 // Add zero size if it is not a forward declaration.
1291 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1293 // If we're a forward decl, say so.
1294 if (CTy.isForwardDecl())
1295 addFlag(Buffer, dwarf::DW_AT_declaration);
1297 // Add source line info if available.
1298 if (!CTy.isForwardDecl())
1299 addSourceLine(Buffer, CTy);
1301 // No harm in adding the runtime language to the declaration.
1302 unsigned RLang = CTy.getRunTimeLang();
1304 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1309 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1310 /// DITemplateTypeParameter.
1311 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1312 DITemplateTypeParameter TP) {
1314 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1315 // Add the type if it exists, it could be void and therefore no type.
1317 addType(ParamDIE, resolve(TP.getType()));
1318 if (!TP.getName().empty())
1319 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1322 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1323 /// DITemplateValueParameter.
1325 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1326 DITemplateValueParameter VP) {
1327 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1329 // Add the type if there is one, template template and template parameter
1330 // packs will not have a type.
1331 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1332 addType(ParamDIE, resolve(VP.getType()));
1333 if (!VP.getName().empty())
1334 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1335 if (Value *Val = VP.getValue()) {
1336 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1337 addConstantValue(ParamDIE, CI,
1338 isUnsignedDIType(DD, resolve(VP.getType())));
1339 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1340 // For declaration non-type template parameters (such as global values and
1342 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1343 addOpAddress(*Loc, Asm->getSymbol(GV));
1344 // Emit DW_OP_stack_value to use the address as the immediate value of the
1345 // parameter, rather than a pointer to it.
1346 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1347 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1348 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1349 assert(isa<MDString>(Val));
1350 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1351 cast<MDString>(Val)->getString());
1352 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1353 assert(isa<MDNode>(Val));
1354 DIArray A(cast<MDNode>(Val));
1355 addTemplateParams(ParamDIE, A);
1360 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1361 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1362 // Construct the context before querying for the existence of the DIE in case
1363 // such construction creates the DIE.
1364 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1366 if (DIE *NDie = getDIE(NS))
1368 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1370 if (!NS.getName().empty()) {
1371 addString(NDie, dwarf::DW_AT_name, NS.getName());
1372 DD->addAccelNamespace(NS.getName(), NDie);
1373 addGlobalName(NS.getName(), NDie, NS.getContext());
1375 DD->addAccelNamespace("(anonymous namespace)", NDie);
1376 addSourceLine(NDie, NS);
1380 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1381 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1382 // Construct the context before querying for the existence of the DIE in case
1383 // such construction creates the DIE (as is the case for member function
1385 DIScope Context = resolve(SP.getContext());
1386 DIE *ContextDIE = getOrCreateContextDIE(Context);
1388 // Unique declarations based on the ODR, where applicable.
1389 SP = DISubprogram(DD->resolve(SP.getRef()));
1390 assert(SP.Verify());
1392 if (DIE *SPDie = getDIE(SP))
1395 DISubprogram SPDecl = SP.getFunctionDeclaration();
1396 if (SPDecl.isSubprogram())
1397 // Add subprogram definitions to the CU die directly.
1398 ContextDIE = &getUnitDie();
1400 // DW_TAG_inlined_subroutine may refer to this DIE.
1401 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1403 DIE *DeclDie = nullptr;
1404 if (SPDecl.isSubprogram())
1405 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1407 // Add function template parameters.
1408 addTemplateParams(SPDie, SP.getTemplateParams());
1411 // Refer function declaration directly.
1412 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1414 // Add the linkage name if we have one and it isn't in the Decl.
1415 StringRef LinkageName = SP.getLinkageName();
1416 if (!LinkageName.empty()) {
1417 if (SPDecl.isSubprogram() && !SPDecl.getLinkageName().empty())
1418 assert(SPDecl.getLinkageName() == SP.getLinkageName() &&
1419 "decl has a linkage name and it is different");
1421 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1422 GlobalValue::getRealLinkageName(LinkageName));
1425 // If this DIE is going to refer declaration info using AT_specification
1426 // then there is no need to add other attributes.
1430 // Constructors and operators for anonymous aggregates do not have names.
1431 if (!SP.getName().empty())
1432 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1434 addSourceLine(SPDie, SP);
1436 // Add the prototype if we have a prototype and we have a C like
1438 uint16_t Language = getLanguage();
1439 if (SP.isPrototyped() &&
1440 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1441 Language == dwarf::DW_LANG_ObjC))
1442 addFlag(SPDie, dwarf::DW_AT_prototyped);
1444 DICompositeType SPTy = SP.getType();
1445 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1446 "the type of a subprogram should be a subroutine");
1448 DIArray Args = SPTy.getTypeArray();
1449 // Add a return type. If this is a type like a C/C++ void type we don't add a
1451 if (Args.getElement(0))
1452 addType(SPDie, DIType(Args.getElement(0)));
1454 unsigned VK = SP.getVirtuality();
1456 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1457 DIELoc *Block = getDIELoc();
1458 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1459 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1460 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1461 ContainingTypeMap.insert(
1462 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1465 if (!SP.isDefinition()) {
1466 addFlag(SPDie, dwarf::DW_AT_declaration);
1468 // Add arguments. Do not add arguments for subprogram definition. They will
1469 // be handled while processing variables.
1470 constructSubprogramArguments(SPDie, Args);
1473 if (SP.isArtificial())
1474 addFlag(SPDie, dwarf::DW_AT_artificial);
1476 if (!SP.isLocalToUnit())
1477 addFlag(SPDie, dwarf::DW_AT_external);
1479 if (SP.isOptimized())
1480 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1482 if (unsigned isa = Asm->getISAEncoding()) {
1483 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1486 if (SP.isLValueReference())
1487 addFlag(SPDie, dwarf::DW_AT_reference);
1489 if (SP.isRValueReference())
1490 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1492 if (SP.isProtected())
1493 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1494 dwarf::DW_ACCESS_protected);
1495 else if (SP.isPrivate())
1496 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1497 dwarf::DW_ACCESS_private);
1499 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1500 dwarf::DW_ACCESS_public);
1502 if (SP.isExplicit())
1503 addFlag(SPDie, dwarf::DW_AT_explicit);
1508 // Return const expression if value is a GEP to access merged global
1510 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1511 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1512 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1513 if (!CE || CE->getNumOperands() != 3 ||
1514 CE->getOpcode() != Instruction::GetElementPtr)
1517 // First operand points to a global struct.
1518 Value *Ptr = CE->getOperand(0);
1519 if (!isa<GlobalValue>(Ptr) ||
1520 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1523 // Second operand is zero.
1524 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1525 if (!CI || !CI->isZero())
1528 // Third operand is offset.
1529 if (!isa<ConstantInt>(CE->getOperand(2)))
1535 /// createGlobalVariableDIE - create global variable DIE.
1536 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1537 // Check for pre-existence.
1541 assert(GV.isGlobalVariable());
1543 DIScope GVContext = GV.getContext();
1544 DIType GTy = DD->resolve(GV.getType());
1546 // If this is a static data member definition, some attributes belong
1547 // to the declaration DIE.
1548 DIE *VariableDIE = nullptr;
1549 bool IsStaticMember = false;
1550 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1551 if (SDMDecl.Verify()) {
1552 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1553 // We need the declaration DIE that is in the static member's class.
1554 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1555 IsStaticMember = true;
1558 // If this is not a static data member definition, create the variable
1559 // DIE and add the initial set of attributes to it.
1561 // Construct the context before querying for the existence of the DIE in
1562 // case such construction creates the DIE.
1563 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1566 VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1568 // Add name and type.
1569 addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1570 addType(*VariableDIE, GTy);
1572 // Add scoping info.
1573 if (!GV.isLocalToUnit())
1574 addFlag(*VariableDIE, dwarf::DW_AT_external);
1576 // Add line number info.
1577 addSourceLine(*VariableDIE, GV);
1581 bool addToAccelTable = false;
1582 DIE *VariableSpecDIE = nullptr;
1583 bool isGlobalVariable = GV.getGlobal() != nullptr;
1584 if (isGlobalVariable) {
1585 addToAccelTable = true;
1586 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1587 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1588 if (GV.getGlobal()->isThreadLocal()) {
1589 // FIXME: Make this work with -gsplit-dwarf.
1590 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1591 assert((PointerSize == 4 || PointerSize == 8) &&
1592 "Add support for other sizes if necessary");
1593 // Based on GCC's support for TLS:
1594 if (!DD->useSplitDwarf()) {
1595 // 1) Start with a constNu of the appropriate pointer size
1596 addUInt(*Loc, dwarf::DW_FORM_data1,
1597 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1598 // 2) containing the (relocated) offset of the TLS variable
1599 // within the module's TLS block.
1600 addExpr(*Loc, dwarf::DW_FORM_udata,
1601 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1603 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1604 addUInt(*Loc, dwarf::DW_FORM_udata,
1605 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
1607 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1608 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1610 DD->addArangeLabel(SymbolCU(this, Sym));
1611 addOpAddress(*Loc, Sym);
1613 // Do not create specification DIE if context is either compile unit
1615 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1616 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1617 // Create specification DIE.
1618 VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie);
1619 addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE);
1620 addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc);
1621 // A static member's declaration is already flagged as such.
1622 if (!SDMDecl.Verify())
1623 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
1625 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1627 // Add the linkage name.
1628 StringRef LinkageName = GV.getLinkageName();
1629 if (!LinkageName.empty())
1630 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1631 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1633 addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE
1635 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1636 : dwarf::DW_AT_MIPS_linkage_name,
1637 GlobalValue::getRealLinkageName(LinkageName));
1638 } else if (const ConstantInt *CI =
1639 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1640 // AT_const_value was added when the static member was created. To avoid
1641 // emitting AT_const_value multiple times, we only add AT_const_value when
1642 // it is not a static member.
1643 if (!IsStaticMember)
1644 addConstantValue(*VariableDIE, CI, isUnsignedDIType(DD, GTy));
1645 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1646 addToAccelTable = true;
1647 // GV is a merged global.
1648 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1649 Value *Ptr = CE->getOperand(0);
1650 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1651 DD->addArangeLabel(SymbolCU(this, Sym));
1652 addOpAddress(*Loc, Sym);
1653 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1654 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1655 addUInt(*Loc, dwarf::DW_FORM_udata,
1656 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1657 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1658 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1661 if (addToAccelTable) {
1662 DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE;
1663 DD->addAccelName(GV.getName(), AddrDIE);
1665 // If the linkage name is different than the name, go ahead and output
1666 // that as well into the name table.
1667 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1668 DD->addAccelName(GV.getLinkageName(), AddrDIE);
1671 if (!GV.isLocalToUnit())
1672 addGlobalName(GV.getName(),
1673 VariableSpecDIE ? *VariableSpecDIE : *VariableDIE,
1677 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1678 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1679 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1680 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1682 // The LowerBound value defines the lower bounds which is typically zero for
1683 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1684 // Count == -1 then the array is unbounded and we do not emit
1685 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1686 // Count == 0, then the array has zero elements in which case we do not emit
1688 int64_t LowerBound = SR.getLo();
1689 int64_t DefaultLowerBound = getDefaultLowerBound();
1690 int64_t Count = SR.getCount();
1692 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1693 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1695 if (Count != -1 && Count != 0)
1696 // FIXME: An unbounded array should reference the expression that defines
1698 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1699 LowerBound + Count - 1);
1702 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1703 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1705 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1707 // Emit the element type.
1708 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1710 // Get an anonymous type for index type.
1711 // FIXME: This type should be passed down from the front end
1712 // as different languages may have different sizes for indexes.
1713 DIE *IdxTy = getIndexTyDie();
1715 // Construct an integer type to use for indexes.
1716 IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1717 addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1718 addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1719 addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1720 dwarf::DW_ATE_unsigned);
1721 setIndexTyDie(IdxTy);
1724 // Add subranges to array type.
1725 DIArray Elements = CTy.getTypeArray();
1726 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1727 DIDescriptor Element = Elements.getElement(i);
1728 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1729 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1733 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1734 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1735 DIArray Elements = CTy.getTypeArray();
1737 // Add enumerators to enumeration type.
1738 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1739 DIEnumerator Enum(Elements.getElement(i));
1740 if (Enum.isEnumerator()) {
1741 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1742 StringRef Name = Enum.getName();
1743 addString(Enumerator, dwarf::DW_AT_name, Name);
1744 int64_t Value = Enum.getEnumValue();
1745 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1749 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1751 addType(Buffer, DTy);
1752 addFlag(Buffer, dwarf::DW_AT_enum_class);
1756 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1758 void DwarfUnit::constructContainingTypeDIEs() {
1759 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1760 CE = ContainingTypeMap.end();
1762 DIE &SPDie = *CI->first;
1763 DIDescriptor D(CI->second);
1766 DIE *NDie = getDIE(D);
1769 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1773 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1774 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
1775 AbstractOrInlined AbsIn) {
1776 auto D = constructVariableDIEImpl(DV, AbsIn);
1781 std::unique_ptr<DIE>
1782 DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
1783 AbstractOrInlined AbsIn) {
1784 StringRef Name = DV.getName();
1786 // Define variable debug information entry.
1787 auto VariableDie = make_unique<DIE>(DV.getTag());
1788 DbgVariable *AbsVar = DV.getAbstractVariable();
1789 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : nullptr;
1791 addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, *AbsDIE);
1794 addString(*VariableDie, dwarf::DW_AT_name, Name);
1795 addSourceLine(*VariableDie, DV.getVariable());
1796 addType(*VariableDie, DV.getType());
1799 if (AbsIn != AOI_Inlined && DV.isArtificial())
1800 addFlag(*VariableDie, dwarf::DW_AT_artificial);
1802 if (AbsIn == AOI_Abstract)
1805 // Add variable address.
1807 unsigned Offset = DV.getDotDebugLocOffset();
1808 if (Offset != ~0U) {
1809 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
1813 // Check if variable is described by a DBG_VALUE instruction.
1814 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1815 assert(DVInsn->getNumOperands() == 3);
1816 if (DVInsn->getOperand(0).isReg()) {
1817 const MachineOperand RegOp = DVInsn->getOperand(0);
1818 // If the second operand is an immediate, this is an indirect value.
1819 if (DVInsn->getOperand(1).isImm()) {
1820 MachineLocation Location(RegOp.getReg(),
1821 DVInsn->getOperand(1).getImm());
1822 addVariableAddress(DV, *VariableDie, Location);
1823 } else if (RegOp.getReg())
1824 addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
1825 } else if (DVInsn->getOperand(0).isImm())
1826 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
1827 else if (DVInsn->getOperand(0).isFPImm())
1828 addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
1829 else if (DVInsn->getOperand(0).isCImm())
1830 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
1831 isUnsignedDIType(DD, DV.getType()));
1836 // .. else use frame index.
1837 int FI = DV.getFrameIndex();
1839 unsigned FrameReg = 0;
1840 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1841 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1842 MachineLocation Location(FrameReg, Offset);
1843 addVariableAddress(DV, *VariableDie, Location);
1849 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1850 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1851 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1852 StringRef Name = DT.getName();
1854 addString(MemberDie, dwarf::DW_AT_name, Name);
1856 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1858 addSourceLine(MemberDie, DT);
1860 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1862 // For C++, virtual base classes are not at fixed offset. Use following
1863 // expression to extract appropriate offset from vtable.
1864 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1866 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1867 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1868 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1869 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1870 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1871 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1872 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1873 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1875 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1877 uint64_t Size = DT.getSizeInBits();
1878 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1879 uint64_t OffsetInBytes;
1881 if (Size != FieldSize) {
1882 // Handle bitfield, assume bytes are 8 bits.
1883 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1884 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1886 uint64_t Offset = DT.getOffsetInBits();
1887 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1888 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1889 uint64_t FieldOffset = (HiMark - FieldSize);
1890 Offset -= FieldOffset;
1892 // Maybe we need to work from the other end.
1893 if (Asm->getDataLayout().isLittleEndian())
1894 Offset = FieldSize - (Offset + Size);
1895 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1897 // Here DW_AT_data_member_location points to the anonymous
1898 // field that includes this bit field.
1899 OffsetInBytes = FieldOffset >> 3;
1901 // This is not a bitfield.
1902 OffsetInBytes = DT.getOffsetInBits() >> 3;
1904 if (DD->getDwarfVersion() <= 2) {
1905 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1906 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1907 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1908 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1910 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1914 if (DT.isProtected())
1915 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1916 dwarf::DW_ACCESS_protected);
1917 else if (DT.isPrivate())
1918 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1919 dwarf::DW_ACCESS_private);
1920 // Otherwise C++ member and base classes are considered public.
1922 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1923 dwarf::DW_ACCESS_public);
1925 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1926 dwarf::DW_VIRTUALITY_virtual);
1928 // Objective-C properties.
1929 if (MDNode *PNode = DT.getObjCProperty())
1930 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1931 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1934 if (DT.isArtificial())
1935 addFlag(MemberDie, dwarf::DW_AT_artificial);
1938 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1939 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1943 // Construct the context before querying for the existence of the DIE in case
1944 // such construction creates the DIE.
1945 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1946 assert(dwarf::isType(ContextDIE->getTag()) &&
1947 "Static member should belong to a type.");
1949 if (DIE *StaticMemberDIE = getDIE(DT))
1950 return StaticMemberDIE;
1952 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1954 DIType Ty = resolve(DT.getTypeDerivedFrom());
1956 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1957 addType(StaticMemberDIE, Ty);
1958 addSourceLine(StaticMemberDIE, DT);
1959 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1960 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1962 // FIXME: We could omit private if the parent is a class_type, and
1963 // public if the parent is something else.
1964 if (DT.isProtected())
1965 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1966 dwarf::DW_ACCESS_protected);
1967 else if (DT.isPrivate())
1968 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1969 dwarf::DW_ACCESS_private);
1971 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1972 dwarf::DW_ACCESS_public);
1974 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1975 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1976 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1977 addConstantFPValue(StaticMemberDIE, CFP);
1979 return &StaticMemberDIE;
1982 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1983 Asm->OutStreamer.AddComment("DWARF version number");
1984 Asm->EmitInt16(DD->getDwarfVersion());
1985 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1986 // We share one abbreviations table across all units so it's always at the
1987 // start of the section. Use a relocatable offset where needed to ensure
1988 // linking doesn't invalidate that offset.
1990 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1992 // Use a constant value when no symbol is provided.
1994 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1995 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1998 void DwarfUnit::addRange(RangeSpan Range) {
1999 // Only add a range for this unit if we're emitting full debug.
2000 if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
2001 // If we have no current ranges just add the range and return, otherwise,
2002 // check the current section and CU against the previous section and CU we
2003 // emitted into and the subprogram was contained within. If these are the
2004 // same then extend our current range, otherwise add this as a new range.
2005 if (CURanges.size() == 0 ||
2006 this != DD->getPrevCU() ||
2007 Asm->getCurrentSection() != DD->getPrevSection()) {
2008 CURanges.push_back(Range);
2012 assert(&(CURanges.back().getEnd()->getSection()) ==
2013 &(Range.getEnd()->getSection()) &&
2014 "We can only append to a range in the same section!");
2015 CURanges.back().setEnd(Range.getEnd());
2019 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2020 // Define start line table label for each Compile Unit.
2021 MCSymbol *LineTableStartSym =
2022 Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
2024 stmtListIndex = UnitDie.getValues().size();
2026 // DW_AT_stmt_list is a offset of line number information for this
2027 // compile unit in debug_line section. For split dwarf this is
2028 // left in the skeleton CU and so not included.
2029 // The line table entries are not always emitted in assembly, so it
2030 // is not okay to use line_table_start here.
2031 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2032 addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym);
2034 addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
2035 DwarfLineSectionSym);
2038 void DwarfCompileUnit::applyStmtList(DIE &D) {
2039 D.addValue(dwarf::DW_AT_stmt_list,
2040 UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
2041 UnitDie.getValues()[stmtListIndex]);
2044 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2045 DwarfUnit::emitHeader(ASectionSym);
2046 Asm->OutStreamer.AddComment("Type Signature");
2047 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2048 Asm->OutStreamer.AddComment("Type DIE Offset");
2049 // In a skeleton type unit there is no type DIE so emit a zero offset.
2050 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2051 sizeof(Ty->getOffset()));
2054 void DwarfTypeUnit::initSection(const MCSection *Section) {
2055 assert(!this->Section);
2056 this->Section = Section;
2057 // Since each type unit is contained in its own COMDAT section, the begin
2058 // label and the section label are the same. Using the begin label emission in
2059 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2060 // the only other alternative of lazily constructing start-of-section labels
2061 // and storing a mapping in DwarfDebug (or AsmPrinter).
2062 this->SectionSym = this->LabelBegin =
2063 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2065 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());