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"
16 #include "DwarfAccelTable.h"
17 #include "DwarfCompileUnit.h"
18 #include "DwarfDebug.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DIBuilder.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Mangler.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetSubtargetInfo.h"
39 #define DEBUG_TYPE "dwarfdebug"
42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
43 cl::desc("Generate DWARF4 type units."),
46 /// Unit - Unit constructor.
47 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
48 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
49 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
50 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
51 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
52 UnitTag == dwarf::DW_TAG_type_unit);
53 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
56 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
57 DwarfDebug *DW, DwarfFile *DWU,
58 MCDwarfDwoLineTable *SplitLineTable)
59 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
60 CU(CU), SplitLineTable(SplitLineTable) {
62 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
65 /// ~Unit - Destructor for compile unit.
66 DwarfUnit::~DwarfUnit() {
67 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
68 DIEBlocks[j]->~DIEBlock();
69 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
70 DIELocs[j]->~DIELoc();
73 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
74 /// information entry.
75 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
76 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
80 /// getDefaultLowerBound - Return the default lower bound for an array. If the
81 /// DWARF version doesn't handle the language, return -1.
82 int64_t DwarfUnit::getDefaultLowerBound() const {
83 switch (getLanguage()) {
87 case dwarf::DW_LANG_C89:
88 case dwarf::DW_LANG_C99:
89 case dwarf::DW_LANG_C:
90 case dwarf::DW_LANG_C_plus_plus:
91 case dwarf::DW_LANG_ObjC:
92 case dwarf::DW_LANG_ObjC_plus_plus:
95 case dwarf::DW_LANG_Fortran77:
96 case dwarf::DW_LANG_Fortran90:
97 case dwarf::DW_LANG_Fortran95:
100 // The languages below have valid values only if the DWARF version >= 4.
101 case dwarf::DW_LANG_Java:
102 case dwarf::DW_LANG_Python:
103 case dwarf::DW_LANG_UPC:
104 case dwarf::DW_LANG_D:
105 if (dwarf::DWARF_VERSION >= 4)
109 case dwarf::DW_LANG_Ada83:
110 case dwarf::DW_LANG_Ada95:
111 case dwarf::DW_LANG_Cobol74:
112 case dwarf::DW_LANG_Cobol85:
113 case dwarf::DW_LANG_Modula2:
114 case dwarf::DW_LANG_Pascal83:
115 case dwarf::DW_LANG_PLI:
116 if (dwarf::DWARF_VERSION >= 4)
124 /// Check whether the DIE for this MDNode can be shared across CUs.
125 static bool isShareableAcrossCUs(DIDescriptor D) {
126 // When the MDNode can be part of the type system, the DIE can be shared
128 // Combining type units and cross-CU DIE sharing is lower value (since
129 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
130 // level already) but may be implementable for some value in projects
131 // building multiple independent libraries with LTO and then linking those
133 return (D.isType() ||
134 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
135 !GenerateDwarfTypeUnits;
138 /// getDIE - Returns the debug information entry map slot for the
139 /// specified debug variable. We delegate the request to DwarfDebug
140 /// when the DIE for this MDNode can be shared across CUs. The mappings
141 /// will be kept in DwarfDebug for shareable DIEs.
142 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
143 if (isShareableAcrossCUs(D))
144 return DD->getDIE(D);
145 return MDNodeToDieMap.lookup(D);
148 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
149 /// when the DIE for this MDNode can be shared across CUs. The mappings
150 /// will be kept in DwarfDebug for shareable DIEs.
151 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
152 if (isShareableAcrossCUs(Desc)) {
153 DD->insertDIE(Desc, D);
156 MDNodeToDieMap.insert(std::make_pair(Desc, D));
159 /// addFlag - Add a flag that is true.
160 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
161 if (DD->getDwarfVersion() >= 4)
162 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
164 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
167 /// addUInt - Add an unsigned integer attribute data and value.
169 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
170 Optional<dwarf::Form> Form, uint64_t Integer) {
172 Form = DIEInteger::BestForm(false, Integer);
173 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
175 Die.addValue(Attribute, *Form, Value);
178 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
179 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
182 /// addSInt - Add an signed integer attribute data and value.
184 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
185 Optional<dwarf::Form> Form, int64_t Integer) {
187 Form = DIEInteger::BestForm(true, Integer);
188 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
189 Die.addValue(Attribute, *Form, Value);
192 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
194 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
197 /// addString - Add a string attribute data and value. We always emit a
198 /// reference to the string pool instead of immediate strings so that DIEs have
199 /// more predictable sizes. In the case of split dwarf we emit an index
200 /// into another table which gets us the static offset into the string
202 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
205 if (!DD->useSplitDwarf())
206 return addLocalString(Die, Attribute, String);
208 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
209 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
210 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
211 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
214 /// addLocalString - Add a string attribute data and value. This is guaranteed
215 /// to be in the local string pool instead of indirected.
216 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
218 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
220 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
221 Value = new (DIEValueAllocator) DIELabel(Symb);
223 Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
224 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
225 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
228 /// addExpr - Add a Dwarf expression attribute data and value.
230 void DwarfUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) {
231 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
232 Die.addValue((dwarf::Attribute)0, Form, Value);
235 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
237 void DwarfUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
239 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
240 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
241 : dwarf::DW_FORM_data4;
242 Die.addValue(Attribute, Form, Value);
245 /// addLabel - Add a Dwarf label attribute data and value.
247 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
248 const MCSymbol *Label) {
249 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
250 Die.addValue(Attribute, Form, Value);
253 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
254 addLabel(Die, (dwarf::Attribute)0, Form, Label);
257 /// addSectionOffset - Add an offset into a section attribute data and value.
259 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
261 if (DD->getDwarfVersion() >= 4)
262 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
264 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
267 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
268 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
269 : getCU().getOrCreateSourceID(FileName, DirName);
272 /// addOpAddress - Add a dwarf op address data and value using the
273 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
275 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
276 if (!DD->useSplitDwarf()) {
277 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
278 addLabel(Die, dwarf::DW_FORM_udata, Sym);
280 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
281 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
282 DD->getAddressPool().getIndex(Sym));
286 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
287 const MCSymbol *Hi, const MCSymbol *Lo) {
288 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
289 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
292 /// addDIEEntry - Add a DIE attribute data and value.
294 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
295 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
298 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
299 // Flag the type unit reference as a declaration so that if it contains
300 // members (implicit special members, static data member definitions, member
301 // declarations for definitions in this CU, etc) consumers don't get confused
302 // and think this is a full definition.
303 addFlag(Die, dwarf::DW_AT_declaration);
305 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
306 new (DIEValueAllocator) DIETypeSignature(Type));
309 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
311 const DIE *DieCU = Die.getUnitOrNull();
312 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
314 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
315 DieCU = &getUnitDie();
317 EntryCU = &getUnitDie();
318 Die.addValue(Attribute,
319 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
323 /// Create a DIE with the given Tag, add the DIE to its parent, and
324 /// call insertDIE if MD is not null.
325 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
326 assert(Tag != dwarf::DW_TAG_auto_variable &&
327 Tag != dwarf::DW_TAG_arg_variable);
328 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
329 DIE &Die = *Parent.getChildren().back();
335 /// addBlock - Add block data.
337 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
338 Loc->ComputeSize(Asm);
339 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
340 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
343 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
345 Block->ComputeSize(Asm);
346 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
347 Die.addValue(Attribute, Block->BestForm(), Block);
350 /// addSourceLine - Add location information to specified debug information
352 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
353 StringRef Directory) {
357 unsigned FileID = getOrCreateSourceID(File, Directory);
358 assert(FileID && "Invalid file id");
359 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
360 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
363 /// addSourceLine - Add location information to specified debug information
365 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
366 assert(V.isVariable());
368 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
369 V.getContext().getDirectory());
372 /// addSourceLine - Add location information to specified debug information
374 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
375 assert(G.isGlobalVariable());
377 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
380 /// addSourceLine - Add location information to specified debug information
382 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
383 assert(SP.isSubprogram());
385 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
388 /// addSourceLine - Add location information to specified debug information
390 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
393 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
396 /// addSourceLine - Add location information to specified debug information
398 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
399 assert(Ty.isObjCProperty());
401 DIFile File = Ty.getFile();
402 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
403 File.getDirectory());
406 /// addSourceLine - Add location information to specified debug information
408 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
411 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
414 /// addVariableAddress - Add DW_AT_location attribute for a
415 /// DbgVariable based on provided MachineLocation.
416 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
417 MachineLocation Location) {
418 if (DV.variableHasComplexAddress())
419 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
420 else if (DV.isBlockByrefVariable())
421 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
423 addAddress(Die, dwarf::DW_AT_location, Location,
424 DV.getVariable().isIndirect());
427 /// addRegisterOp - Add register operand.
428 // FIXME: Ideally, this would share the implementation with
429 // AsmPrinter::EmitDwarfRegOpPiece.
430 void DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
431 unsigned SizeInBits, unsigned OffsetInBits) {
432 const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
433 int DWReg = RI->getDwarfRegNum(Reg, false);
434 bool isSubRegister = DWReg < 0;
438 // Go up the super-register chain until we hit a valid dwarf register number.
439 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
440 DWReg = RI->getDwarfRegNum(*SR, false);
442 Idx = RI->getSubRegIndex(*SR, Reg);
446 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
447 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
453 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
455 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
456 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
460 bool isPiece = SizeInBits > 0;
461 if (isSubRegister || isPiece) {
462 const unsigned SizeOfByte = 8;
463 unsigned RegSizeInBits = RI->getSubRegIdxSize(Idx);
464 unsigned RegOffsetInBits = RI->getSubRegIdxOffset(Idx);
465 unsigned PieceSizeInBits = std::max(SizeInBits, RegSizeInBits);
466 unsigned PieceOffsetInBits = OffsetInBits ? OffsetInBits : RegOffsetInBits;
467 assert(RegSizeInBits >= SizeInBits && "register smaller than value");
469 if (RegOffsetInBits != PieceOffsetInBits) {
470 // Manually shift the value into place, since the DW_OP_piece
471 // describes the part of the variable, not the position of the
473 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
474 addUInt(TheDie, dwarf::DW_FORM_data1, RegOffsetInBits);
475 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_shr);
478 if (PieceOffsetInBits > 0 || PieceSizeInBits % SizeOfByte) {
479 assert(PieceSizeInBits > 0 && "piece has zero size");
480 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
481 addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits);
482 addUInt(TheDie, dwarf::DW_FORM_data1, PieceOffsetInBits);
484 assert(PieceSizeInBits > 0 && "piece has zero size");
485 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
486 addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits/SizeOfByte);
491 /// addRegisterOffset - Add register offset.
492 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
494 const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
495 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
496 const TargetRegisterInfo *TRI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
497 if (Reg == TRI->getFrameRegister(*Asm->MF))
498 // If variable offset is based in frame register then use fbreg.
499 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
501 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
503 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
504 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
506 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
509 /// addAddress - Add an address attribute to a die based on the location
511 void DwarfUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
512 const MachineLocation &Location, bool Indirect) {
513 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
515 if (Location.isReg() && !Indirect)
516 addRegisterOpPiece(*Loc, Location.getReg());
518 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
519 if (Indirect && !Location.isReg()) {
520 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
524 // Now attach the location information to the DIE.
525 addBlock(Die, Attribute, Loc);
528 /// addComplexAddress - Start with the address based on the location provided,
529 /// and generate the DWARF information necessary to find the actual variable
530 /// given the extra address information encoded in the DbgVariable, starting
531 /// from the starting location. Add the DWARF information to the die.
533 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
534 dwarf::Attribute Attribute,
535 const MachineLocation &Location) {
536 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
537 unsigned N = DV.getNumAddrElements();
539 if (Location.isReg()) {
540 if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_plus) {
541 assert(!DV.getVariable().isIndirect() &&
542 "double indirection not handled");
543 // If first address element is OpPlus then emit
544 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
545 addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1));
547 } else if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_deref) {
548 assert(!DV.getVariable().isIndirect() &&
549 "double indirection not handled");
550 addRegisterOpPiece(*Loc, Location.getReg(),
551 DV.getExpression().getPieceSize(),
552 DV.getExpression().getPieceOffset());
555 addRegisterOpPiece(*Loc, Location.getReg());
557 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
560 uint64_t Element = DV.getAddrElement(i);
561 if (Element == dwarf::DW_OP_plus) {
562 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
563 addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
565 } else if (Element == dwarf::DW_OP_deref) {
566 if (!Location.isReg())
567 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
569 } else if (Element == dwarf::DW_OP_piece) {
570 const unsigned SizeOfByte = 8;
571 unsigned PieceOffsetInBits = DV.getAddrElement(++i)*SizeOfByte;
572 unsigned PieceSizeInBits = DV.getAddrElement(++i)*SizeOfByte;
573 // Emit DW_OP_bit_piece Size Offset.
574 assert(PieceSizeInBits > 0 && "piece has zero size");
575 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
576 addUInt(*Loc, dwarf::DW_FORM_udata, PieceSizeInBits);
577 addUInt(*Loc, dwarf::DW_FORM_udata, PieceOffsetInBits);
580 llvm_unreachable("unknown DIBuilder Opcode");
583 // Now attach the location information to the DIE.
584 addBlock(Die, Attribute, Loc);
587 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
588 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
589 gives the variable VarName either the struct, or a pointer to the struct, as
590 its type. This is necessary for various behind-the-scenes things the
591 compiler needs to do with by-reference variables in Blocks.
593 However, as far as the original *programmer* is concerned, the variable
594 should still have type 'SomeType', as originally declared.
596 The function getBlockByrefType dives into the __Block_byref_x_VarName
597 struct to find the original type of the variable, which is then assigned to
598 the variable's Debug Information Entry as its real type. So far, so good.
599 However now the debugger will expect the variable VarName to have the type
600 SomeType. So we need the location attribute for the variable to be an
601 expression that explains to the debugger how to navigate through the
602 pointers and struct to find the actual variable of type SomeType.
604 The following function does just that. We start by getting
605 the "normal" location for the variable. This will be the location
606 of either the struct __Block_byref_x_VarName or the pointer to the
607 struct __Block_byref_x_VarName.
609 The struct will look something like:
611 struct __Block_byref_x_VarName {
613 struct __Block_byref_x_VarName *forwarding;
614 ... <various other fields>
616 ... <maybe more fields>
619 If we are given the struct directly (as our starting point) we
620 need to tell the debugger to:
622 1). Add the offset of the forwarding field.
624 2). Follow that pointer to get the real __Block_byref_x_VarName
625 struct to use (the real one may have been copied onto the heap).
627 3). Add the offset for the field VarName, to find the actual variable.
629 If we started with a pointer to the struct, then we need to
630 dereference that pointer first, before the other steps.
631 Translating this into DWARF ops, we will need to append the following
632 to the current location description for the variable:
634 DW_OP_deref -- optional, if we start with a pointer
635 DW_OP_plus_uconst <forward_fld_offset>
637 DW_OP_plus_uconst <varName_fld_offset>
639 That is what this function does. */
641 /// addBlockByrefAddress - Start with the address based on the location
642 /// provided, and generate the DWARF information necessary to find the
643 /// actual Block variable (navigating the Block struct) based on the
644 /// starting location. Add the DWARF information to the die. For
645 /// more information, read large comment just above here.
647 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
648 dwarf::Attribute Attribute,
649 const MachineLocation &Location) {
650 DIType Ty = DV.getType();
652 uint16_t Tag = Ty.getTag();
653 bool isPointer = false;
655 StringRef varName = DV.getName();
657 if (Tag == dwarf::DW_TAG_pointer_type) {
658 DIDerivedType DTy(Ty);
659 TmpTy = resolve(DTy.getTypeDerivedFrom());
663 DICompositeType blockStruct(TmpTy);
665 // Find the __forwarding field and the variable field in the __Block_byref
667 DIArray Fields = blockStruct.getElements();
668 DIDerivedType varField;
669 DIDerivedType forwardingField;
671 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
672 DIDerivedType DT(Fields.getElement(i));
673 StringRef fieldName = DT.getName();
674 if (fieldName == "__forwarding")
675 forwardingField = DT;
676 else if (fieldName == varName)
680 // Get the offsets for the forwarding field and the variable field.
681 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
682 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
684 // Decode the original location, and use that as the start of the byref
685 // variable's location.
686 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
688 if (Location.isReg())
689 addRegisterOpPiece(*Loc, Location.getReg());
691 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
693 // If we started with a pointer to the __Block_byref... struct, then
694 // the first thing we need to do is dereference the pointer (DW_OP_deref).
696 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
698 // Next add the offset for the '__forwarding' field:
699 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
700 // adding the offset if it's 0.
701 if (forwardingFieldOffset > 0) {
702 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
703 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
706 // Now dereference the __forwarding field to get to the real __Block_byref
707 // struct: DW_OP_deref.
708 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
710 // Now that we've got the real __Block_byref... struct, add the offset
711 // for the variable's field to get to the location of the actual variable:
712 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
713 if (varFieldOffset > 0) {
714 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
715 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
718 // Now attach the location information to the DIE.
719 addBlock(Die, Attribute, Loc);
722 /// Return true if type encoding is unsigned.
723 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
724 DIDerivedType DTy(Ty);
725 if (DTy.isDerivedType()) {
726 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
727 // Encode pointer constants as unsigned bytes. This is used at least for
728 // null pointer constant emission.
729 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
730 // here, but accept them for now due to a bug in SROA producing bogus
732 if (T == dwarf::DW_TAG_pointer_type ||
733 T == dwarf::DW_TAG_ptr_to_member_type ||
734 T == dwarf::DW_TAG_reference_type ||
735 T == dwarf::DW_TAG_rvalue_reference_type)
737 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
738 T == dwarf::DW_TAG_volatile_type ||
739 T == dwarf::DW_TAG_restrict_type ||
740 T == dwarf::DW_TAG_enumeration_type);
741 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
742 return isUnsignedDIType(DD, DD->resolve(Deriv));
743 // FIXME: Enums without a fixed underlying type have unknown signedness
744 // here, leading to incorrectly emitted constants.
745 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
750 assert(BTy.isBasicType());
751 unsigned Encoding = BTy.getEncoding();
752 assert((Encoding == dwarf::DW_ATE_unsigned ||
753 Encoding == dwarf::DW_ATE_unsigned_char ||
754 Encoding == dwarf::DW_ATE_signed ||
755 Encoding == dwarf::DW_ATE_signed_char ||
756 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) &&
757 "Unsupported encoding");
758 return (Encoding == dwarf::DW_ATE_unsigned ||
759 Encoding == dwarf::DW_ATE_unsigned_char ||
760 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean);
763 /// If this type is derived from a base type then return base type size.
764 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
765 unsigned Tag = Ty.getTag();
767 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
768 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
769 Tag != dwarf::DW_TAG_restrict_type)
770 return Ty.getSizeInBits();
772 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
774 // If this type is not derived from any type or the type is a declaration then
775 // take conservative approach.
776 if (!BaseType.isValid() || BaseType.isForwardDecl())
777 return Ty.getSizeInBits();
779 // If this is a derived type, go ahead and get the base type, unless it's a
780 // reference then it's just the size of the field. Pointer types have no need
781 // of this since they're a different type of qualification on the type.
782 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
783 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
784 return Ty.getSizeInBits();
786 if (BaseType.isDerivedType())
787 return getBaseTypeSize(DD, DIDerivedType(BaseType));
789 return BaseType.getSizeInBits();
792 /// addConstantFPValue - Add constant value entry in variable DIE.
793 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
794 assert(MO.isFPImm() && "Invalid machine operand!");
795 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
796 APFloat FPImm = MO.getFPImm()->getValueAPF();
798 // Get the raw data form of the floating point.
799 const APInt FltVal = FPImm.bitcastToAPInt();
800 const char *FltPtr = (const char *)FltVal.getRawData();
802 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
803 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
804 int Incr = (LittleEndian ? 1 : -1);
805 int Start = (LittleEndian ? 0 : NumBytes - 1);
806 int Stop = (LittleEndian ? NumBytes : -1);
808 // Output the constant to DWARF one byte at a time.
809 for (; Start != Stop; Start += Incr)
810 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
812 addBlock(Die, dwarf::DW_AT_const_value, Block);
815 /// addConstantFPValue - Add constant value entry in variable DIE.
816 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
817 // Pass this down to addConstantValue as an unsigned bag of bits.
818 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
821 /// addConstantValue - Add constant value entry in variable DIE.
822 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
823 addConstantValue(Die, CI->getValue(), Ty);
826 /// addConstantValue - Add constant value entry in variable DIE.
827 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
829 assert(MO.isImm() && "Invalid machine operand!");
831 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
834 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
835 // FIXME: This is a bit conservative/simple - it emits negative values always
836 // sign extended to 64 bits rather than minimizing the number of bytes.
837 addUInt(Die, dwarf::DW_AT_const_value,
838 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
841 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
842 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
845 // addConstantValue - Add constant value entry in variable DIE.
846 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
847 unsigned CIBitWidth = Val.getBitWidth();
848 if (CIBitWidth <= 64) {
849 addConstantValue(Die, Unsigned,
850 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
854 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
856 // Get the raw data form of the large APInt.
857 const uint64_t *Ptr64 = Val.getRawData();
859 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
860 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
862 // Output the constant to DWARF one byte at a time.
863 for (int i = 0; i < NumBytes; i++) {
866 c = Ptr64[i / 8] >> (8 * (i & 7));
868 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
869 addUInt(*Block, dwarf::DW_FORM_data1, c);
872 addBlock(Die, dwarf::DW_AT_const_value, Block);
875 /// addTemplateParams - Add template parameters into buffer.
876 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
877 // Add template parameters.
878 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
879 DIDescriptor Element = TParams.getElement(i);
880 if (Element.isTemplateTypeParameter())
881 constructTemplateTypeParameterDIE(Buffer,
882 DITemplateTypeParameter(Element));
883 else if (Element.isTemplateValueParameter())
884 constructTemplateValueParameterDIE(Buffer,
885 DITemplateValueParameter(Element));
889 /// getOrCreateContextDIE - Get context owner's DIE.
890 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
891 if (!Context || Context.isFile())
892 return &getUnitDie();
893 if (Context.isType())
894 return getOrCreateTypeDIE(DIType(Context));
895 if (Context.isNameSpace())
896 return getOrCreateNameSpace(DINameSpace(Context));
897 if (Context.isSubprogram())
898 return getOrCreateSubprogramDIE(DISubprogram(Context));
899 return getDIE(Context);
902 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
903 DIScope Context = resolve(Ty.getContext());
904 DIE *ContextDIE = getOrCreateContextDIE(Context);
906 if (DIE *TyDIE = getDIE(Ty))
910 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
912 constructTypeDIE(TyDIE, Ty);
914 updateAcceleratorTables(Context, Ty, TyDIE);
918 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
920 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
926 assert(Ty == resolve(Ty.getRef()) &&
927 "type was not uniqued, possible ODR violation.");
929 // DW_TAG_restrict_type is not supported in DWARF2
930 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
931 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
933 // Construct the context before querying for the existence of the DIE in case
934 // such construction creates the DIE.
935 DIScope Context = resolve(Ty.getContext());
936 DIE *ContextDIE = getOrCreateContextDIE(Context);
939 if (DIE *TyDIE = getDIE(Ty))
943 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
945 updateAcceleratorTables(Context, Ty, TyDIE);
947 if (Ty.isBasicType())
948 constructTypeDIE(TyDIE, DIBasicType(Ty));
949 else if (Ty.isCompositeType()) {
950 DICompositeType CTy(Ty);
951 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
952 if (MDString *TypeId = CTy.getIdentifier()) {
953 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
954 // Skip updating the accelerator tables since this is not the full type.
957 constructTypeDIE(TyDIE, CTy);
959 assert(Ty.isDerivedType() && "Unknown kind of DIType");
960 constructTypeDIE(TyDIE, DIDerivedType(Ty));
966 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
968 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
969 bool IsImplementation = 0;
970 if (Ty.isCompositeType()) {
971 DICompositeType CT(Ty);
972 // A runtime language of 0 actually means C/C++ and that any
973 // non-negative value is some version of Objective-C/C++.
974 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
976 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
977 DD->addAccelType(Ty.getName(), TyDIE, Flags);
979 if (!Context || Context.isCompileUnit() || Context.isFile() ||
980 Context.isNameSpace())
981 addGlobalType(Ty, TyDIE, Context);
985 /// addType - Add a new type attribute to the specified entity.
986 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
987 assert(Ty && "Trying to add a type that doesn't exist?");
989 // Check for pre-existence.
990 DIEEntry *Entry = getDIEEntry(Ty);
991 // If it exists then use the existing value.
993 addDIEEntry(Entity, Attribute, Entry);
998 DIE *Buffer = getOrCreateTypeDIE(Ty);
1001 Entry = createDIEEntry(*Buffer);
1002 insertDIEEntry(Ty, Entry);
1003 addDIEEntry(Entity, Attribute, Entry);
1006 /// getParentContextString - Walks the metadata parent chain in a language
1007 /// specific manner (using the compile unit language) and returns
1008 /// it as a string. This is done at the metadata level because DIEs may
1009 /// not currently have been added to the parent context and walking the
1010 /// DIEs looking for names is more expensive than walking the metadata.
1011 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1015 // FIXME: Decide whether to implement this for non-C++ languages.
1016 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1020 SmallVector<DIScope, 1> Parents;
1021 while (!Context.isCompileUnit()) {
1022 Parents.push_back(Context);
1023 if (Context.getContext())
1024 Context = resolve(Context.getContext());
1026 // Structure, etc types will have a NULL context if they're at the top
1031 // Reverse iterate over our list to go from the outermost construct to the
1033 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1037 StringRef Name = Ctx.getName();
1038 if (Name.empty() && Ctx.isNameSpace())
1039 Name = "(anonymous namespace)";
1040 if (!Name.empty()) {
1048 /// constructTypeDIE - Construct basic type die from DIBasicType.
1049 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1050 // Get core information.
1051 StringRef Name = BTy.getName();
1052 // Add name if not anonymous or intermediate type.
1054 addString(Buffer, dwarf::DW_AT_name, Name);
1056 // An unspecified type only has a name attribute.
1057 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1060 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1063 uint64_t Size = BTy.getSizeInBits() >> 3;
1064 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1067 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1068 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1069 // Get core information.
1070 StringRef Name = DTy.getName();
1071 uint64_t Size = DTy.getSizeInBits() >> 3;
1072 uint16_t Tag = Buffer.getTag();
1074 // Map to main type, void will not have a type.
1075 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1077 addType(Buffer, FromTy);
1079 // Add name if not anonymous or intermediate type.
1081 addString(Buffer, dwarf::DW_AT_name, Name);
1083 // Add size if non-zero (derived types might be zero-sized.)
1084 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1085 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1087 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1088 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1089 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1090 // Add source line info if available and TyDesc is not a forward declaration.
1091 if (!DTy.isForwardDecl())
1092 addSourceLine(Buffer, DTy);
1095 /// constructSubprogramArguments - Construct function argument DIEs.
1096 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1097 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1098 DIType Ty = resolve(Args.getElement(i));
1100 assert(i == N-1 && "Unspecified parameter must be the last argument");
1101 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1103 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1105 if (Ty.isArtificial())
1106 addFlag(Arg, dwarf::DW_AT_artificial);
1111 /// constructTypeDIE - Construct type DIE from DICompositeType.
1112 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1113 // Add name if not anonymous or intermediate type.
1114 StringRef Name = CTy.getName();
1116 uint64_t Size = CTy.getSizeInBits() >> 3;
1117 uint16_t Tag = Buffer.getTag();
1120 case dwarf::DW_TAG_array_type:
1121 constructArrayTypeDIE(Buffer, CTy);
1123 case dwarf::DW_TAG_enumeration_type:
1124 constructEnumTypeDIE(Buffer, CTy);
1126 case dwarf::DW_TAG_subroutine_type: {
1127 // Add return type. A void return won't have a type.
1128 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1129 DIType RTy(resolve(Elements.getElement(0)));
1131 addType(Buffer, RTy);
1133 bool isPrototyped = true;
1134 if (Elements.getNumElements() == 2 &&
1135 !Elements.getElement(1))
1136 isPrototyped = false;
1138 constructSubprogramArguments(Buffer, Elements);
1140 // Add prototype flag if we're dealing with a C language and the
1141 // function has been prototyped.
1142 uint16_t Language = getLanguage();
1144 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1145 Language == dwarf::DW_LANG_ObjC))
1146 addFlag(Buffer, dwarf::DW_AT_prototyped);
1148 if (CTy.isLValueReference())
1149 addFlag(Buffer, dwarf::DW_AT_reference);
1151 if (CTy.isRValueReference())
1152 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1154 case dwarf::DW_TAG_structure_type:
1155 case dwarf::DW_TAG_union_type:
1156 case dwarf::DW_TAG_class_type: {
1157 // Add elements to structure type.
1158 DIArray Elements = CTy.getElements();
1159 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1160 DIDescriptor Element = Elements.getElement(i);
1161 if (Element.isSubprogram())
1162 getOrCreateSubprogramDIE(DISubprogram(Element));
1163 else if (Element.isDerivedType()) {
1164 DIDerivedType DDTy(Element);
1165 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1166 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1167 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1168 dwarf::DW_AT_friend);
1169 } else if (DDTy.isStaticMember()) {
1170 getOrCreateStaticMemberDIE(DDTy);
1172 constructMemberDIE(Buffer, DDTy);
1174 } else if (Element.isObjCProperty()) {
1175 DIObjCProperty Property(Element);
1176 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1177 StringRef PropertyName = Property.getObjCPropertyName();
1178 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1179 if (Property.getType())
1180 addType(ElemDie, Property.getType());
1181 addSourceLine(ElemDie, Property);
1182 StringRef GetterName = Property.getObjCPropertyGetterName();
1183 if (!GetterName.empty())
1184 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1185 StringRef SetterName = Property.getObjCPropertySetterName();
1186 if (!SetterName.empty())
1187 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1188 unsigned PropertyAttributes = 0;
1189 if (Property.isReadOnlyObjCProperty())
1190 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1191 if (Property.isReadWriteObjCProperty())
1192 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1193 if (Property.isAssignObjCProperty())
1194 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1195 if (Property.isRetainObjCProperty())
1196 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1197 if (Property.isCopyObjCProperty())
1198 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1199 if (Property.isNonAtomicObjCProperty())
1200 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1201 if (PropertyAttributes)
1202 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1203 PropertyAttributes);
1205 DIEEntry *Entry = getDIEEntry(Element);
1207 Entry = createDIEEntry(ElemDie);
1208 insertDIEEntry(Element, Entry);
1214 if (CTy.isAppleBlockExtension())
1215 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1217 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1219 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1220 *getOrCreateTypeDIE(ContainingType));
1222 if (CTy.isObjcClassComplete())
1223 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1225 // Add template parameters to a class, structure or union types.
1226 // FIXME: The support isn't in the metadata for this yet.
1227 if (Tag == dwarf::DW_TAG_class_type ||
1228 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1229 addTemplateParams(Buffer, CTy.getTemplateParams());
1237 // Add name if not anonymous or intermediate type.
1239 addString(Buffer, dwarf::DW_AT_name, Name);
1241 if (Tag == dwarf::DW_TAG_enumeration_type ||
1242 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1243 Tag == dwarf::DW_TAG_union_type) {
1244 // Add size if non-zero (derived types might be zero-sized.)
1245 // TODO: Do we care about size for enum forward declarations?
1247 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1248 else if (!CTy.isForwardDecl())
1249 // Add zero size if it is not a forward declaration.
1250 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1252 // If we're a forward decl, say so.
1253 if (CTy.isForwardDecl())
1254 addFlag(Buffer, dwarf::DW_AT_declaration);
1256 // Add source line info if available.
1257 if (!CTy.isForwardDecl())
1258 addSourceLine(Buffer, CTy);
1260 // No harm in adding the runtime language to the declaration.
1261 unsigned RLang = CTy.getRunTimeLang();
1263 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1268 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1269 /// DITemplateTypeParameter.
1270 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1271 DITemplateTypeParameter TP) {
1273 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1274 // Add the type if it exists, it could be void and therefore no type.
1276 addType(ParamDIE, resolve(TP.getType()));
1277 if (!TP.getName().empty())
1278 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1281 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1282 /// DITemplateValueParameter.
1284 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1285 DITemplateValueParameter VP) {
1286 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1288 // Add the type if there is one, template template and template parameter
1289 // packs will not have a type.
1290 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1291 addType(ParamDIE, resolve(VP.getType()));
1292 if (!VP.getName().empty())
1293 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1294 if (Value *Val = VP.getValue()) {
1295 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1296 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1297 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1298 // For declaration non-type template parameters (such as global values and
1300 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1301 addOpAddress(*Loc, Asm->getSymbol(GV));
1302 // Emit DW_OP_stack_value to use the address as the immediate value of the
1303 // parameter, rather than a pointer to it.
1304 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1305 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1306 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1307 assert(isa<MDString>(Val));
1308 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1309 cast<MDString>(Val)->getString());
1310 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1311 assert(isa<MDNode>(Val));
1312 DIArray A(cast<MDNode>(Val));
1313 addTemplateParams(ParamDIE, A);
1318 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1319 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1320 // Construct the context before querying for the existence of the DIE in case
1321 // such construction creates the DIE.
1322 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1324 if (DIE *NDie = getDIE(NS))
1326 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1328 StringRef Name = NS.getName();
1330 addString(NDie, dwarf::DW_AT_name, NS.getName());
1332 Name = "(anonymous namespace)";
1333 DD->addAccelNamespace(Name, NDie);
1334 addGlobalName(Name, NDie, NS.getContext());
1335 addSourceLine(NDie, NS);
1339 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1340 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1341 // Construct the context before querying for the existence of the DIE in case
1342 // such construction creates the DIE (as is the case for member function
1344 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1346 if (DIE *SPDie = getDIE(SP))
1349 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1350 // Add subprogram definitions to the CU die directly.
1351 ContextDIE = &getUnitDie();
1352 // Build the decl now to ensure it precedes the definition.
1353 getOrCreateSubprogramDIE(SPDecl);
1356 // DW_TAG_inlined_subroutine may refer to this DIE.
1357 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1359 // Stop here and fill this in later, depending on whether or not this
1360 // subprogram turns out to have inlined instances or not.
1361 if (SP.isDefinition())
1364 applySubprogramAttributes(SP, SPDie);
1368 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) {
1369 DISubprogram SPDecl = SP.getFunctionDeclaration();
1370 DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
1371 applySubprogramAttributes(SP, SPDie);
1372 addGlobalName(SP.getName(), SPDie, Context);
1375 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1376 DIE *DeclDie = nullptr;
1377 StringRef DeclLinkageName;
1378 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1379 DeclDie = getDIE(SPDecl);
1380 assert(DeclDie && "This DIE should've already been constructed when the "
1381 "definition DIE was created in "
1382 "getOrCreateSubprogramDIE");
1383 DeclLinkageName = SPDecl.getLinkageName();
1386 // Add function template parameters.
1387 addTemplateParams(SPDie, SP.getTemplateParams());
1389 // Add the linkage name if we have one and it isn't in the Decl.
1390 StringRef LinkageName = SP.getLinkageName();
1391 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1392 LinkageName == DeclLinkageName) &&
1393 "decl has a linkage name and it is different");
1394 if (!LinkageName.empty() && DeclLinkageName.empty())
1395 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1396 GlobalValue::getRealLinkageName(LinkageName));
1399 // Refer to the function declaration where all the other attributes will be
1401 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1405 // Constructors and operators for anonymous aggregates do not have names.
1406 if (!SP.getName().empty())
1407 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1409 // Skip the rest of the attributes under -gmlt to save space.
1410 if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1413 addSourceLine(SPDie, SP);
1415 // Add the prototype if we have a prototype and we have a C like
1417 uint16_t Language = getLanguage();
1418 if (SP.isPrototyped() &&
1419 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1420 Language == dwarf::DW_LANG_ObjC))
1421 addFlag(SPDie, dwarf::DW_AT_prototyped);
1423 DISubroutineType SPTy = SP.getType();
1424 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1425 "the type of a subprogram should be a subroutine");
1427 DITypeArray Args = SPTy.getTypeArray();
1428 // Add a return type. If this is a type like a C/C++ void type we don't add a
1430 if (resolve(Args.getElement(0)))
1431 addType(SPDie, DIType(resolve(Args.getElement(0))));
1433 unsigned VK = SP.getVirtuality();
1435 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1436 DIELoc *Block = getDIELoc();
1437 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1438 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1439 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1440 ContainingTypeMap.insert(
1441 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1444 if (!SP.isDefinition()) {
1445 addFlag(SPDie, dwarf::DW_AT_declaration);
1447 // Add arguments. Do not add arguments for subprogram definition. They will
1448 // be handled while processing variables.
1449 constructSubprogramArguments(SPDie, Args);
1452 if (SP.isArtificial())
1453 addFlag(SPDie, dwarf::DW_AT_artificial);
1455 if (!SP.isLocalToUnit())
1456 addFlag(SPDie, dwarf::DW_AT_external);
1458 if (SP.isOptimized())
1459 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1461 if (unsigned isa = Asm->getISAEncoding()) {
1462 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1465 if (SP.isLValueReference())
1466 addFlag(SPDie, dwarf::DW_AT_reference);
1468 if (SP.isRValueReference())
1469 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1471 if (SP.isProtected())
1472 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1473 dwarf::DW_ACCESS_protected);
1474 else if (SP.isPrivate())
1475 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1476 dwarf::DW_ACCESS_private);
1477 else if (SP.isPublic())
1478 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1479 dwarf::DW_ACCESS_public);
1481 if (SP.isExplicit())
1482 addFlag(SPDie, dwarf::DW_AT_explicit);
1485 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var,
1487 StringRef Name = Var.getName();
1489 addString(VariableDie, dwarf::DW_AT_name, Name);
1490 addSourceLine(VariableDie, Var.getVariable());
1491 addType(VariableDie, Var.getType());
1492 if (Var.isArtificial())
1493 addFlag(VariableDie, dwarf::DW_AT_artificial);
1496 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1497 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1498 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1499 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1501 // The LowerBound value defines the lower bounds which is typically zero for
1502 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1503 // Count == -1 then the array is unbounded and we do not emit
1504 // DW_AT_lower_bound and DW_AT_count attributes.
1505 int64_t LowerBound = SR.getLo();
1506 int64_t DefaultLowerBound = getDefaultLowerBound();
1507 int64_t Count = SR.getCount();
1509 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1510 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1513 // FIXME: An unbounded array should reference the expression that defines
1515 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1518 DIE *DwarfUnit::getIndexTyDie() {
1521 // Construct an integer type to use for indexes.
1522 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1523 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1524 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1525 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1526 dwarf::DW_ATE_unsigned);
1530 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1531 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1533 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1535 // Emit the element type.
1536 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1538 // Get an anonymous type for index type.
1539 // FIXME: This type should be passed down from the front end
1540 // as different languages may have different sizes for indexes.
1541 DIE *IdxTy = getIndexTyDie();
1543 // Add subranges to array type.
1544 DIArray Elements = CTy.getElements();
1545 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1546 DIDescriptor Element = Elements.getElement(i);
1547 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1548 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1552 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1553 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1554 DIArray Elements = CTy.getElements();
1556 // Add enumerators to enumeration type.
1557 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1558 DIEnumerator Enum(Elements.getElement(i));
1559 if (Enum.isEnumerator()) {
1560 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1561 StringRef Name = Enum.getName();
1562 addString(Enumerator, dwarf::DW_AT_name, Name);
1563 int64_t Value = Enum.getEnumValue();
1564 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1568 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1570 addType(Buffer, DTy);
1571 addFlag(Buffer, dwarf::DW_AT_enum_class);
1575 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1577 void DwarfUnit::constructContainingTypeDIEs() {
1578 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1579 CE = ContainingTypeMap.end();
1581 DIE &SPDie = *CI->first;
1582 DIDescriptor D(CI->second);
1585 DIE *NDie = getDIE(D);
1588 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1592 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1593 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1594 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1595 StringRef Name = DT.getName();
1597 addString(MemberDie, dwarf::DW_AT_name, Name);
1599 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1601 addSourceLine(MemberDie, DT);
1603 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1605 // For C++, virtual base classes are not at fixed offset. Use following
1606 // expression to extract appropriate offset from vtable.
1607 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1609 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1610 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1611 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1612 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1613 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1614 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1615 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1616 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1618 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1620 uint64_t Size = DT.getSizeInBits();
1621 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1622 uint64_t OffsetInBytes;
1624 if (Size != FieldSize) {
1625 // Handle bitfield, assume bytes are 8 bits.
1626 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1627 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1629 uint64_t Offset = DT.getOffsetInBits();
1630 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1631 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1632 uint64_t FieldOffset = (HiMark - FieldSize);
1633 Offset -= FieldOffset;
1635 // Maybe we need to work from the other end.
1636 if (Asm->getDataLayout().isLittleEndian())
1637 Offset = FieldSize - (Offset + Size);
1638 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1640 // Here DW_AT_data_member_location points to the anonymous
1641 // field that includes this bit field.
1642 OffsetInBytes = FieldOffset >> 3;
1644 // This is not a bitfield.
1645 OffsetInBytes = DT.getOffsetInBits() >> 3;
1647 if (DD->getDwarfVersion() <= 2) {
1648 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1649 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1650 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1651 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1653 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1657 if (DT.isProtected())
1658 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1659 dwarf::DW_ACCESS_protected);
1660 else if (DT.isPrivate())
1661 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1662 dwarf::DW_ACCESS_private);
1663 // Otherwise C++ member and base classes are considered public.
1664 else if (DT.isPublic())
1665 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1666 dwarf::DW_ACCESS_public);
1668 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1669 dwarf::DW_VIRTUALITY_virtual);
1671 // Objective-C properties.
1672 if (MDNode *PNode = DT.getObjCProperty())
1673 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1674 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1677 if (DT.isArtificial())
1678 addFlag(MemberDie, dwarf::DW_AT_artificial);
1681 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1682 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1686 // Construct the context before querying for the existence of the DIE in case
1687 // such construction creates the DIE.
1688 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1689 assert(dwarf::isType(ContextDIE->getTag()) &&
1690 "Static member should belong to a type.");
1692 if (DIE *StaticMemberDIE = getDIE(DT))
1693 return StaticMemberDIE;
1695 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1697 DIType Ty = resolve(DT.getTypeDerivedFrom());
1699 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1700 addType(StaticMemberDIE, Ty);
1701 addSourceLine(StaticMemberDIE, DT);
1702 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1703 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1705 // FIXME: We could omit private if the parent is a class_type, and
1706 // public if the parent is something else.
1707 if (DT.isProtected())
1708 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1709 dwarf::DW_ACCESS_protected);
1710 else if (DT.isPrivate())
1711 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1712 dwarf::DW_ACCESS_private);
1713 else if (DT.isPublic())
1714 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1715 dwarf::DW_ACCESS_public);
1717 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1718 addConstantValue(StaticMemberDIE, CI, Ty);
1719 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1720 addConstantFPValue(StaticMemberDIE, CFP);
1722 return &StaticMemberDIE;
1725 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1726 // Emit size of content not including length itself
1727 Asm->OutStreamer.AddComment("Length of Unit");
1728 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1730 Asm->OutStreamer.AddComment("DWARF version number");
1731 Asm->EmitInt16(DD->getDwarfVersion());
1732 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1733 // We share one abbreviations table across all units so it's always at the
1734 // start of the section. Use a relocatable offset where needed to ensure
1735 // linking doesn't invalidate that offset.
1737 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1739 // Use a constant value when no symbol is provided.
1741 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1742 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1745 void DwarfUnit::initSection(const MCSection *Section) {
1746 assert(!this->Section);
1747 this->Section = Section;
1750 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1751 DwarfUnit::emitHeader(ASectionSym);
1752 Asm->OutStreamer.AddComment("Type Signature");
1753 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1754 Asm->OutStreamer.AddComment("Type DIE Offset");
1755 // In a skeleton type unit there is no type DIE so emit a zero offset.
1756 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1757 sizeof(Ty->getOffset()));