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, int *SizeInBits) {
750 if (Ty.isDerivedType())
751 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
753 if (Ty.isBasicType())
754 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
755 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
756 *SizeInBits = Ty.getSizeInBits();
762 /// Return true if type encoding is unsigned.
763 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
764 DIDerivedType DTy(Ty);
765 if (DTy.isDerivedType())
766 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
769 if (BTy.isBasicType()) {
770 unsigned Encoding = BTy.getEncoding();
771 if (Encoding == dwarf::DW_ATE_unsigned ||
772 Encoding == dwarf::DW_ATE_unsigned_char ||
773 Encoding == dwarf::DW_ATE_boolean)
779 /// If this type is derived from a base type then return base type size.
780 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
781 unsigned Tag = Ty.getTag();
783 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
784 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
785 Tag != dwarf::DW_TAG_restrict_type)
786 return Ty.getSizeInBits();
788 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
790 // If this type is not derived from any type or the type is a declaration then
791 // take conservative approach.
792 if (!BaseType.isValid() || BaseType.isForwardDecl())
793 return Ty.getSizeInBits();
795 // If this is a derived type, go ahead and get the base type, unless it's a
796 // reference then it's just the size of the field. Pointer types have no need
797 // of this since they're a different type of qualification on the type.
798 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
799 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
800 return Ty.getSizeInBits();
802 if (BaseType.isDerivedType())
803 return getBaseTypeSize(DD, DIDerivedType(BaseType));
805 return BaseType.getSizeInBits();
808 /// addConstantValue - Add constant value entry in variable DIE.
809 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
811 // FIXME: This is a bit conservative/simple - it emits negative values at
812 // their maximum bit width which is a bit unfortunate (& doesn't prefer
813 // udata/sdata over dataN as suggested by the DWARF spec)
814 assert(MO.isImm() && "Invalid machine operand!");
816 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
819 // If we're a signed constant definitely use sdata.
820 if (SignedConstant) {
821 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
825 // Else use data for now unless it's larger than we can deal with.
826 switch (SizeInBits) {
828 Form = dwarf::DW_FORM_data1;
831 Form = dwarf::DW_FORM_data2;
834 Form = dwarf::DW_FORM_data4;
837 Form = dwarf::DW_FORM_data8;
840 Form = dwarf::DW_FORM_udata;
841 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
844 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
847 /// addConstantFPValue - Add constant value entry in variable DIE.
848 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
849 assert(MO.isFPImm() && "Invalid machine operand!");
850 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
851 APFloat FPImm = MO.getFPImm()->getValueAPF();
853 // Get the raw data form of the floating point.
854 const APInt FltVal = FPImm.bitcastToAPInt();
855 const char *FltPtr = (const char *)FltVal.getRawData();
857 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
858 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
859 int Incr = (LittleEndian ? 1 : -1);
860 int Start = (LittleEndian ? 0 : NumBytes - 1);
861 int Stop = (LittleEndian ? NumBytes : -1);
863 // Output the constant to DWARF one byte at a time.
864 for (; Start != Stop; Start += Incr)
865 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
867 addBlock(Die, dwarf::DW_AT_const_value, Block);
870 /// addConstantFPValue - Add constant value entry in variable DIE.
871 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
872 // Pass this down to addConstantValue as an unsigned bag of bits.
873 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
876 /// addConstantValue - Add constant value entry in variable DIE.
877 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
879 addConstantValue(Die, CI->getValue(), Unsigned);
882 // addConstantValue - Add constant value entry in variable DIE.
883 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
884 unsigned CIBitWidth = Val.getBitWidth();
885 if (CIBitWidth <= 64) {
886 // If we're a signed constant definitely use sdata.
888 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
893 // Else use data for now unless it's larger than we can deal with.
895 switch (CIBitWidth) {
897 Form = dwarf::DW_FORM_data1;
900 Form = dwarf::DW_FORM_data2;
903 Form = dwarf::DW_FORM_data4;
906 Form = dwarf::DW_FORM_data8;
909 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
913 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
917 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
919 // Get the raw data form of the large APInt.
920 const uint64_t *Ptr64 = Val.getRawData();
922 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
923 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
925 // Output the constant to DWARF one byte at a time.
926 for (int i = 0; i < NumBytes; i++) {
929 c = Ptr64[i / 8] >> (8 * (i & 7));
931 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
932 addUInt(*Block, dwarf::DW_FORM_data1, c);
935 addBlock(Die, dwarf::DW_AT_const_value, Block);
938 /// addTemplateParams - Add template parameters into buffer.
939 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
940 // Add template parameters.
941 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
942 DIDescriptor Element = TParams.getElement(i);
943 if (Element.isTemplateTypeParameter())
944 constructTemplateTypeParameterDIE(Buffer,
945 DITemplateTypeParameter(Element));
946 else if (Element.isTemplateValueParameter())
947 constructTemplateValueParameterDIE(Buffer,
948 DITemplateValueParameter(Element));
952 /// getOrCreateContextDIE - Get context owner's DIE.
953 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
954 if (!Context || Context.isFile())
955 return &getUnitDie();
956 if (Context.isType())
957 return getOrCreateTypeDIE(DIType(Context));
958 if (Context.isNameSpace())
959 return getOrCreateNameSpace(DINameSpace(Context));
960 if (Context.isSubprogram())
961 return getOrCreateSubprogramDIE(DISubprogram(Context));
962 return getDIE(Context);
965 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
966 DIScope Context = resolve(Ty.getContext());
967 DIE *ContextDIE = getOrCreateContextDIE(Context);
969 if (DIE *TyDIE = getDIE(Ty))
973 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
975 constructTypeDIE(TyDIE, Ty);
977 updateAcceleratorTables(Context, Ty, TyDIE);
981 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
983 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
989 assert(Ty == resolve(Ty.getRef()) &&
990 "type was not uniqued, possible ODR violation.");
992 // DW_TAG_restrict_type is not supported in DWARF2
993 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
994 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
996 // Construct the context before querying for the existence of the DIE in case
997 // such construction creates the DIE.
998 DIScope Context = resolve(Ty.getContext());
999 DIE *ContextDIE = getOrCreateContextDIE(Context);
1002 if (DIE *TyDIE = getDIE(Ty))
1006 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
1008 updateAcceleratorTables(Context, Ty, TyDIE);
1010 if (Ty.isBasicType())
1011 constructTypeDIE(TyDIE, DIBasicType(Ty));
1012 else if (Ty.isCompositeType()) {
1013 DICompositeType CTy(Ty);
1014 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
1015 if (MDString *TypeId = CTy.getIdentifier()) {
1016 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
1017 // Skip updating the accelerator tables since this is not the full type.
1020 constructTypeDIE(TyDIE, CTy);
1022 assert(Ty.isDerivedType() && "Unknown kind of DIType");
1023 constructTypeDIE(TyDIE, DIDerivedType(Ty));
1029 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
1031 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
1032 bool IsImplementation = 0;
1033 if (Ty.isCompositeType()) {
1034 DICompositeType CT(Ty);
1035 // A runtime language of 0 actually means C/C++ and that any
1036 // non-negative value is some version of Objective-C/C++.
1037 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1039 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1040 DD->addAccelType(Ty.getName(), TyDIE, Flags);
1042 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1043 Context.isNameSpace()) &&
1044 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1045 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
1050 /// addType - Add a new type attribute to the specified entity.
1051 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
1052 assert(Ty && "Trying to add a type that doesn't exist?");
1054 // Check for pre-existence.
1055 DIEEntry *Entry = getDIEEntry(Ty);
1056 // If it exists then use the existing value.
1058 addDIEEntry(Entity, Attribute, Entry);
1063 DIE *Buffer = getOrCreateTypeDIE(Ty);
1066 Entry = createDIEEntry(*Buffer);
1067 insertDIEEntry(Ty, Entry);
1068 addDIEEntry(Entity, Attribute, Entry);
1071 /// addGlobalName - Add a new global name to the compile unit.
1072 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1073 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1075 std::string FullName = getParentContextString(Context) + Name.str();
1076 GlobalNames[FullName] = &Die;
1079 /// getParentContextString - Walks the metadata parent chain in a language
1080 /// specific manner (using the compile unit language) and returns
1081 /// it as a string. This is done at the metadata level because DIEs may
1082 /// not currently have been added to the parent context and walking the
1083 /// DIEs looking for names is more expensive than walking the metadata.
1084 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1088 // FIXME: Decide whether to implement this for non-C++ languages.
1089 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1093 SmallVector<DIScope, 1> Parents;
1094 while (!Context.isCompileUnit()) {
1095 Parents.push_back(Context);
1096 if (Context.getContext())
1097 Context = resolve(Context.getContext());
1099 // Structure, etc types will have a NULL context if they're at the top
1104 // Reverse iterate over our list to go from the outermost construct to the
1106 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1110 StringRef Name = Ctx.getName();
1111 if (!Name.empty()) {
1119 /// constructTypeDIE - Construct basic type die from DIBasicType.
1120 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1121 // Get core information.
1122 StringRef Name = BTy.getName();
1123 // Add name if not anonymous or intermediate type.
1125 addString(Buffer, dwarf::DW_AT_name, Name);
1127 // An unspecified type only has a name attribute.
1128 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1131 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1134 uint64_t Size = BTy.getSizeInBits() >> 3;
1135 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1138 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1139 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1140 // Get core information.
1141 StringRef Name = DTy.getName();
1142 uint64_t Size = DTy.getSizeInBits() >> 3;
1143 uint16_t Tag = Buffer.getTag();
1145 // Map to main type, void will not have a type.
1146 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1148 addType(Buffer, FromTy);
1150 // Add name if not anonymous or intermediate type.
1152 addString(Buffer, dwarf::DW_AT_name, Name);
1154 // Add size if non-zero (derived types might be zero-sized.)
1155 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1156 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1158 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1159 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1160 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1161 // Add source line info if available and TyDesc is not a forward declaration.
1162 if (!DTy.isForwardDecl())
1163 addSourceLine(Buffer, DTy);
1166 /// constructSubprogramArguments - Construct function argument DIEs.
1167 DIE *DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1168 DIE *ObjectPointer = nullptr;
1169 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1170 DIDescriptor Ty = Args.getElement(i);
1171 if (Ty.isUnspecifiedParameter()) {
1172 assert(i == N-1 && "Unspecified parameter must be the last argument");
1173 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1175 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1176 addType(Arg, DIType(Ty));
1177 if (DIType(Ty).isArtificial())
1178 addFlag(Arg, dwarf::DW_AT_artificial);
1179 if (DIType(Ty).isObjectPointer())
1180 ObjectPointer = &Arg;
1183 return ObjectPointer;
1186 /// constructTypeDIE - Construct type DIE from DICompositeType.
1187 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1188 // Add name if not anonymous or intermediate type.
1189 StringRef Name = CTy.getName();
1191 uint64_t Size = CTy.getSizeInBits() >> 3;
1192 uint16_t Tag = Buffer.getTag();
1195 case dwarf::DW_TAG_array_type:
1196 constructArrayTypeDIE(Buffer, CTy);
1198 case dwarf::DW_TAG_enumeration_type:
1199 constructEnumTypeDIE(Buffer, CTy);
1201 case dwarf::DW_TAG_subroutine_type: {
1202 // Add return type. A void return won't have a type.
1203 DIArray Elements = CTy.getTypeArray();
1204 DIType RTy(Elements.getElement(0));
1206 addType(Buffer, RTy);
1208 bool isPrototyped = true;
1209 if (Elements.getNumElements() == 2 &&
1210 Elements.getElement(1).isUnspecifiedParameter())
1211 isPrototyped = false;
1213 constructSubprogramArguments(Buffer, Elements);
1215 // Add prototype flag if we're dealing with a C language and the
1216 // function has been prototyped.
1217 uint16_t Language = getLanguage();
1219 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1220 Language == dwarf::DW_LANG_ObjC))
1221 addFlag(Buffer, dwarf::DW_AT_prototyped);
1223 if (CTy.isLValueReference())
1224 addFlag(Buffer, dwarf::DW_AT_reference);
1226 if (CTy.isRValueReference())
1227 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1229 case dwarf::DW_TAG_structure_type:
1230 case dwarf::DW_TAG_union_type:
1231 case dwarf::DW_TAG_class_type: {
1232 // Add elements to structure type.
1233 DIArray Elements = CTy.getTypeArray();
1234 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1235 DIDescriptor Element = Elements.getElement(i);
1236 if (Element.isSubprogram())
1237 getOrCreateSubprogramDIE(DISubprogram(Element));
1238 else if (Element.isDerivedType()) {
1239 DIDerivedType DDTy(Element);
1240 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1241 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1242 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1243 dwarf::DW_AT_friend);
1244 } else if (DDTy.isStaticMember()) {
1245 getOrCreateStaticMemberDIE(DDTy);
1247 constructMemberDIE(Buffer, DDTy);
1249 } else if (Element.isObjCProperty()) {
1250 DIObjCProperty Property(Element);
1251 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1252 StringRef PropertyName = Property.getObjCPropertyName();
1253 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1254 if (Property.getType())
1255 addType(ElemDie, Property.getType());
1256 addSourceLine(ElemDie, Property);
1257 StringRef GetterName = Property.getObjCPropertyGetterName();
1258 if (!GetterName.empty())
1259 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1260 StringRef SetterName = Property.getObjCPropertySetterName();
1261 if (!SetterName.empty())
1262 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1263 unsigned PropertyAttributes = 0;
1264 if (Property.isReadOnlyObjCProperty())
1265 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1266 if (Property.isReadWriteObjCProperty())
1267 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1268 if (Property.isAssignObjCProperty())
1269 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1270 if (Property.isRetainObjCProperty())
1271 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1272 if (Property.isCopyObjCProperty())
1273 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1274 if (Property.isNonAtomicObjCProperty())
1275 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1276 if (PropertyAttributes)
1277 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1278 PropertyAttributes);
1280 DIEEntry *Entry = getDIEEntry(Element);
1282 Entry = createDIEEntry(ElemDie);
1283 insertDIEEntry(Element, Entry);
1289 if (CTy.isAppleBlockExtension())
1290 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1292 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1294 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1295 *getOrCreateTypeDIE(ContainingType));
1297 if (CTy.isObjcClassComplete())
1298 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1300 // Add template parameters to a class, structure or union types.
1301 // FIXME: The support isn't in the metadata for this yet.
1302 if (Tag == dwarf::DW_TAG_class_type ||
1303 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1304 addTemplateParams(Buffer, CTy.getTemplateParams());
1312 // Add name if not anonymous or intermediate type.
1314 addString(Buffer, dwarf::DW_AT_name, Name);
1316 if (Tag == dwarf::DW_TAG_enumeration_type ||
1317 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1318 Tag == dwarf::DW_TAG_union_type) {
1319 // Add size if non-zero (derived types might be zero-sized.)
1320 // TODO: Do we care about size for enum forward declarations?
1322 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1323 else if (!CTy.isForwardDecl())
1324 // Add zero size if it is not a forward declaration.
1325 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1327 // If we're a forward decl, say so.
1328 if (CTy.isForwardDecl())
1329 addFlag(Buffer, dwarf::DW_AT_declaration);
1331 // Add source line info if available.
1332 if (!CTy.isForwardDecl())
1333 addSourceLine(Buffer, CTy);
1335 // No harm in adding the runtime language to the declaration.
1336 unsigned RLang = CTy.getRunTimeLang();
1338 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1343 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1344 /// DITemplateTypeParameter.
1345 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1346 DITemplateTypeParameter TP) {
1348 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1349 // Add the type if it exists, it could be void and therefore no type.
1351 addType(ParamDIE, resolve(TP.getType()));
1352 if (!TP.getName().empty())
1353 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1356 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1357 /// DITemplateValueParameter.
1359 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1360 DITemplateValueParameter VP) {
1361 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1363 // Add the type if there is one, template template and template parameter
1364 // packs will not have a type.
1365 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1366 addType(ParamDIE, resolve(VP.getType()));
1367 if (!VP.getName().empty())
1368 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1369 if (Value *Val = VP.getValue()) {
1370 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1371 addConstantValue(ParamDIE, CI,
1372 isUnsignedDIType(DD, resolve(VP.getType())));
1373 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1374 // For declaration non-type template parameters (such as global values and
1376 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1377 addOpAddress(*Loc, Asm->getSymbol(GV));
1378 // Emit DW_OP_stack_value to use the address as the immediate value of the
1379 // parameter, rather than a pointer to it.
1380 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1381 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1382 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1383 assert(isa<MDString>(Val));
1384 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1385 cast<MDString>(Val)->getString());
1386 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1387 assert(isa<MDNode>(Val));
1388 DIArray A(cast<MDNode>(Val));
1389 addTemplateParams(ParamDIE, A);
1394 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1395 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1396 // Construct the context before querying for the existence of the DIE in case
1397 // such construction creates the DIE.
1398 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1400 if (DIE *NDie = getDIE(NS))
1402 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1404 if (!NS.getName().empty()) {
1405 addString(NDie, dwarf::DW_AT_name, NS.getName());
1406 DD->addAccelNamespace(NS.getName(), NDie);
1407 addGlobalName(NS.getName(), NDie, NS.getContext());
1409 DD->addAccelNamespace("(anonymous namespace)", NDie);
1410 addSourceLine(NDie, NS);
1414 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1415 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1416 // Construct the context before querying for the existence of the DIE in case
1417 // such construction creates the DIE (as is the case for member function
1419 DIScope Context = resolve(SP.getContext());
1420 DIE *ContextDIE = getOrCreateContextDIE(Context);
1422 // Unique declarations based on the ODR, where applicable.
1423 SP = DISubprogram(DD->resolve(SP.getRef()));
1424 assert(SP.Verify());
1426 if (DIE *SPDie = getDIE(SP))
1429 DISubprogram SPDecl = SP.getFunctionDeclaration();
1430 if (SPDecl.isSubprogram())
1431 // Add subprogram definitions to the CU die directly.
1432 ContextDIE = &getUnitDie();
1434 // DW_TAG_inlined_subroutine may refer to this DIE.
1435 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1437 DIE *DeclDie = nullptr;
1438 if (SPDecl.isSubprogram())
1439 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1441 // Add function template parameters.
1442 addTemplateParams(SPDie, SP.getTemplateParams());
1445 // Refer function declaration directly.
1446 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1448 // Add the linkage name if we have one and it isn't in the Decl.
1449 StringRef LinkageName = SP.getLinkageName();
1450 if (!LinkageName.empty()) {
1451 if (SPDecl.isSubprogram() && !SPDecl.getLinkageName().empty())
1452 assert(SPDecl.getLinkageName() == SP.getLinkageName() &&
1453 "decl has a linkage name and it is different");
1455 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1456 GlobalValue::getRealLinkageName(LinkageName));
1459 // If this DIE is going to refer declaration info using AT_specification
1460 // then there is no need to add other attributes.
1464 // Constructors and operators for anonymous aggregates do not have names.
1465 if (!SP.getName().empty())
1466 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1468 addSourceLine(SPDie, SP);
1470 // Add the prototype if we have a prototype and we have a C like
1472 uint16_t Language = getLanguage();
1473 if (SP.isPrototyped() &&
1474 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1475 Language == dwarf::DW_LANG_ObjC))
1476 addFlag(SPDie, dwarf::DW_AT_prototyped);
1478 DICompositeType SPTy = SP.getType();
1479 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1480 "the type of a subprogram should be a subroutine");
1482 DIArray Args = SPTy.getTypeArray();
1483 // Add a return type. If this is a type like a C/C++ void type we don't add a
1485 if (Args.getElement(0))
1486 addType(SPDie, DIType(Args.getElement(0)));
1488 unsigned VK = SP.getVirtuality();
1490 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1491 DIELoc *Block = getDIELoc();
1492 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1493 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1494 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1495 ContainingTypeMap.insert(
1496 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1499 if (!SP.isDefinition()) {
1500 addFlag(SPDie, dwarf::DW_AT_declaration);
1502 // Add arguments. Do not add arguments for subprogram definition. They will
1503 // be handled while processing variables.
1504 if (DIE *ObjectPointer = constructSubprogramArguments(SPDie, Args))
1505 addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, *ObjectPointer);
1508 if (SP.isArtificial())
1509 addFlag(SPDie, dwarf::DW_AT_artificial);
1511 if (!SP.isLocalToUnit())
1512 addFlag(SPDie, dwarf::DW_AT_external);
1514 if (SP.isOptimized())
1515 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1517 if (unsigned isa = Asm->getISAEncoding()) {
1518 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1521 if (SP.isLValueReference())
1522 addFlag(SPDie, dwarf::DW_AT_reference);
1524 if (SP.isRValueReference())
1525 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1527 if (SP.isProtected())
1528 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1529 dwarf::DW_ACCESS_protected);
1530 else if (SP.isPrivate())
1531 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1532 dwarf::DW_ACCESS_private);
1534 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1535 dwarf::DW_ACCESS_public);
1537 if (SP.isExplicit())
1538 addFlag(SPDie, dwarf::DW_AT_explicit);
1543 // Return const expression if value is a GEP to access merged global
1545 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1546 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1547 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1548 if (!CE || CE->getNumOperands() != 3 ||
1549 CE->getOpcode() != Instruction::GetElementPtr)
1552 // First operand points to a global struct.
1553 Value *Ptr = CE->getOperand(0);
1554 if (!isa<GlobalValue>(Ptr) ||
1555 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1558 // Second operand is zero.
1559 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1560 if (!CI || !CI->isZero())
1563 // Third operand is offset.
1564 if (!isa<ConstantInt>(CE->getOperand(2)))
1570 /// createGlobalVariableDIE - create global variable DIE.
1571 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1572 // Check for pre-existence.
1576 assert(GV.isGlobalVariable());
1578 DIScope GVContext = GV.getContext();
1579 DIType GTy = DD->resolve(GV.getType());
1581 // If this is a static data member definition, some attributes belong
1582 // to the declaration DIE.
1583 DIE *VariableDIE = nullptr;
1584 bool IsStaticMember = false;
1585 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1586 if (SDMDecl.Verify()) {
1587 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1588 // We need the declaration DIE that is in the static member's class.
1589 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1590 IsStaticMember = true;
1593 // If this is not a static data member definition, create the variable
1594 // DIE and add the initial set of attributes to it.
1596 // Construct the context before querying for the existence of the DIE in
1597 // case such construction creates the DIE.
1598 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1601 VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1603 // Add name and type.
1604 addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1605 addType(*VariableDIE, GTy);
1607 // Add scoping info.
1608 if (!GV.isLocalToUnit())
1609 addFlag(*VariableDIE, dwarf::DW_AT_external);
1611 // Add line number info.
1612 addSourceLine(*VariableDIE, GV);
1616 bool addToAccelTable = false;
1617 DIE *VariableSpecDIE = nullptr;
1618 bool isGlobalVariable = GV.getGlobal() != nullptr;
1619 if (isGlobalVariable) {
1620 addToAccelTable = true;
1621 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1622 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1623 if (GV.getGlobal()->isThreadLocal()) {
1624 // FIXME: Make this work with -gsplit-dwarf.
1625 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1626 assert((PointerSize == 4 || PointerSize == 8) &&
1627 "Add support for other sizes if necessary");
1628 // Based on GCC's support for TLS:
1629 if (!DD->useSplitDwarf()) {
1630 // 1) Start with a constNu of the appropriate pointer size
1631 addUInt(*Loc, dwarf::DW_FORM_data1,
1632 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1633 // 2) containing the (relocated) offset of the TLS variable
1634 // within the module's TLS block.
1635 addExpr(*Loc, dwarf::DW_FORM_udata,
1636 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1638 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1639 addUInt(*Loc, dwarf::DW_FORM_udata,
1640 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
1642 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1643 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1645 DD->addArangeLabel(SymbolCU(this, Sym));
1646 addOpAddress(*Loc, Sym);
1648 // Do not create specification DIE if context is either compile unit
1650 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1651 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1652 // Create specification DIE.
1653 VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie);
1654 addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE);
1655 addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc);
1656 // A static member's declaration is already flagged as such.
1657 if (!SDMDecl.Verify())
1658 addFlag(*VariableDIE, dwarf::DW_AT_declaration);
1660 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1662 // Add the linkage name.
1663 StringRef LinkageName = GV.getLinkageName();
1664 if (!LinkageName.empty())
1665 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1666 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1668 addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE
1670 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1671 : dwarf::DW_AT_MIPS_linkage_name,
1672 GlobalValue::getRealLinkageName(LinkageName));
1673 } else if (const ConstantInt *CI =
1674 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1675 // AT_const_value was added when the static member was created. To avoid
1676 // emitting AT_const_value multiple times, we only add AT_const_value when
1677 // it is not a static member.
1678 if (!IsStaticMember)
1679 addConstantValue(*VariableDIE, CI, isUnsignedDIType(DD, GTy));
1680 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1681 addToAccelTable = true;
1682 // GV is a merged global.
1683 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1684 Value *Ptr = CE->getOperand(0);
1685 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1686 DD->addArangeLabel(SymbolCU(this, Sym));
1687 addOpAddress(*Loc, Sym);
1688 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1689 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1690 addUInt(*Loc, dwarf::DW_FORM_udata,
1691 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1692 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1693 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
1696 if (addToAccelTable) {
1697 DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE;
1698 DD->addAccelName(GV.getName(), AddrDIE);
1700 // If the linkage name is different than the name, go ahead and output
1701 // that as well into the name table.
1702 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1703 DD->addAccelName(GV.getLinkageName(), AddrDIE);
1706 if (!GV.isLocalToUnit())
1707 addGlobalName(GV.getName(),
1708 VariableSpecDIE ? *VariableSpecDIE : *VariableDIE,
1712 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1713 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1714 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1715 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1717 // The LowerBound value defines the lower bounds which is typically zero for
1718 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1719 // Count == -1 then the array is unbounded and we do not emit
1720 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1721 // Count == 0, then the array has zero elements in which case we do not emit
1723 int64_t LowerBound = SR.getLo();
1724 int64_t DefaultLowerBound = getDefaultLowerBound();
1725 int64_t Count = SR.getCount();
1727 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1728 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1730 if (Count != -1 && Count != 0)
1731 // FIXME: An unbounded array should reference the expression that defines
1733 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1734 LowerBound + Count - 1);
1737 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1738 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1740 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1742 // Emit the element type.
1743 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1745 // Get an anonymous type for index type.
1746 // FIXME: This type should be passed down from the front end
1747 // as different languages may have different sizes for indexes.
1748 DIE *IdxTy = getIndexTyDie();
1750 // Construct an integer type to use for indexes.
1751 IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1752 addString(*IdxTy, dwarf::DW_AT_name, "sizetype");
1753 addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1754 addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1755 dwarf::DW_ATE_unsigned);
1756 setIndexTyDie(IdxTy);
1759 // Add subranges to array type.
1760 DIArray Elements = CTy.getTypeArray();
1761 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1762 DIDescriptor Element = Elements.getElement(i);
1763 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1764 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1768 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1769 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1770 DIArray Elements = CTy.getTypeArray();
1772 // Add enumerators to enumeration type.
1773 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1774 DIEnumerator Enum(Elements.getElement(i));
1775 if (Enum.isEnumerator()) {
1776 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1777 StringRef Name = Enum.getName();
1778 addString(Enumerator, dwarf::DW_AT_name, Name);
1779 int64_t Value = Enum.getEnumValue();
1780 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1784 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1786 addType(Buffer, DTy);
1787 addFlag(Buffer, dwarf::DW_AT_enum_class);
1791 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1793 void DwarfUnit::constructContainingTypeDIEs() {
1794 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1795 CE = ContainingTypeMap.end();
1797 DIE &SPDie = *CI->first;
1798 DIDescriptor D(CI->second);
1801 DIE *NDie = getDIE(D);
1804 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1808 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1809 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV,
1810 bool isScopeAbstract) {
1811 auto D = constructVariableDIEImpl(DV, isScopeAbstract);
1816 std::unique_ptr<DIE> DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV,
1817 bool isScopeAbstract) {
1818 StringRef Name = DV.getName();
1820 // Define variable debug information entry.
1821 auto VariableDie = make_unique<DIE>(DV.getTag());
1822 DbgVariable *AbsVar = DV.getAbstractVariable();
1823 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : nullptr;
1825 addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, *AbsDIE);
1828 addString(*VariableDie, dwarf::DW_AT_name, Name);
1829 addSourceLine(*VariableDie, DV.getVariable());
1830 addType(*VariableDie, DV.getType());
1833 if (DV.isArtificial())
1834 addFlag(*VariableDie, dwarf::DW_AT_artificial);
1836 if (isScopeAbstract)
1839 // Add variable address.
1841 unsigned Offset = DV.getDotDebugLocOffset();
1842 if (Offset != ~0U) {
1843 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
1847 // Check if variable is described by a DBG_VALUE instruction.
1848 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1849 assert(DVInsn->getNumOperands() == 3);
1850 if (DVInsn->getOperand(0).isReg()) {
1851 const MachineOperand RegOp = DVInsn->getOperand(0);
1852 // If the second operand is an immediate, this is an indirect value.
1853 if (DVInsn->getOperand(1).isImm()) {
1854 MachineLocation Location(RegOp.getReg(),
1855 DVInsn->getOperand(1).getImm());
1856 addVariableAddress(DV, *VariableDie, Location);
1857 } else if (RegOp.getReg())
1858 addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
1859 } else if (DVInsn->getOperand(0).isImm())
1860 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
1861 else if (DVInsn->getOperand(0).isFPImm())
1862 addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
1863 else if (DVInsn->getOperand(0).isCImm())
1864 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
1865 isUnsignedDIType(DD, DV.getType()));
1870 // .. else use frame index.
1871 int FI = DV.getFrameIndex();
1873 unsigned FrameReg = 0;
1874 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1875 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1876 MachineLocation Location(FrameReg, Offset);
1877 addVariableAddress(DV, *VariableDie, Location);
1883 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1884 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1885 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1886 StringRef Name = DT.getName();
1888 addString(MemberDie, dwarf::DW_AT_name, Name);
1890 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1892 addSourceLine(MemberDie, DT);
1894 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1896 // For C++, virtual base classes are not at fixed offset. Use following
1897 // expression to extract appropriate offset from vtable.
1898 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1900 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1901 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1902 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1903 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1904 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1905 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1906 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1907 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1909 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1911 uint64_t Size = DT.getSizeInBits();
1912 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1913 uint64_t OffsetInBytes;
1915 if (Size != FieldSize) {
1916 // Handle bitfield, assume bytes are 8 bits.
1917 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1918 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1920 uint64_t Offset = DT.getOffsetInBits();
1921 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1922 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1923 uint64_t FieldOffset = (HiMark - FieldSize);
1924 Offset -= FieldOffset;
1926 // Maybe we need to work from the other end.
1927 if (Asm->getDataLayout().isLittleEndian())
1928 Offset = FieldSize - (Offset + Size);
1929 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1931 // Here DW_AT_data_member_location points to the anonymous
1932 // field that includes this bit field.
1933 OffsetInBytes = FieldOffset >> 3;
1935 // This is not a bitfield.
1936 OffsetInBytes = DT.getOffsetInBits() >> 3;
1938 if (DD->getDwarfVersion() <= 2) {
1939 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1940 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1941 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1942 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1944 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1948 if (DT.isProtected())
1949 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1950 dwarf::DW_ACCESS_protected);
1951 else if (DT.isPrivate())
1952 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1953 dwarf::DW_ACCESS_private);
1954 // Otherwise C++ member and base classes are considered public.
1956 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1957 dwarf::DW_ACCESS_public);
1959 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1960 dwarf::DW_VIRTUALITY_virtual);
1962 // Objective-C properties.
1963 if (MDNode *PNode = DT.getObjCProperty())
1964 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1965 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1968 if (DT.isArtificial())
1969 addFlag(MemberDie, dwarf::DW_AT_artificial);
1972 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1973 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1977 // Construct the context before querying for the existence of the DIE in case
1978 // such construction creates the DIE.
1979 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1980 assert(dwarf::isType(ContextDIE->getTag()) &&
1981 "Static member should belong to a type.");
1983 if (DIE *StaticMemberDIE = getDIE(DT))
1984 return StaticMemberDIE;
1986 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1988 DIType Ty = resolve(DT.getTypeDerivedFrom());
1990 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1991 addType(StaticMemberDIE, Ty);
1992 addSourceLine(StaticMemberDIE, DT);
1993 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1994 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1996 // FIXME: We could omit private if the parent is a class_type, and
1997 // public if the parent is something else.
1998 if (DT.isProtected())
1999 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2000 dwarf::DW_ACCESS_protected);
2001 else if (DT.isPrivate())
2002 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2003 dwarf::DW_ACCESS_private);
2005 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2006 dwarf::DW_ACCESS_public);
2008 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
2009 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
2010 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
2011 addConstantFPValue(StaticMemberDIE, CFP);
2013 return &StaticMemberDIE;
2016 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
2017 Asm->OutStreamer.AddComment("DWARF version number");
2018 Asm->EmitInt16(DD->getDwarfVersion());
2019 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2020 // We share one abbreviations table across all units so it's always at the
2021 // start of the section. Use a relocatable offset where needed to ensure
2022 // linking doesn't invalidate that offset.
2024 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2026 // Use a constant value when no symbol is provided.
2028 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2029 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2032 void DwarfUnit::addRange(RangeSpan Range) {
2033 // Only add a range for this unit if we're emitting full debug.
2034 if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
2035 // If we have no current ranges just add the range and return, otherwise,
2036 // check the current section and CU against the previous section and CU we
2037 // emitted into and the subprogram was contained within. If these are the
2038 // same then extend our current range, otherwise add this as a new range.
2039 if (CURanges.size() == 0 ||
2040 this != DD->getPrevCU() ||
2041 Asm->getCurrentSection() != DD->getPrevSection()) {
2042 CURanges.push_back(Range);
2046 assert(&(CURanges.back().getEnd()->getSection()) ==
2047 &(Range.getEnd()->getSection()) &&
2048 "We can only append to a range in the same section!");
2049 CURanges.back().setEnd(Range.getEnd());
2053 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2054 // Define start line table label for each Compile Unit.
2055 MCSymbol *LineTableStartSym =
2056 Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
2058 stmtListIndex = UnitDie.getValues().size();
2060 // DW_AT_stmt_list is a offset of line number information for this
2061 // compile unit in debug_line section. For split dwarf this is
2062 // left in the skeleton CU and so not included.
2063 // The line table entries are not always emitted in assembly, so it
2064 // is not okay to use line_table_start here.
2065 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2066 addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym);
2068 addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
2069 DwarfLineSectionSym);
2072 void DwarfCompileUnit::applyStmtList(DIE &D) {
2073 D.addValue(dwarf::DW_AT_stmt_list,
2074 UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
2075 UnitDie.getValues()[stmtListIndex]);
2078 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
2079 DwarfUnit::emitHeader(ASectionSym);
2080 Asm->OutStreamer.AddComment("Type Signature");
2081 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2082 Asm->OutStreamer.AddComment("Type DIE Offset");
2083 // In a skeleton type unit there is no type DIE so emit a zero offset.
2084 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2085 sizeof(Ty->getOffset()));
2088 void DwarfTypeUnit::initSection(const MCSection *Section) {
2089 assert(!this->Section);
2090 this->Section = Section;
2091 // Since each type unit is contained in its own COMDAT section, the begin
2092 // label and the section label are the same. Using the begin label emission in
2093 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2094 // the only other alternative of lazily constructing start-of-section labels
2095 // and storing a mapping in DwarfDebug (or AsmPrinter).
2096 this->SectionSym = this->LabelBegin =
2097 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2099 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());