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 /// addRegisterOp - Add register operand.
415 // FIXME: Ideally, this would share the implementation with
416 // AsmPrinter::EmitDwarfRegOpPiece.
417 void DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
418 unsigned SizeInBits, unsigned OffsetInBits) {
419 const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
420 int DWReg = RI->getDwarfRegNum(Reg, false);
421 bool isSubRegister = DWReg < 0;
425 // Go up the super-register chain until we hit a valid dwarf register number.
426 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
427 DWReg = RI->getDwarfRegNum(*SR, false);
429 Idx = RI->getSubRegIndex(*SR, Reg);
433 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
434 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
440 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
442 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
443 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
447 bool isPiece = SizeInBits > 0;
448 if (isSubRegister || isPiece) {
449 const unsigned SizeOfByte = 8;
450 unsigned RegSizeInBits = RI->getSubRegIdxSize(Idx);
451 unsigned RegOffsetInBits = RI->getSubRegIdxOffset(Idx);
452 unsigned PieceSizeInBits = std::max(SizeInBits, RegSizeInBits);
453 unsigned PieceOffsetInBits = OffsetInBits ? OffsetInBits : RegOffsetInBits;
454 assert(RegSizeInBits >= SizeInBits && "register smaller than value");
456 if (RegOffsetInBits != PieceOffsetInBits) {
457 // Manually shift the value into place, since the DW_OP_piece
458 // describes the part of the variable, not the position of the
460 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
461 addUInt(TheDie, dwarf::DW_FORM_data1, RegOffsetInBits);
462 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_shr);
465 if (PieceOffsetInBits > 0 || PieceSizeInBits % SizeOfByte) {
466 assert(PieceSizeInBits > 0 && "piece has zero size");
467 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
468 addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits);
469 addUInt(TheDie, dwarf::DW_FORM_data1, PieceOffsetInBits);
471 assert(PieceSizeInBits > 0 && "piece has zero size");
472 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
473 addUInt(TheDie, dwarf::DW_FORM_data1, PieceSizeInBits/SizeOfByte);
478 /// addRegisterOffset - Add register offset.
479 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
481 const TargetRegisterInfo *RI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
482 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
483 const TargetRegisterInfo *TRI = Asm->TM.getSubtargetImpl()->getRegisterInfo();
484 if (Reg == TRI->getFrameRegister(*Asm->MF))
485 // If variable offset is based in frame register then use fbreg.
486 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
488 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
490 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
491 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
493 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
496 /// addComplexAddress - Start with the address based on the location provided,
497 /// and generate the DWARF information necessary to find the actual variable
498 /// given the extra address information encoded in the DbgVariable, starting
499 /// from the starting location. Add the DWARF information to the die.
501 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
502 dwarf::Attribute Attribute,
503 const MachineLocation &Location) {
504 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
505 unsigned N = DV.getNumAddrElements();
507 if (Location.isReg()) {
508 if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_plus) {
509 assert(!DV.getVariable().isIndirect() &&
510 "double indirection not handled");
511 // If first address element is OpPlus then emit
512 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
513 addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1));
515 } else if (N >= 2 && DV.getAddrElement(0) == dwarf::DW_OP_deref) {
516 assert(!DV.getVariable().isIndirect() &&
517 "double indirection not handled");
518 addRegisterOpPiece(*Loc, Location.getReg(),
519 DV.getExpression().getPieceSize(),
520 DV.getExpression().getPieceOffset());
523 addRegisterOpPiece(*Loc, Location.getReg());
525 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
528 uint64_t Element = DV.getAddrElement(i);
529 if (Element == dwarf::DW_OP_plus) {
530 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
531 addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
533 } else if (Element == dwarf::DW_OP_deref) {
534 if (!Location.isReg())
535 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
537 } else if (Element == dwarf::DW_OP_piece) {
538 const unsigned SizeOfByte = 8;
539 unsigned PieceOffsetInBits = DV.getAddrElement(++i)*SizeOfByte;
540 unsigned PieceSizeInBits = DV.getAddrElement(++i)*SizeOfByte;
541 // Emit DW_OP_bit_piece Size Offset.
542 assert(PieceSizeInBits > 0 && "piece has zero size");
543 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
544 addUInt(*Loc, dwarf::DW_FORM_udata, PieceSizeInBits);
545 addUInt(*Loc, dwarf::DW_FORM_udata, PieceOffsetInBits);
548 llvm_unreachable("unknown DIBuilder Opcode");
551 // Now attach the location information to the DIE.
552 addBlock(Die, Attribute, Loc);
555 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
556 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
557 gives the variable VarName either the struct, or a pointer to the struct, as
558 its type. This is necessary for various behind-the-scenes things the
559 compiler needs to do with by-reference variables in Blocks.
561 However, as far as the original *programmer* is concerned, the variable
562 should still have type 'SomeType', as originally declared.
564 The function getBlockByrefType dives into the __Block_byref_x_VarName
565 struct to find the original type of the variable, which is then assigned to
566 the variable's Debug Information Entry as its real type. So far, so good.
567 However now the debugger will expect the variable VarName to have the type
568 SomeType. So we need the location attribute for the variable to be an
569 expression that explains to the debugger how to navigate through the
570 pointers and struct to find the actual variable of type SomeType.
572 The following function does just that. We start by getting
573 the "normal" location for the variable. This will be the location
574 of either the struct __Block_byref_x_VarName or the pointer to the
575 struct __Block_byref_x_VarName.
577 The struct will look something like:
579 struct __Block_byref_x_VarName {
581 struct __Block_byref_x_VarName *forwarding;
582 ... <various other fields>
584 ... <maybe more fields>
587 If we are given the struct directly (as our starting point) we
588 need to tell the debugger to:
590 1). Add the offset of the forwarding field.
592 2). Follow that pointer to get the real __Block_byref_x_VarName
593 struct to use (the real one may have been copied onto the heap).
595 3). Add the offset for the field VarName, to find the actual variable.
597 If we started with a pointer to the struct, then we need to
598 dereference that pointer first, before the other steps.
599 Translating this into DWARF ops, we will need to append the following
600 to the current location description for the variable:
602 DW_OP_deref -- optional, if we start with a pointer
603 DW_OP_plus_uconst <forward_fld_offset>
605 DW_OP_plus_uconst <varName_fld_offset>
607 That is what this function does. */
609 /// addBlockByrefAddress - Start with the address based on the location
610 /// provided, and generate the DWARF information necessary to find the
611 /// actual Block variable (navigating the Block struct) based on the
612 /// starting location. Add the DWARF information to the die. For
613 /// more information, read large comment just above here.
615 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
616 dwarf::Attribute Attribute,
617 const MachineLocation &Location) {
618 DIType Ty = DV.getType();
620 uint16_t Tag = Ty.getTag();
621 bool isPointer = false;
623 StringRef varName = DV.getName();
625 if (Tag == dwarf::DW_TAG_pointer_type) {
626 DIDerivedType DTy(Ty);
627 TmpTy = resolve(DTy.getTypeDerivedFrom());
631 DICompositeType blockStruct(TmpTy);
633 // Find the __forwarding field and the variable field in the __Block_byref
635 DIArray Fields = blockStruct.getElements();
636 DIDerivedType varField;
637 DIDerivedType forwardingField;
639 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
640 DIDerivedType DT(Fields.getElement(i));
641 StringRef fieldName = DT.getName();
642 if (fieldName == "__forwarding")
643 forwardingField = DT;
644 else if (fieldName == varName)
648 // Get the offsets for the forwarding field and the variable field.
649 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
650 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
652 // Decode the original location, and use that as the start of the byref
653 // variable's location.
654 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
656 if (Location.isReg())
657 addRegisterOpPiece(*Loc, Location.getReg());
659 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
661 // If we started with a pointer to the __Block_byref... struct, then
662 // the first thing we need to do is dereference the pointer (DW_OP_deref).
664 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
666 // Next add the offset for the '__forwarding' field:
667 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
668 // adding the offset if it's 0.
669 if (forwardingFieldOffset > 0) {
670 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
671 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
674 // Now dereference the __forwarding field to get to the real __Block_byref
675 // struct: DW_OP_deref.
676 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
678 // Now that we've got the real __Block_byref... struct, add the offset
679 // for the variable's field to get to the location of the actual variable:
680 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
681 if (varFieldOffset > 0) {
682 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
683 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
686 // Now attach the location information to the DIE.
687 addBlock(Die, Attribute, Loc);
690 /// Return true if type encoding is unsigned.
691 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
692 DIDerivedType DTy(Ty);
693 if (DTy.isDerivedType()) {
694 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
695 // Encode pointer constants as unsigned bytes. This is used at least for
696 // null pointer constant emission.
697 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
698 // here, but accept them for now due to a bug in SROA producing bogus
700 if (T == dwarf::DW_TAG_pointer_type ||
701 T == dwarf::DW_TAG_ptr_to_member_type ||
702 T == dwarf::DW_TAG_reference_type ||
703 T == dwarf::DW_TAG_rvalue_reference_type)
705 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
706 T == dwarf::DW_TAG_volatile_type ||
707 T == dwarf::DW_TAG_restrict_type ||
708 T == dwarf::DW_TAG_enumeration_type);
709 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
710 return isUnsignedDIType(DD, DD->resolve(Deriv));
711 // FIXME: Enums without a fixed underlying type have unknown signedness
712 // here, leading to incorrectly emitted constants.
713 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
718 assert(BTy.isBasicType());
719 unsigned Encoding = BTy.getEncoding();
720 assert((Encoding == dwarf::DW_ATE_unsigned ||
721 Encoding == dwarf::DW_ATE_unsigned_char ||
722 Encoding == dwarf::DW_ATE_signed ||
723 Encoding == dwarf::DW_ATE_signed_char ||
724 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) &&
725 "Unsupported encoding");
726 return (Encoding == dwarf::DW_ATE_unsigned ||
727 Encoding == dwarf::DW_ATE_unsigned_char ||
728 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean);
731 /// If this type is derived from a base type then return base type size.
732 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
733 unsigned Tag = Ty.getTag();
735 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
736 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
737 Tag != dwarf::DW_TAG_restrict_type)
738 return Ty.getSizeInBits();
740 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
742 // If this type is not derived from any type or the type is a declaration then
743 // take conservative approach.
744 if (!BaseType.isValid() || BaseType.isForwardDecl())
745 return Ty.getSizeInBits();
747 // If this is a derived type, go ahead and get the base type, unless it's a
748 // reference then it's just the size of the field. Pointer types have no need
749 // of this since they're a different type of qualification on the type.
750 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
751 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
752 return Ty.getSizeInBits();
754 if (BaseType.isDerivedType())
755 return getBaseTypeSize(DD, DIDerivedType(BaseType));
757 return BaseType.getSizeInBits();
760 /// addConstantFPValue - Add constant value entry in variable DIE.
761 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
762 assert(MO.isFPImm() && "Invalid machine operand!");
763 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
764 APFloat FPImm = MO.getFPImm()->getValueAPF();
766 // Get the raw data form of the floating point.
767 const APInt FltVal = FPImm.bitcastToAPInt();
768 const char *FltPtr = (const char *)FltVal.getRawData();
770 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
771 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
772 int Incr = (LittleEndian ? 1 : -1);
773 int Start = (LittleEndian ? 0 : NumBytes - 1);
774 int Stop = (LittleEndian ? NumBytes : -1);
776 // Output the constant to DWARF one byte at a time.
777 for (; Start != Stop; Start += Incr)
778 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
780 addBlock(Die, dwarf::DW_AT_const_value, Block);
783 /// addConstantFPValue - Add constant value entry in variable DIE.
784 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
785 // Pass this down to addConstantValue as an unsigned bag of bits.
786 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
789 /// addConstantValue - Add constant value entry in variable DIE.
790 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
791 addConstantValue(Die, CI->getValue(), Ty);
794 /// addConstantValue - Add constant value entry in variable DIE.
795 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
797 assert(MO.isImm() && "Invalid machine operand!");
799 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
802 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
803 // FIXME: This is a bit conservative/simple - it emits negative values always
804 // sign extended to 64 bits rather than minimizing the number of bytes.
805 addUInt(Die, dwarf::DW_AT_const_value,
806 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
809 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
810 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
813 // addConstantValue - Add constant value entry in variable DIE.
814 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
815 unsigned CIBitWidth = Val.getBitWidth();
816 if (CIBitWidth <= 64) {
817 addConstantValue(Die, Unsigned,
818 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
822 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
824 // Get the raw data form of the large APInt.
825 const uint64_t *Ptr64 = Val.getRawData();
827 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
828 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
830 // Output the constant to DWARF one byte at a time.
831 for (int i = 0; i < NumBytes; i++) {
834 c = Ptr64[i / 8] >> (8 * (i & 7));
836 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
837 addUInt(*Block, dwarf::DW_FORM_data1, c);
840 addBlock(Die, dwarf::DW_AT_const_value, Block);
843 /// addTemplateParams - Add template parameters into buffer.
844 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
845 // Add template parameters.
846 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
847 DIDescriptor Element = TParams.getElement(i);
848 if (Element.isTemplateTypeParameter())
849 constructTemplateTypeParameterDIE(Buffer,
850 DITemplateTypeParameter(Element));
851 else if (Element.isTemplateValueParameter())
852 constructTemplateValueParameterDIE(Buffer,
853 DITemplateValueParameter(Element));
857 /// getOrCreateContextDIE - Get context owner's DIE.
858 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
859 if (!Context || Context.isFile())
860 return &getUnitDie();
861 if (Context.isType())
862 return getOrCreateTypeDIE(DIType(Context));
863 if (Context.isNameSpace())
864 return getOrCreateNameSpace(DINameSpace(Context));
865 if (Context.isSubprogram())
866 return getOrCreateSubprogramDIE(DISubprogram(Context));
867 return getDIE(Context);
870 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
871 DIScope Context = resolve(Ty.getContext());
872 DIE *ContextDIE = getOrCreateContextDIE(Context);
874 if (DIE *TyDIE = getDIE(Ty))
878 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
880 constructTypeDIE(TyDIE, Ty);
882 updateAcceleratorTables(Context, Ty, TyDIE);
886 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
888 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
894 assert(Ty == resolve(Ty.getRef()) &&
895 "type was not uniqued, possible ODR violation.");
897 // DW_TAG_restrict_type is not supported in DWARF2
898 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
899 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
901 // Construct the context before querying for the existence of the DIE in case
902 // such construction creates the DIE.
903 DIScope Context = resolve(Ty.getContext());
904 DIE *ContextDIE = getOrCreateContextDIE(Context);
907 if (DIE *TyDIE = getDIE(Ty))
911 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
913 updateAcceleratorTables(Context, Ty, TyDIE);
915 if (Ty.isBasicType())
916 constructTypeDIE(TyDIE, DIBasicType(Ty));
917 else if (Ty.isCompositeType()) {
918 DICompositeType CTy(Ty);
919 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
920 if (MDString *TypeId = CTy.getIdentifier()) {
921 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
922 // Skip updating the accelerator tables since this is not the full type.
925 constructTypeDIE(TyDIE, CTy);
927 assert(Ty.isDerivedType() && "Unknown kind of DIType");
928 constructTypeDIE(TyDIE, DIDerivedType(Ty));
934 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
936 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
937 bool IsImplementation = 0;
938 if (Ty.isCompositeType()) {
939 DICompositeType CT(Ty);
940 // A runtime language of 0 actually means C/C++ and that any
941 // non-negative value is some version of Objective-C/C++.
942 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
944 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
945 DD->addAccelType(Ty.getName(), TyDIE, Flags);
947 if (!Context || Context.isCompileUnit() || Context.isFile() ||
948 Context.isNameSpace())
949 addGlobalType(Ty, TyDIE, Context);
953 /// addType - Add a new type attribute to the specified entity.
954 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
955 assert(Ty && "Trying to add a type that doesn't exist?");
957 // Check for pre-existence.
958 DIEEntry *Entry = getDIEEntry(Ty);
959 // If it exists then use the existing value.
961 addDIEEntry(Entity, Attribute, Entry);
966 DIE *Buffer = getOrCreateTypeDIE(Ty);
969 Entry = createDIEEntry(*Buffer);
970 insertDIEEntry(Ty, Entry);
971 addDIEEntry(Entity, Attribute, Entry);
974 /// getParentContextString - Walks the metadata parent chain in a language
975 /// specific manner (using the compile unit language) and returns
976 /// it as a string. This is done at the metadata level because DIEs may
977 /// not currently have been added to the parent context and walking the
978 /// DIEs looking for names is more expensive than walking the metadata.
979 std::string DwarfUnit::getParentContextString(DIScope Context) const {
983 // FIXME: Decide whether to implement this for non-C++ languages.
984 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
988 SmallVector<DIScope, 1> Parents;
989 while (!Context.isCompileUnit()) {
990 Parents.push_back(Context);
991 if (Context.getContext())
992 Context = resolve(Context.getContext());
994 // Structure, etc types will have a NULL context if they're at the top
999 // Reverse iterate over our list to go from the outermost construct to the
1001 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1005 StringRef Name = Ctx.getName();
1006 if (Name.empty() && Ctx.isNameSpace())
1007 Name = "(anonymous namespace)";
1008 if (!Name.empty()) {
1016 /// constructTypeDIE - Construct basic type die from DIBasicType.
1017 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1018 // Get core information.
1019 StringRef Name = BTy.getName();
1020 // Add name if not anonymous or intermediate type.
1022 addString(Buffer, dwarf::DW_AT_name, Name);
1024 // An unspecified type only has a name attribute.
1025 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1028 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1031 uint64_t Size = BTy.getSizeInBits() >> 3;
1032 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1035 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1036 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1037 // Get core information.
1038 StringRef Name = DTy.getName();
1039 uint64_t Size = DTy.getSizeInBits() >> 3;
1040 uint16_t Tag = Buffer.getTag();
1042 // Map to main type, void will not have a type.
1043 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1045 addType(Buffer, FromTy);
1047 // Add name if not anonymous or intermediate type.
1049 addString(Buffer, dwarf::DW_AT_name, Name);
1051 // Add size if non-zero (derived types might be zero-sized.)
1052 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1053 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1055 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1056 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1057 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1058 // Add source line info if available and TyDesc is not a forward declaration.
1059 if (!DTy.isForwardDecl())
1060 addSourceLine(Buffer, DTy);
1063 /// constructSubprogramArguments - Construct function argument DIEs.
1064 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1065 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1066 DIType Ty = resolve(Args.getElement(i));
1068 assert(i == N-1 && "Unspecified parameter must be the last argument");
1069 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1071 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1073 if (Ty.isArtificial())
1074 addFlag(Arg, dwarf::DW_AT_artificial);
1079 /// constructTypeDIE - Construct type DIE from DICompositeType.
1080 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1081 // Add name if not anonymous or intermediate type.
1082 StringRef Name = CTy.getName();
1084 uint64_t Size = CTy.getSizeInBits() >> 3;
1085 uint16_t Tag = Buffer.getTag();
1088 case dwarf::DW_TAG_array_type:
1089 constructArrayTypeDIE(Buffer, CTy);
1091 case dwarf::DW_TAG_enumeration_type:
1092 constructEnumTypeDIE(Buffer, CTy);
1094 case dwarf::DW_TAG_subroutine_type: {
1095 // Add return type. A void return won't have a type.
1096 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1097 DIType RTy(resolve(Elements.getElement(0)));
1099 addType(Buffer, RTy);
1101 bool isPrototyped = true;
1102 if (Elements.getNumElements() == 2 &&
1103 !Elements.getElement(1))
1104 isPrototyped = false;
1106 constructSubprogramArguments(Buffer, Elements);
1108 // Add prototype flag if we're dealing with a C language and the
1109 // function has been prototyped.
1110 uint16_t Language = getLanguage();
1112 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1113 Language == dwarf::DW_LANG_ObjC))
1114 addFlag(Buffer, dwarf::DW_AT_prototyped);
1116 if (CTy.isLValueReference())
1117 addFlag(Buffer, dwarf::DW_AT_reference);
1119 if (CTy.isRValueReference())
1120 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1122 case dwarf::DW_TAG_structure_type:
1123 case dwarf::DW_TAG_union_type:
1124 case dwarf::DW_TAG_class_type: {
1125 // Add elements to structure type.
1126 DIArray Elements = CTy.getElements();
1127 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1128 DIDescriptor Element = Elements.getElement(i);
1129 if (Element.isSubprogram())
1130 getOrCreateSubprogramDIE(DISubprogram(Element));
1131 else if (Element.isDerivedType()) {
1132 DIDerivedType DDTy(Element);
1133 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1134 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1135 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1136 dwarf::DW_AT_friend);
1137 } else if (DDTy.isStaticMember()) {
1138 getOrCreateStaticMemberDIE(DDTy);
1140 constructMemberDIE(Buffer, DDTy);
1142 } else if (Element.isObjCProperty()) {
1143 DIObjCProperty Property(Element);
1144 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1145 StringRef PropertyName = Property.getObjCPropertyName();
1146 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1147 if (Property.getType())
1148 addType(ElemDie, Property.getType());
1149 addSourceLine(ElemDie, Property);
1150 StringRef GetterName = Property.getObjCPropertyGetterName();
1151 if (!GetterName.empty())
1152 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1153 StringRef SetterName = Property.getObjCPropertySetterName();
1154 if (!SetterName.empty())
1155 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1156 unsigned PropertyAttributes = 0;
1157 if (Property.isReadOnlyObjCProperty())
1158 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1159 if (Property.isReadWriteObjCProperty())
1160 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1161 if (Property.isAssignObjCProperty())
1162 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1163 if (Property.isRetainObjCProperty())
1164 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1165 if (Property.isCopyObjCProperty())
1166 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1167 if (Property.isNonAtomicObjCProperty())
1168 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1169 if (PropertyAttributes)
1170 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1171 PropertyAttributes);
1173 DIEEntry *Entry = getDIEEntry(Element);
1175 Entry = createDIEEntry(ElemDie);
1176 insertDIEEntry(Element, Entry);
1182 if (CTy.isAppleBlockExtension())
1183 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1185 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1187 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1188 *getOrCreateTypeDIE(ContainingType));
1190 if (CTy.isObjcClassComplete())
1191 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1193 // Add template parameters to a class, structure or union types.
1194 // FIXME: The support isn't in the metadata for this yet.
1195 if (Tag == dwarf::DW_TAG_class_type ||
1196 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1197 addTemplateParams(Buffer, CTy.getTemplateParams());
1205 // Add name if not anonymous or intermediate type.
1207 addString(Buffer, dwarf::DW_AT_name, Name);
1209 if (Tag == dwarf::DW_TAG_enumeration_type ||
1210 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1211 Tag == dwarf::DW_TAG_union_type) {
1212 // Add size if non-zero (derived types might be zero-sized.)
1213 // TODO: Do we care about size for enum forward declarations?
1215 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1216 else if (!CTy.isForwardDecl())
1217 // Add zero size if it is not a forward declaration.
1218 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1220 // If we're a forward decl, say so.
1221 if (CTy.isForwardDecl())
1222 addFlag(Buffer, dwarf::DW_AT_declaration);
1224 // Add source line info if available.
1225 if (!CTy.isForwardDecl())
1226 addSourceLine(Buffer, CTy);
1228 // No harm in adding the runtime language to the declaration.
1229 unsigned RLang = CTy.getRunTimeLang();
1231 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1236 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1237 /// DITemplateTypeParameter.
1238 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1239 DITemplateTypeParameter TP) {
1241 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1242 // Add the type if it exists, it could be void and therefore no type.
1244 addType(ParamDIE, resolve(TP.getType()));
1245 if (!TP.getName().empty())
1246 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1249 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1250 /// DITemplateValueParameter.
1252 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1253 DITemplateValueParameter VP) {
1254 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1256 // Add the type if there is one, template template and template parameter
1257 // packs will not have a type.
1258 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1259 addType(ParamDIE, resolve(VP.getType()));
1260 if (!VP.getName().empty())
1261 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1262 if (Value *Val = VP.getValue()) {
1263 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1264 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1265 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1266 // For declaration non-type template parameters (such as global values and
1268 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1269 addOpAddress(*Loc, Asm->getSymbol(GV));
1270 // Emit DW_OP_stack_value to use the address as the immediate value of the
1271 // parameter, rather than a pointer to it.
1272 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1273 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1274 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1275 assert(isa<MDString>(Val));
1276 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1277 cast<MDString>(Val)->getString());
1278 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1279 assert(isa<MDNode>(Val));
1280 DIArray A(cast<MDNode>(Val));
1281 addTemplateParams(ParamDIE, A);
1286 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1287 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1288 // Construct the context before querying for the existence of the DIE in case
1289 // such construction creates the DIE.
1290 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1292 if (DIE *NDie = getDIE(NS))
1294 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1296 StringRef Name = NS.getName();
1298 addString(NDie, dwarf::DW_AT_name, NS.getName());
1300 Name = "(anonymous namespace)";
1301 DD->addAccelNamespace(Name, NDie);
1302 addGlobalName(Name, NDie, NS.getContext());
1303 addSourceLine(NDie, NS);
1307 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1308 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1309 // Construct the context before querying for the existence of the DIE in case
1310 // such construction creates the DIE (as is the case for member function
1312 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1314 if (DIE *SPDie = getDIE(SP))
1317 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1318 // Add subprogram definitions to the CU die directly.
1319 ContextDIE = &getUnitDie();
1320 // Build the decl now to ensure it precedes the definition.
1321 getOrCreateSubprogramDIE(SPDecl);
1324 // DW_TAG_inlined_subroutine may refer to this DIE.
1325 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1327 // Stop here and fill this in later, depending on whether or not this
1328 // subprogram turns out to have inlined instances or not.
1329 if (SP.isDefinition())
1332 applySubprogramAttributes(SP, SPDie);
1336 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) {
1337 DISubprogram SPDecl = SP.getFunctionDeclaration();
1338 DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
1339 applySubprogramAttributes(SP, SPDie);
1340 addGlobalName(SP.getName(), SPDie, Context);
1343 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1344 DIE *DeclDie = nullptr;
1345 StringRef DeclLinkageName;
1346 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1347 DeclDie = getDIE(SPDecl);
1348 assert(DeclDie && "This DIE should've already been constructed when the "
1349 "definition DIE was created in "
1350 "getOrCreateSubprogramDIE");
1351 DeclLinkageName = SPDecl.getLinkageName();
1354 // Add function template parameters.
1355 addTemplateParams(SPDie, SP.getTemplateParams());
1357 // Add the linkage name if we have one and it isn't in the Decl.
1358 StringRef LinkageName = SP.getLinkageName();
1359 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1360 LinkageName == DeclLinkageName) &&
1361 "decl has a linkage name and it is different");
1362 if (!LinkageName.empty() && DeclLinkageName.empty())
1363 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1364 GlobalValue::getRealLinkageName(LinkageName));
1367 // Refer to the function declaration where all the other attributes will be
1369 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1373 // Constructors and operators for anonymous aggregates do not have names.
1374 if (!SP.getName().empty())
1375 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1377 // Skip the rest of the attributes under -gmlt to save space.
1378 if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1381 addSourceLine(SPDie, SP);
1383 // Add the prototype if we have a prototype and we have a C like
1385 uint16_t Language = getLanguage();
1386 if (SP.isPrototyped() &&
1387 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1388 Language == dwarf::DW_LANG_ObjC))
1389 addFlag(SPDie, dwarf::DW_AT_prototyped);
1391 DISubroutineType SPTy = SP.getType();
1392 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1393 "the type of a subprogram should be a subroutine");
1395 DITypeArray Args = SPTy.getTypeArray();
1396 // Add a return type. If this is a type like a C/C++ void type we don't add a
1398 if (resolve(Args.getElement(0)))
1399 addType(SPDie, DIType(resolve(Args.getElement(0))));
1401 unsigned VK = SP.getVirtuality();
1403 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1404 DIELoc *Block = getDIELoc();
1405 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1406 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1407 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1408 ContainingTypeMap.insert(
1409 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1412 if (!SP.isDefinition()) {
1413 addFlag(SPDie, dwarf::DW_AT_declaration);
1415 // Add arguments. Do not add arguments for subprogram definition. They will
1416 // be handled while processing variables.
1417 constructSubprogramArguments(SPDie, Args);
1420 if (SP.isArtificial())
1421 addFlag(SPDie, dwarf::DW_AT_artificial);
1423 if (!SP.isLocalToUnit())
1424 addFlag(SPDie, dwarf::DW_AT_external);
1426 if (SP.isOptimized())
1427 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1429 if (unsigned isa = Asm->getISAEncoding()) {
1430 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1433 if (SP.isLValueReference())
1434 addFlag(SPDie, dwarf::DW_AT_reference);
1436 if (SP.isRValueReference())
1437 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1439 if (SP.isProtected())
1440 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1441 dwarf::DW_ACCESS_protected);
1442 else if (SP.isPrivate())
1443 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1444 dwarf::DW_ACCESS_private);
1445 else if (SP.isPublic())
1446 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1447 dwarf::DW_ACCESS_public);
1449 if (SP.isExplicit())
1450 addFlag(SPDie, dwarf::DW_AT_explicit);
1453 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var,
1455 StringRef Name = Var.getName();
1457 addString(VariableDie, dwarf::DW_AT_name, Name);
1458 addSourceLine(VariableDie, Var.getVariable());
1459 addType(VariableDie, Var.getType());
1460 if (Var.isArtificial())
1461 addFlag(VariableDie, dwarf::DW_AT_artificial);
1464 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1465 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1466 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1467 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1469 // The LowerBound value defines the lower bounds which is typically zero for
1470 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1471 // Count == -1 then the array is unbounded and we do not emit
1472 // DW_AT_lower_bound and DW_AT_count attributes.
1473 int64_t LowerBound = SR.getLo();
1474 int64_t DefaultLowerBound = getDefaultLowerBound();
1475 int64_t Count = SR.getCount();
1477 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1478 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1481 // FIXME: An unbounded array should reference the expression that defines
1483 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1486 DIE *DwarfUnit::getIndexTyDie() {
1489 // Construct an integer type to use for indexes.
1490 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1491 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1492 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1493 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1494 dwarf::DW_ATE_unsigned);
1498 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1499 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1501 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1503 // Emit the element type.
1504 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1506 // Get an anonymous type for index type.
1507 // FIXME: This type should be passed down from the front end
1508 // as different languages may have different sizes for indexes.
1509 DIE *IdxTy = getIndexTyDie();
1511 // Add subranges to array type.
1512 DIArray Elements = CTy.getElements();
1513 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1514 DIDescriptor Element = Elements.getElement(i);
1515 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1516 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1520 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1521 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1522 DIArray Elements = CTy.getElements();
1524 // Add enumerators to enumeration type.
1525 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1526 DIEnumerator Enum(Elements.getElement(i));
1527 if (Enum.isEnumerator()) {
1528 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1529 StringRef Name = Enum.getName();
1530 addString(Enumerator, dwarf::DW_AT_name, Name);
1531 int64_t Value = Enum.getEnumValue();
1532 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1536 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1538 addType(Buffer, DTy);
1539 addFlag(Buffer, dwarf::DW_AT_enum_class);
1543 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1545 void DwarfUnit::constructContainingTypeDIEs() {
1546 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1547 CE = ContainingTypeMap.end();
1549 DIE &SPDie = *CI->first;
1550 DIDescriptor D(CI->second);
1553 DIE *NDie = getDIE(D);
1556 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1560 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1561 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1562 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1563 StringRef Name = DT.getName();
1565 addString(MemberDie, dwarf::DW_AT_name, Name);
1567 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1569 addSourceLine(MemberDie, DT);
1571 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1573 // For C++, virtual base classes are not at fixed offset. Use following
1574 // expression to extract appropriate offset from vtable.
1575 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1577 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1578 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1579 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1580 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1581 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1582 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1583 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1584 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1586 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1588 uint64_t Size = DT.getSizeInBits();
1589 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1590 uint64_t OffsetInBytes;
1592 if (Size != FieldSize) {
1593 // Handle bitfield, assume bytes are 8 bits.
1594 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1595 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1597 uint64_t Offset = DT.getOffsetInBits();
1598 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1599 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1600 uint64_t FieldOffset = (HiMark - FieldSize);
1601 Offset -= FieldOffset;
1603 // Maybe we need to work from the other end.
1604 if (Asm->getDataLayout().isLittleEndian())
1605 Offset = FieldSize - (Offset + Size);
1606 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1608 // Here DW_AT_data_member_location points to the anonymous
1609 // field that includes this bit field.
1610 OffsetInBytes = FieldOffset >> 3;
1612 // This is not a bitfield.
1613 OffsetInBytes = DT.getOffsetInBits() >> 3;
1615 if (DD->getDwarfVersion() <= 2) {
1616 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1617 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1618 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1619 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1621 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1625 if (DT.isProtected())
1626 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1627 dwarf::DW_ACCESS_protected);
1628 else if (DT.isPrivate())
1629 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1630 dwarf::DW_ACCESS_private);
1631 // Otherwise C++ member and base classes are considered public.
1632 else if (DT.isPublic())
1633 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1634 dwarf::DW_ACCESS_public);
1636 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1637 dwarf::DW_VIRTUALITY_virtual);
1639 // Objective-C properties.
1640 if (MDNode *PNode = DT.getObjCProperty())
1641 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1642 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1645 if (DT.isArtificial())
1646 addFlag(MemberDie, dwarf::DW_AT_artificial);
1649 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1650 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1654 // Construct the context before querying for the existence of the DIE in case
1655 // such construction creates the DIE.
1656 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1657 assert(dwarf::isType(ContextDIE->getTag()) &&
1658 "Static member should belong to a type.");
1660 if (DIE *StaticMemberDIE = getDIE(DT))
1661 return StaticMemberDIE;
1663 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1665 DIType Ty = resolve(DT.getTypeDerivedFrom());
1667 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1668 addType(StaticMemberDIE, Ty);
1669 addSourceLine(StaticMemberDIE, DT);
1670 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1671 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1673 // FIXME: We could omit private if the parent is a class_type, and
1674 // public if the parent is something else.
1675 if (DT.isProtected())
1676 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1677 dwarf::DW_ACCESS_protected);
1678 else if (DT.isPrivate())
1679 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1680 dwarf::DW_ACCESS_private);
1681 else if (DT.isPublic())
1682 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1683 dwarf::DW_ACCESS_public);
1685 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1686 addConstantValue(StaticMemberDIE, CI, Ty);
1687 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1688 addConstantFPValue(StaticMemberDIE, CFP);
1690 return &StaticMemberDIE;
1693 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1694 // Emit size of content not including length itself
1695 Asm->OutStreamer.AddComment("Length of Unit");
1696 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1698 Asm->OutStreamer.AddComment("DWARF version number");
1699 Asm->EmitInt16(DD->getDwarfVersion());
1700 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1701 // We share one abbreviations table across all units so it's always at the
1702 // start of the section. Use a relocatable offset where needed to ensure
1703 // linking doesn't invalidate that offset.
1705 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1707 // Use a constant value when no symbol is provided.
1709 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1710 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1713 void DwarfUnit::initSection(const MCSection *Section) {
1714 assert(!this->Section);
1715 this->Section = Section;
1718 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1719 DwarfUnit::emitHeader(ASectionSym);
1720 Asm->OutStreamer.AddComment("Type Signature");
1721 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1722 Asm->OutStreamer.AddComment("Type DIE Offset");
1723 // In a skeleton type unit there is no type DIE so emit a zero offset.
1724 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1725 sizeof(Ty->getOffset()));