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 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
982 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] =
987 /// addType - Add a new type attribute to the specified entity.
988 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
989 assert(Ty && "Trying to add a type that doesn't exist?");
991 // Check for pre-existence.
992 DIEEntry *Entry = getDIEEntry(Ty);
993 // If it exists then use the existing value.
995 addDIEEntry(Entity, Attribute, Entry);
1000 DIE *Buffer = getOrCreateTypeDIE(Ty);
1003 Entry = createDIEEntry(*Buffer);
1004 insertDIEEntry(Ty, Entry);
1005 addDIEEntry(Entity, Attribute, Entry);
1008 /// addGlobalName - Add a new global name to the compile unit.
1009 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) {
1010 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1012 std::string FullName = getParentContextString(Context) + Name.str();
1013 GlobalNames[FullName] = &Die;
1016 /// getParentContextString - Walks the metadata parent chain in a language
1017 /// specific manner (using the compile unit language) and returns
1018 /// it as a string. This is done at the metadata level because DIEs may
1019 /// not currently have been added to the parent context and walking the
1020 /// DIEs looking for names is more expensive than walking the metadata.
1021 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1025 // FIXME: Decide whether to implement this for non-C++ languages.
1026 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1030 SmallVector<DIScope, 1> Parents;
1031 while (!Context.isCompileUnit()) {
1032 Parents.push_back(Context);
1033 if (Context.getContext())
1034 Context = resolve(Context.getContext());
1036 // Structure, etc types will have a NULL context if they're at the top
1041 // Reverse iterate over our list to go from the outermost construct to the
1043 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1047 StringRef Name = Ctx.getName();
1048 if (Name.empty() && Ctx.isNameSpace())
1049 Name = "(anonymous namespace)";
1050 if (!Name.empty()) {
1058 /// constructTypeDIE - Construct basic type die from DIBasicType.
1059 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1060 // Get core information.
1061 StringRef Name = BTy.getName();
1062 // Add name if not anonymous or intermediate type.
1064 addString(Buffer, dwarf::DW_AT_name, Name);
1066 // An unspecified type only has a name attribute.
1067 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1070 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1073 uint64_t Size = BTy.getSizeInBits() >> 3;
1074 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1077 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1078 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1079 // Get core information.
1080 StringRef Name = DTy.getName();
1081 uint64_t Size = DTy.getSizeInBits() >> 3;
1082 uint16_t Tag = Buffer.getTag();
1084 // Map to main type, void will not have a type.
1085 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1087 addType(Buffer, FromTy);
1089 // Add name if not anonymous or intermediate type.
1091 addString(Buffer, dwarf::DW_AT_name, Name);
1093 // Add size if non-zero (derived types might be zero-sized.)
1094 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1095 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1097 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1098 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1099 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
1100 // Add source line info if available and TyDesc is not a forward declaration.
1101 if (!DTy.isForwardDecl())
1102 addSourceLine(Buffer, DTy);
1105 /// constructSubprogramArguments - Construct function argument DIEs.
1106 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
1107 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1108 DIType Ty = resolve(Args.getElement(i));
1110 assert(i == N-1 && "Unspecified parameter must be the last argument");
1111 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1113 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1115 if (Ty.isArtificial())
1116 addFlag(Arg, dwarf::DW_AT_artificial);
1121 /// constructTypeDIE - Construct type DIE from DICompositeType.
1122 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1123 // Add name if not anonymous or intermediate type.
1124 StringRef Name = CTy.getName();
1126 uint64_t Size = CTy.getSizeInBits() >> 3;
1127 uint16_t Tag = Buffer.getTag();
1130 case dwarf::DW_TAG_array_type:
1131 constructArrayTypeDIE(Buffer, CTy);
1133 case dwarf::DW_TAG_enumeration_type:
1134 constructEnumTypeDIE(Buffer, CTy);
1136 case dwarf::DW_TAG_subroutine_type: {
1137 // Add return type. A void return won't have a type.
1138 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
1139 DIType RTy(resolve(Elements.getElement(0)));
1141 addType(Buffer, RTy);
1143 bool isPrototyped = true;
1144 if (Elements.getNumElements() == 2 &&
1145 !Elements.getElement(1))
1146 isPrototyped = false;
1148 constructSubprogramArguments(Buffer, Elements);
1150 // Add prototype flag if we're dealing with a C language and the
1151 // function has been prototyped.
1152 uint16_t Language = getLanguage();
1154 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1155 Language == dwarf::DW_LANG_ObjC))
1156 addFlag(Buffer, dwarf::DW_AT_prototyped);
1158 if (CTy.isLValueReference())
1159 addFlag(Buffer, dwarf::DW_AT_reference);
1161 if (CTy.isRValueReference())
1162 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1164 case dwarf::DW_TAG_structure_type:
1165 case dwarf::DW_TAG_union_type:
1166 case dwarf::DW_TAG_class_type: {
1167 // Add elements to structure type.
1168 DIArray Elements = CTy.getElements();
1169 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1170 DIDescriptor Element = Elements.getElement(i);
1171 if (Element.isSubprogram())
1172 getOrCreateSubprogramDIE(DISubprogram(Element));
1173 else if (Element.isDerivedType()) {
1174 DIDerivedType DDTy(Element);
1175 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1176 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1177 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1178 dwarf::DW_AT_friend);
1179 } else if (DDTy.isStaticMember()) {
1180 getOrCreateStaticMemberDIE(DDTy);
1182 constructMemberDIE(Buffer, DDTy);
1184 } else if (Element.isObjCProperty()) {
1185 DIObjCProperty Property(Element);
1186 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1187 StringRef PropertyName = Property.getObjCPropertyName();
1188 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1189 if (Property.getType())
1190 addType(ElemDie, Property.getType());
1191 addSourceLine(ElemDie, Property);
1192 StringRef GetterName = Property.getObjCPropertyGetterName();
1193 if (!GetterName.empty())
1194 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1195 StringRef SetterName = Property.getObjCPropertySetterName();
1196 if (!SetterName.empty())
1197 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1198 unsigned PropertyAttributes = 0;
1199 if (Property.isReadOnlyObjCProperty())
1200 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1201 if (Property.isReadWriteObjCProperty())
1202 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1203 if (Property.isAssignObjCProperty())
1204 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1205 if (Property.isRetainObjCProperty())
1206 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1207 if (Property.isCopyObjCProperty())
1208 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1209 if (Property.isNonAtomicObjCProperty())
1210 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1211 if (PropertyAttributes)
1212 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1213 PropertyAttributes);
1215 DIEEntry *Entry = getDIEEntry(Element);
1217 Entry = createDIEEntry(ElemDie);
1218 insertDIEEntry(Element, Entry);
1224 if (CTy.isAppleBlockExtension())
1225 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1227 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1229 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1230 *getOrCreateTypeDIE(ContainingType));
1232 if (CTy.isObjcClassComplete())
1233 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1235 // Add template parameters to a class, structure or union types.
1236 // FIXME: The support isn't in the metadata for this yet.
1237 if (Tag == dwarf::DW_TAG_class_type ||
1238 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1239 addTemplateParams(Buffer, CTy.getTemplateParams());
1247 // Add name if not anonymous or intermediate type.
1249 addString(Buffer, dwarf::DW_AT_name, Name);
1251 if (Tag == dwarf::DW_TAG_enumeration_type ||
1252 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1253 Tag == dwarf::DW_TAG_union_type) {
1254 // Add size if non-zero (derived types might be zero-sized.)
1255 // TODO: Do we care about size for enum forward declarations?
1257 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1258 else if (!CTy.isForwardDecl())
1259 // Add zero size if it is not a forward declaration.
1260 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1262 // If we're a forward decl, say so.
1263 if (CTy.isForwardDecl())
1264 addFlag(Buffer, dwarf::DW_AT_declaration);
1266 // Add source line info if available.
1267 if (!CTy.isForwardDecl())
1268 addSourceLine(Buffer, CTy);
1270 // No harm in adding the runtime language to the declaration.
1271 unsigned RLang = CTy.getRunTimeLang();
1273 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1278 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1279 /// DITemplateTypeParameter.
1280 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1281 DITemplateTypeParameter TP) {
1283 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1284 // Add the type if it exists, it could be void and therefore no type.
1286 addType(ParamDIE, resolve(TP.getType()));
1287 if (!TP.getName().empty())
1288 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1291 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1292 /// DITemplateValueParameter.
1294 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1295 DITemplateValueParameter VP) {
1296 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1298 // Add the type if there is one, template template and template parameter
1299 // packs will not have a type.
1300 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1301 addType(ParamDIE, resolve(VP.getType()));
1302 if (!VP.getName().empty())
1303 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1304 if (Value *Val = VP.getValue()) {
1305 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1306 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1307 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1308 // For declaration non-type template parameters (such as global values and
1310 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1311 addOpAddress(*Loc, Asm->getSymbol(GV));
1312 // Emit DW_OP_stack_value to use the address as the immediate value of the
1313 // parameter, rather than a pointer to it.
1314 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1315 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1316 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1317 assert(isa<MDString>(Val));
1318 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1319 cast<MDString>(Val)->getString());
1320 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1321 assert(isa<MDNode>(Val));
1322 DIArray A(cast<MDNode>(Val));
1323 addTemplateParams(ParamDIE, A);
1328 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1329 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1330 // Construct the context before querying for the existence of the DIE in case
1331 // such construction creates the DIE.
1332 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1334 if (DIE *NDie = getDIE(NS))
1336 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1338 StringRef Name = NS.getName();
1340 addString(NDie, dwarf::DW_AT_name, NS.getName());
1342 Name = "(anonymous namespace)";
1343 DD->addAccelNamespace(Name, NDie);
1344 addGlobalName(Name, NDie, NS.getContext());
1345 addSourceLine(NDie, NS);
1349 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1350 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1351 // Construct the context before querying for the existence of the DIE in case
1352 // such construction creates the DIE (as is the case for member function
1354 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1356 if (DIE *SPDie = getDIE(SP))
1359 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1360 // Add subprogram definitions to the CU die directly.
1361 ContextDIE = &getUnitDie();
1362 // Build the decl now to ensure it precedes the definition.
1363 getOrCreateSubprogramDIE(SPDecl);
1366 // DW_TAG_inlined_subroutine may refer to this DIE.
1367 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1369 // Stop here and fill this in later, depending on whether or not this
1370 // subprogram turns out to have inlined instances or not.
1371 if (SP.isDefinition())
1374 applySubprogramAttributes(SP, SPDie);
1378 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) {
1379 DISubprogram SPDecl = SP.getFunctionDeclaration();
1380 DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
1381 applySubprogramAttributes(SP, SPDie);
1382 addGlobalName(SP.getName(), SPDie, Context);
1385 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) {
1386 DIE *DeclDie = nullptr;
1387 StringRef DeclLinkageName;
1388 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1389 DeclDie = getDIE(SPDecl);
1390 assert(DeclDie && "This DIE should've already been constructed when the "
1391 "definition DIE was created in "
1392 "getOrCreateSubprogramDIE");
1393 DeclLinkageName = SPDecl.getLinkageName();
1396 // Add function template parameters.
1397 addTemplateParams(SPDie, SP.getTemplateParams());
1399 // Add the linkage name if we have one and it isn't in the Decl.
1400 StringRef LinkageName = SP.getLinkageName();
1401 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1402 LinkageName == DeclLinkageName) &&
1403 "decl has a linkage name and it is different");
1404 if (!LinkageName.empty() && DeclLinkageName.empty())
1405 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1406 GlobalValue::getRealLinkageName(LinkageName));
1409 // Refer to the function declaration where all the other attributes will be
1411 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1415 // Constructors and operators for anonymous aggregates do not have names.
1416 if (!SP.getName().empty())
1417 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1419 // Skip the rest of the attributes under -gmlt to save space.
1420 if(getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1423 addSourceLine(SPDie, SP);
1425 // Add the prototype if we have a prototype and we have a C like
1427 uint16_t Language = getLanguage();
1428 if (SP.isPrototyped() &&
1429 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1430 Language == dwarf::DW_LANG_ObjC))
1431 addFlag(SPDie, dwarf::DW_AT_prototyped);
1433 DISubroutineType SPTy = SP.getType();
1434 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1435 "the type of a subprogram should be a subroutine");
1437 DITypeArray Args = SPTy.getTypeArray();
1438 // Add a return type. If this is a type like a C/C++ void type we don't add a
1440 if (resolve(Args.getElement(0)))
1441 addType(SPDie, DIType(resolve(Args.getElement(0))));
1443 unsigned VK = SP.getVirtuality();
1445 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1446 DIELoc *Block = getDIELoc();
1447 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1448 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1449 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1450 ContainingTypeMap.insert(
1451 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1454 if (!SP.isDefinition()) {
1455 addFlag(SPDie, dwarf::DW_AT_declaration);
1457 // Add arguments. Do not add arguments for subprogram definition. They will
1458 // be handled while processing variables.
1459 constructSubprogramArguments(SPDie, Args);
1462 if (SP.isArtificial())
1463 addFlag(SPDie, dwarf::DW_AT_artificial);
1465 if (!SP.isLocalToUnit())
1466 addFlag(SPDie, dwarf::DW_AT_external);
1468 if (SP.isOptimized())
1469 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1471 if (unsigned isa = Asm->getISAEncoding()) {
1472 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1475 if (SP.isLValueReference())
1476 addFlag(SPDie, dwarf::DW_AT_reference);
1478 if (SP.isRValueReference())
1479 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1481 if (SP.isProtected())
1482 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1483 dwarf::DW_ACCESS_protected);
1484 else if (SP.isPrivate())
1485 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1486 dwarf::DW_ACCESS_private);
1487 else if (SP.isPublic())
1488 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1489 dwarf::DW_ACCESS_public);
1491 if (SP.isExplicit())
1492 addFlag(SPDie, dwarf::DW_AT_explicit);
1495 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var,
1497 StringRef Name = Var.getName();
1499 addString(VariableDie, dwarf::DW_AT_name, Name);
1500 addSourceLine(VariableDie, Var.getVariable());
1501 addType(VariableDie, Var.getType());
1502 if (Var.isArtificial())
1503 addFlag(VariableDie, dwarf::DW_AT_artificial);
1506 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1507 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1508 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1509 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1511 // The LowerBound value defines the lower bounds which is typically zero for
1512 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1513 // Count == -1 then the array is unbounded and we do not emit
1514 // DW_AT_lower_bound and DW_AT_count attributes.
1515 int64_t LowerBound = SR.getLo();
1516 int64_t DefaultLowerBound = getDefaultLowerBound();
1517 int64_t Count = SR.getCount();
1519 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1520 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1523 // FIXME: An unbounded array should reference the expression that defines
1525 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1528 DIE *DwarfUnit::getIndexTyDie() {
1531 // Construct an integer type to use for indexes.
1532 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1533 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1534 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1535 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1536 dwarf::DW_ATE_unsigned);
1540 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1541 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1543 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1545 // Emit the element type.
1546 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1548 // Get an anonymous type for index type.
1549 // FIXME: This type should be passed down from the front end
1550 // as different languages may have different sizes for indexes.
1551 DIE *IdxTy = getIndexTyDie();
1553 // Add subranges to array type.
1554 DIArray Elements = CTy.getElements();
1555 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1556 DIDescriptor Element = Elements.getElement(i);
1557 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1558 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1562 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1563 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1564 DIArray Elements = CTy.getElements();
1566 // Add enumerators to enumeration type.
1567 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1568 DIEnumerator Enum(Elements.getElement(i));
1569 if (Enum.isEnumerator()) {
1570 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1571 StringRef Name = Enum.getName();
1572 addString(Enumerator, dwarf::DW_AT_name, Name);
1573 int64_t Value = Enum.getEnumValue();
1574 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1578 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1580 addType(Buffer, DTy);
1581 addFlag(Buffer, dwarf::DW_AT_enum_class);
1585 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1587 void DwarfUnit::constructContainingTypeDIEs() {
1588 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1589 CE = ContainingTypeMap.end();
1591 DIE &SPDie = *CI->first;
1592 DIDescriptor D(CI->second);
1595 DIE *NDie = getDIE(D);
1598 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1602 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1603 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1604 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1605 StringRef Name = DT.getName();
1607 addString(MemberDie, dwarf::DW_AT_name, Name);
1609 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1611 addSourceLine(MemberDie, DT);
1613 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1615 // For C++, virtual base classes are not at fixed offset. Use following
1616 // expression to extract appropriate offset from vtable.
1617 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1619 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1620 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1621 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1622 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1623 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1624 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1625 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1626 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1628 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1630 uint64_t Size = DT.getSizeInBits();
1631 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1632 uint64_t OffsetInBytes;
1634 if (Size != FieldSize) {
1635 // Handle bitfield, assume bytes are 8 bits.
1636 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1637 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1639 uint64_t Offset = DT.getOffsetInBits();
1640 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1641 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1642 uint64_t FieldOffset = (HiMark - FieldSize);
1643 Offset -= FieldOffset;
1645 // Maybe we need to work from the other end.
1646 if (Asm->getDataLayout().isLittleEndian())
1647 Offset = FieldSize - (Offset + Size);
1648 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1650 // Here DW_AT_data_member_location points to the anonymous
1651 // field that includes this bit field.
1652 OffsetInBytes = FieldOffset >> 3;
1654 // This is not a bitfield.
1655 OffsetInBytes = DT.getOffsetInBits() >> 3;
1657 if (DD->getDwarfVersion() <= 2) {
1658 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1659 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1660 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1661 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1663 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1667 if (DT.isProtected())
1668 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1669 dwarf::DW_ACCESS_protected);
1670 else if (DT.isPrivate())
1671 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1672 dwarf::DW_ACCESS_private);
1673 // Otherwise C++ member and base classes are considered public.
1674 else if (DT.isPublic())
1675 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1676 dwarf::DW_ACCESS_public);
1678 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1679 dwarf::DW_VIRTUALITY_virtual);
1681 // Objective-C properties.
1682 if (MDNode *PNode = DT.getObjCProperty())
1683 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1684 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1687 if (DT.isArtificial())
1688 addFlag(MemberDie, dwarf::DW_AT_artificial);
1691 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1692 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1696 // Construct the context before querying for the existence of the DIE in case
1697 // such construction creates the DIE.
1698 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1699 assert(dwarf::isType(ContextDIE->getTag()) &&
1700 "Static member should belong to a type.");
1702 if (DIE *StaticMemberDIE = getDIE(DT))
1703 return StaticMemberDIE;
1705 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1707 DIType Ty = resolve(DT.getTypeDerivedFrom());
1709 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1710 addType(StaticMemberDIE, Ty);
1711 addSourceLine(StaticMemberDIE, DT);
1712 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1713 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1715 // FIXME: We could omit private if the parent is a class_type, and
1716 // public if the parent is something else.
1717 if (DT.isProtected())
1718 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1719 dwarf::DW_ACCESS_protected);
1720 else if (DT.isPrivate())
1721 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1722 dwarf::DW_ACCESS_private);
1723 else if (DT.isPublic())
1724 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1725 dwarf::DW_ACCESS_public);
1727 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1728 addConstantValue(StaticMemberDIE, CI, Ty);
1729 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1730 addConstantFPValue(StaticMemberDIE, CFP);
1732 return &StaticMemberDIE;
1735 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1736 // Emit size of content not including length itself
1737 Asm->OutStreamer.AddComment("Length of Unit");
1738 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1740 Asm->OutStreamer.AddComment("DWARF version number");
1741 Asm->EmitInt16(DD->getDwarfVersion());
1742 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1743 // We share one abbreviations table across all units so it's always at the
1744 // start of the section. Use a relocatable offset where needed to ensure
1745 // linking doesn't invalidate that offset.
1747 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1749 // Use a constant value when no symbol is provided.
1751 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1752 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1755 void DwarfUnit::initSection(const MCSection *Section) {
1756 assert(!this->Section);
1757 this->Section = Section;
1760 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1761 DwarfUnit::emitHeader(ASectionSym);
1762 Asm->OutStreamer.AddComment("Type Signature");
1763 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1764 Asm->OutStreamer.AddComment("Type DIE Offset");
1765 // In a skeleton type unit there is no type DIE so emit a zero offset.
1766 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1767 sizeof(Ty->getOffset()));