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 #define DEBUG_TYPE "dwarfdebug"
16 #include "DwarfUnit.h"
17 #include "DwarfAccelTable.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"
39 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
40 cl::desc("Generate DWARF4 type units."),
43 /// Unit - Unit constructor.
44 DwarfUnit::DwarfUnit(unsigned UID, DIE *D, DICompileUnit Node, AsmPrinter *A,
45 DwarfDebug *DW, DwarfFile *DWU)
46 : UniqueID(UID), CUNode(Node), UnitDie(D), DebugInfoOffset(0), Asm(A),
47 DD(DW), DU(DWU), IndexTyDie(0), Section(0), Skeleton(0) {
48 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
51 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
52 AsmPrinter *A, DwarfDebug *DW,
54 : DwarfUnit(UID, D, Node, A, DW, DWU) {
58 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DIE *D, DwarfCompileUnit &CU,
59 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU,
60 MCDwarfDwoLineTable *SplitLineTable)
61 : DwarfUnit(UID, D, CU.getCUNode(), A, DW, DWU), CU(CU),
62 SplitLineTable(SplitLineTable) {
64 addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
67 /// ~Unit - Destructor for compile unit.
68 DwarfUnit::~DwarfUnit() {
69 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
70 DIEBlocks[j]->~DIEBlock();
71 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
72 DIELocs[j]->~DIELoc();
75 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
76 /// information entry.
77 DIEEntry *DwarfUnit::createDIEEntry(DIE *Entry) {
78 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
82 /// getDefaultLowerBound - Return the default lower bound for an array. If the
83 /// DWARF version doesn't handle the language, return -1.
84 int64_t DwarfUnit::getDefaultLowerBound() const {
85 switch (getLanguage()) {
89 case dwarf::DW_LANG_C89:
90 case dwarf::DW_LANG_C99:
91 case dwarf::DW_LANG_C:
92 case dwarf::DW_LANG_C_plus_plus:
93 case dwarf::DW_LANG_ObjC:
94 case dwarf::DW_LANG_ObjC_plus_plus:
97 case dwarf::DW_LANG_Fortran77:
98 case dwarf::DW_LANG_Fortran90:
99 case dwarf::DW_LANG_Fortran95:
102 // The languages below have valid values only if the DWARF version >= 4.
103 case dwarf::DW_LANG_Java:
104 case dwarf::DW_LANG_Python:
105 case dwarf::DW_LANG_UPC:
106 case dwarf::DW_LANG_D:
107 if (dwarf::DWARF_VERSION >= 4)
111 case dwarf::DW_LANG_Ada83:
112 case dwarf::DW_LANG_Ada95:
113 case dwarf::DW_LANG_Cobol74:
114 case dwarf::DW_LANG_Cobol85:
115 case dwarf::DW_LANG_Modula2:
116 case dwarf::DW_LANG_Pascal83:
117 case dwarf::DW_LANG_PLI:
118 if (dwarf::DWARF_VERSION >= 4)
126 /// Check whether the DIE for this MDNode can be shared across CUs.
127 static bool isShareableAcrossCUs(DIDescriptor D) {
128 // When the MDNode can be part of the type system, the DIE can be shared
130 // Combining type units and cross-CU DIE sharing is lower value (since
131 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
132 // level already) but may be implementable for some value in projects
133 // building multiple independent libraries with LTO and then linking those
135 return (D.isType() ||
136 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
137 !GenerateDwarfTypeUnits;
140 /// getDIE - Returns the debug information entry map slot for the
141 /// specified debug variable. We delegate the request to DwarfDebug
142 /// when the DIE for this MDNode can be shared across CUs. The mappings
143 /// will be kept in DwarfDebug for shareable DIEs.
144 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
145 if (isShareableAcrossCUs(D))
146 return DD->getDIE(D);
147 return MDNodeToDieMap.lookup(D);
150 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
151 /// when the DIE for this MDNode can be shared across CUs. The mappings
152 /// will be kept in DwarfDebug for shareable DIEs.
153 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
154 if (isShareableAcrossCUs(Desc)) {
155 DD->insertDIE(Desc, D);
158 MDNodeToDieMap.insert(std::make_pair(Desc, D));
161 /// addFlag - Add a flag that is true.
162 void DwarfUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
163 if (DD->getDwarfVersion() >= 4)
164 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
166 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
169 /// addUInt - Add an unsigned integer attribute data and value.
171 void DwarfUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
172 Optional<dwarf::Form> Form, uint64_t Integer) {
174 Form = DIEInteger::BestForm(false, Integer);
175 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
177 Die->addValue(Attribute, *Form, Value);
180 void DwarfUnit::addUInt(DIE *Block, dwarf::Form Form, uint64_t Integer) {
181 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
184 /// addSInt - Add an signed integer attribute data and value.
186 void DwarfUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
187 Optional<dwarf::Form> Form, int64_t Integer) {
189 Form = DIEInteger::BestForm(true, Integer);
190 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
191 Die->addValue(Attribute, *Form, Value);
194 void DwarfUnit::addSInt(DIELoc *Die, Optional<dwarf::Form> Form,
196 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
199 /// addString - Add a string attribute data and value. We always emit a
200 /// reference to the string pool instead of immediate strings so that DIEs have
201 /// more predictable sizes. In the case of split dwarf we emit an index
202 /// into another table which gets us the static offset into the string
204 void DwarfUnit::addString(DIE *Die, dwarf::Attribute Attribute,
207 if (!DD->useSplitDwarf())
208 return addLocalString(Die, Attribute, String);
210 unsigned idx = DU->getStringPoolIndex(String);
211 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
212 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
213 Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
216 /// addLocalString - Add a string attribute data and value. This is guaranteed
217 /// to be in the local string pool instead of indirected.
218 void DwarfUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
220 MCSymbol *Symb = DU->getStringPoolEntry(String);
222 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
223 Value = new (DIEValueAllocator) DIELabel(Symb);
225 MCSymbol *StringPool = DU->getStringPoolSym();
226 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
228 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
229 Die->addValue(Attribute, dwarf::DW_FORM_strp, Str);
232 /// addExpr - Add a Dwarf expression attribute data and value.
234 void DwarfUnit::addExpr(DIELoc *Die, dwarf::Form Form, const MCExpr *Expr) {
235 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
236 Die->addValue((dwarf::Attribute)0, Form, Value);
239 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
241 void DwarfUnit::addLocationList(DIE *Die, dwarf::Attribute Attribute,
243 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
244 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
245 : dwarf::DW_FORM_data4;
246 Die->addValue(Attribute, Form, Value);
249 /// addLabel - Add a Dwarf label attribute data and value.
251 void DwarfUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
252 const MCSymbol *Label) {
253 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
254 Die->addValue(Attribute, Form, Value);
257 void DwarfUnit::addLabel(DIELoc *Die, dwarf::Form Form, const MCSymbol *Label) {
258 addLabel(Die, (dwarf::Attribute)0, Form, Label);
261 /// addSectionLabel - Add a Dwarf section label attribute data and value.
263 void DwarfUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
264 const MCSymbol *Label) {
265 if (DD->getDwarfVersion() >= 4)
266 addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
268 addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
271 /// addSectionOffset - Add an offset into a section attribute data and value.
273 void DwarfUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
275 if (DD->getDwarfVersion() >= 4)
276 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
278 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
281 /// addLabelAddress - Add a dwarf label attribute data and value using
282 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
284 void DwarfCompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
285 const MCSymbol *Label) {
287 if (!DD->useSplitDwarf())
288 return addLocalLabelAddress(Die, Attribute, Label);
291 DD->addArangeLabel(SymbolCU(this, Label));
293 unsigned idx = DU->getAddrPoolIndex(Label);
294 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
295 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
298 void DwarfCompileUnit::addLocalLabelAddress(DIE *Die,
299 dwarf::Attribute Attribute,
300 const MCSymbol *Label) {
302 DD->addArangeLabel(SymbolCU(this, Label));
305 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
306 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
308 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
309 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
313 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
314 // If we print assembly, we can't separate .file entries according to
315 // compile units. Thus all files will belong to the default compile unit.
317 // FIXME: add a better feature test than hasRawTextSupport. Even better,
318 // extend .file to support this.
319 return Asm->OutStreamer.EmitDwarfFileDirective(
320 0, DirName, FileName,
321 Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID());
324 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
325 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
326 : getCU().getOrCreateSourceID(FileName, DirName);
329 /// addOpAddress - Add a dwarf op address data and value using the
330 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
332 void DwarfUnit::addOpAddress(DIELoc *Die, const MCSymbol *Sym) {
333 if (!DD->useSplitDwarf()) {
334 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
335 addLabel(Die, dwarf::DW_FORM_udata, Sym);
337 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
338 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
342 /// addSectionDelta - Add a section label delta attribute data and value.
344 void DwarfUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
345 const MCSymbol *Hi, const MCSymbol *Lo) {
346 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
347 if (DD->getDwarfVersion() >= 4)
348 Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
350 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
353 void DwarfUnit::addLabelDelta(DIE *Die, dwarf::Attribute Attribute,
354 const MCSymbol *Hi, const MCSymbol *Lo) {
355 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
356 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
359 /// addDIEEntry - Add a DIE attribute data and value.
361 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
362 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
365 void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
366 Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
367 new (DIEValueAllocator) DIETypeSignature(Type));
370 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
372 const DIE *DieCU = Die->getUnitOrNull();
373 const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
375 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
376 DieCU = getUnitDie();
378 EntryCU = getUnitDie();
379 Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
380 : dwarf::DW_FORM_ref_addr,
384 /// Create a DIE with the given Tag, add the DIE to its parent, and
385 /// call insertDIE if MD is not null.
386 DIE *DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
387 DIE *Die = new DIE(Tag);
388 Parent.addChild(Die);
394 /// addBlock - Add block data.
396 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute, DIELoc *Loc) {
397 Loc->ComputeSize(Asm);
398 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
399 Die->addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
402 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
404 Block->ComputeSize(Asm);
405 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
406 Die->addValue(Attribute, Block->BestForm(), Block);
409 /// addSourceLine - Add location information to specified debug information
411 void DwarfUnit::addSourceLine(DIE *Die, unsigned Line, StringRef File,
412 StringRef Directory) {
416 unsigned FileID = getOrCreateSourceID(File, Directory);
417 assert(FileID && "Invalid file id");
418 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
419 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
422 /// addSourceLine - Add location information to specified debug information
424 void DwarfUnit::addSourceLine(DIE *Die, DIVariable V) {
425 assert(V.isVariable());
427 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
428 V.getContext().getDirectory());
431 /// addSourceLine - Add location information to specified debug information
433 void DwarfUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
434 assert(G.isGlobalVariable());
436 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
439 /// addSourceLine - Add location information to specified debug information
441 void DwarfUnit::addSourceLine(DIE *Die, DISubprogram SP) {
442 assert(SP.isSubprogram());
444 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
447 /// addSourceLine - Add location information to specified debug information
449 void DwarfUnit::addSourceLine(DIE *Die, DIType Ty) {
452 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
455 /// addSourceLine - Add location information to specified debug information
457 void DwarfUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
458 assert(Ty.isObjCProperty());
460 DIFile File = Ty.getFile();
461 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
462 File.getDirectory());
465 /// addSourceLine - Add location information to specified debug information
467 void DwarfUnit::addSourceLine(DIE *Die, DINameSpace NS) {
470 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
473 /// addVariableAddress - Add DW_AT_location attribute for a
474 /// DbgVariable based on provided MachineLocation.
475 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
476 MachineLocation Location) {
477 if (DV.variableHasComplexAddress())
478 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
479 else if (DV.isBlockByrefVariable())
480 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
482 addAddress(Die, dwarf::DW_AT_location, Location,
483 DV.getVariable().isIndirect());
486 /// addRegisterOp - Add register operand.
487 void DwarfUnit::addRegisterOp(DIELoc *TheDie, unsigned Reg) {
488 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
489 int DWReg = RI->getDwarfRegNum(Reg, false);
490 bool isSubRegister = DWReg < 0;
494 // Go up the super-register chain until we hit a valid dwarf register number.
495 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
496 DWReg = RI->getDwarfRegNum(*SR, false);
498 Idx = RI->getSubRegIndex(*SR, Reg);
502 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
503 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
509 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
511 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
512 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
517 unsigned Size = RI->getSubRegIdxSize(Idx);
518 unsigned Offset = RI->getSubRegIdxOffset(Idx);
520 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
521 addUInt(TheDie, dwarf::DW_FORM_data1, Size);
522 addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
524 unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
525 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
526 addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
531 /// addRegisterOffset - Add register offset.
532 void DwarfUnit::addRegisterOffset(DIELoc *TheDie, unsigned Reg,
534 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
535 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
536 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
537 if (Reg == TRI->getFrameRegister(*Asm->MF))
538 // If variable offset is based in frame register then use fbreg.
539 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
541 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
543 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
544 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
546 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
549 /// addAddress - Add an address attribute to a die based on the location
551 void DwarfUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
552 const MachineLocation &Location, bool Indirect) {
553 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
555 if (Location.isReg() && !Indirect)
556 addRegisterOp(Loc, Location.getReg());
558 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
559 if (Indirect && !Location.isReg()) {
560 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
564 // Now attach the location information to the DIE.
565 addBlock(Die, Attribute, Loc);
568 /// addComplexAddress - Start with the address based on the location provided,
569 /// and generate the DWARF information necessary to find the actual variable
570 /// given the extra address information encoded in the DbgVariable, starting
571 /// from the starting location. Add the DWARF information to the die.
573 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
574 dwarf::Attribute Attribute,
575 const MachineLocation &Location) {
576 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
577 unsigned N = DV.getNumAddrElements();
579 if (Location.isReg()) {
580 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
581 // If first address element is OpPlus then emit
582 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
583 addRegisterOffset(Loc, Location.getReg(), DV.getAddrElement(1));
586 addRegisterOp(Loc, Location.getReg());
588 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
591 uint64_t Element = DV.getAddrElement(i);
592 if (Element == DIBuilder::OpPlus) {
593 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
594 addUInt(Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
595 } else if (Element == DIBuilder::OpDeref) {
596 if (!Location.isReg())
597 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
599 llvm_unreachable("unknown DIBuilder Opcode");
602 // Now attach the location information to the DIE.
603 addBlock(Die, Attribute, Loc);
606 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
607 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
608 gives the variable VarName either the struct, or a pointer to the struct, as
609 its type. This is necessary for various behind-the-scenes things the
610 compiler needs to do with by-reference variables in Blocks.
612 However, as far as the original *programmer* is concerned, the variable
613 should still have type 'SomeType', as originally declared.
615 The function getBlockByrefType dives into the __Block_byref_x_VarName
616 struct to find the original type of the variable, which is then assigned to
617 the variable's Debug Information Entry as its real type. So far, so good.
618 However now the debugger will expect the variable VarName to have the type
619 SomeType. So we need the location attribute for the variable to be an
620 expression that explains to the debugger how to navigate through the
621 pointers and struct to find the actual variable of type SomeType.
623 The following function does just that. We start by getting
624 the "normal" location for the variable. This will be the location
625 of either the struct __Block_byref_x_VarName or the pointer to the
626 struct __Block_byref_x_VarName.
628 The struct will look something like:
630 struct __Block_byref_x_VarName {
632 struct __Block_byref_x_VarName *forwarding;
633 ... <various other fields>
635 ... <maybe more fields>
638 If we are given the struct directly (as our starting point) we
639 need to tell the debugger to:
641 1). Add the offset of the forwarding field.
643 2). Follow that pointer to get the real __Block_byref_x_VarName
644 struct to use (the real one may have been copied onto the heap).
646 3). Add the offset for the field VarName, to find the actual variable.
648 If we started with a pointer to the struct, then we need to
649 dereference that pointer first, before the other steps.
650 Translating this into DWARF ops, we will need to append the following
651 to the current location description for the variable:
653 DW_OP_deref -- optional, if we start with a pointer
654 DW_OP_plus_uconst <forward_fld_offset>
656 DW_OP_plus_uconst <varName_fld_offset>
658 That is what this function does. */
660 /// addBlockByrefAddress - Start with the address based on the location
661 /// provided, and generate the DWARF information necessary to find the
662 /// actual Block variable (navigating the Block struct) based on the
663 /// starting location. Add the DWARF information to the die. For
664 /// more information, read large comment just above here.
666 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
667 dwarf::Attribute Attribute,
668 const MachineLocation &Location) {
669 DIType Ty = DV.getType();
671 uint16_t Tag = Ty.getTag();
672 bool isPointer = false;
674 StringRef varName = DV.getName();
676 if (Tag == dwarf::DW_TAG_pointer_type) {
677 DIDerivedType DTy(Ty);
678 TmpTy = resolve(DTy.getTypeDerivedFrom());
682 DICompositeType blockStruct(TmpTy);
684 // Find the __forwarding field and the variable field in the __Block_byref
686 DIArray Fields = blockStruct.getTypeArray();
687 DIDerivedType varField;
688 DIDerivedType forwardingField;
690 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
691 DIDerivedType DT(Fields.getElement(i));
692 StringRef fieldName = DT.getName();
693 if (fieldName == "__forwarding")
694 forwardingField = DT;
695 else if (fieldName == varName)
699 // Get the offsets for the forwarding field and the variable field.
700 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
701 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
703 // Decode the original location, and use that as the start of the byref
704 // variable's location.
705 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
707 if (Location.isReg())
708 addRegisterOp(Loc, Location.getReg());
710 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
712 // If we started with a pointer to the __Block_byref... struct, then
713 // the first thing we need to do is dereference the pointer (DW_OP_deref).
715 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
717 // Next add the offset for the '__forwarding' field:
718 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
719 // adding the offset if it's 0.
720 if (forwardingFieldOffset > 0) {
721 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
722 addUInt(Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
725 // Now dereference the __forwarding field to get to the real __Block_byref
726 // struct: DW_OP_deref.
727 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
729 // Now that we've got the real __Block_byref... struct, add the offset
730 // for the variable's field to get to the location of the actual variable:
731 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
732 if (varFieldOffset > 0) {
733 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
734 addUInt(Loc, dwarf::DW_FORM_udata, varFieldOffset);
737 // Now attach the location information to the DIE.
738 addBlock(Die, Attribute, Loc);
741 /// isTypeSigned - Return true if the type is signed.
742 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
743 if (Ty.isDerivedType())
744 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
746 if (Ty.isBasicType())
747 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
748 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
749 *SizeInBits = Ty.getSizeInBits();
755 /// Return true if type encoding is unsigned.
756 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
757 DIDerivedType DTy(Ty);
758 if (DTy.isDerivedType())
759 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
762 if (BTy.isBasicType()) {
763 unsigned Encoding = BTy.getEncoding();
764 if (Encoding == dwarf::DW_ATE_unsigned ||
765 Encoding == dwarf::DW_ATE_unsigned_char ||
766 Encoding == dwarf::DW_ATE_boolean)
772 /// If this type is derived from a base type then return base type size.
773 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
774 unsigned Tag = Ty.getTag();
776 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
777 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
778 Tag != dwarf::DW_TAG_restrict_type)
779 return Ty.getSizeInBits();
781 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
783 // If this type is not derived from any type or the type is a declaration then
784 // take conservative approach.
785 if (!BaseType.isValid() || BaseType.isForwardDecl())
786 return Ty.getSizeInBits();
788 // If this is a derived type, go ahead and get the base type, unless it's a
789 // reference then it's just the size of the field. Pointer types have no need
790 // of this since they're a different type of qualification on the type.
791 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
792 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
793 return Ty.getSizeInBits();
795 if (BaseType.isDerivedType())
796 return getBaseTypeSize(DD, DIDerivedType(BaseType));
798 return BaseType.getSizeInBits();
801 /// addConstantValue - Add constant value entry in variable DIE.
802 void DwarfUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
804 // FIXME: This is a bit conservative/simple - it emits negative values at
805 // their maximum bit width which is a bit unfortunate (& doesn't prefer
806 // udata/sdata over dataN as suggested by the DWARF spec)
807 assert(MO.isImm() && "Invalid machine operand!");
809 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
812 // If we're a signed constant definitely use sdata.
813 if (SignedConstant) {
814 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
818 // Else use data for now unless it's larger than we can deal with.
819 switch (SizeInBits) {
821 Form = dwarf::DW_FORM_data1;
824 Form = dwarf::DW_FORM_data2;
827 Form = dwarf::DW_FORM_data4;
830 Form = dwarf::DW_FORM_data8;
833 Form = dwarf::DW_FORM_udata;
834 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
837 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
840 /// addConstantFPValue - Add constant value entry in variable DIE.
841 void DwarfUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
842 assert(MO.isFPImm() && "Invalid machine operand!");
843 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
844 APFloat FPImm = MO.getFPImm()->getValueAPF();
846 // Get the raw data form of the floating point.
847 const APInt FltVal = FPImm.bitcastToAPInt();
848 const char *FltPtr = (const char *)FltVal.getRawData();
850 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
851 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
852 int Incr = (LittleEndian ? 1 : -1);
853 int Start = (LittleEndian ? 0 : NumBytes - 1);
854 int Stop = (LittleEndian ? NumBytes : -1);
856 // Output the constant to DWARF one byte at a time.
857 for (; Start != Stop; Start += Incr)
858 addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
860 addBlock(Die, dwarf::DW_AT_const_value, Block);
863 /// addConstantFPValue - Add constant value entry in variable DIE.
864 void DwarfUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
865 // Pass this down to addConstantValue as an unsigned bag of bits.
866 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
869 /// addConstantValue - Add constant value entry in variable DIE.
870 void DwarfUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
872 addConstantValue(Die, CI->getValue(), Unsigned);
875 // addConstantValue - Add constant value entry in variable DIE.
876 void DwarfUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
877 unsigned CIBitWidth = Val.getBitWidth();
878 if (CIBitWidth <= 64) {
879 // If we're a signed constant definitely use sdata.
881 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
886 // Else use data for now unless it's larger than we can deal with.
888 switch (CIBitWidth) {
890 Form = dwarf::DW_FORM_data1;
893 Form = dwarf::DW_FORM_data2;
896 Form = dwarf::DW_FORM_data4;
899 Form = dwarf::DW_FORM_data8;
902 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
906 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
910 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
912 // Get the raw data form of the large APInt.
913 const uint64_t *Ptr64 = Val.getRawData();
915 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
916 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
918 // Output the constant to DWARF one byte at a time.
919 for (int i = 0; i < NumBytes; i++) {
922 c = Ptr64[i / 8] >> (8 * (i & 7));
924 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
925 addUInt(Block, dwarf::DW_FORM_data1, c);
928 addBlock(Die, dwarf::DW_AT_const_value, Block);
931 /// addTemplateParams - Add template parameters into buffer.
932 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
933 // Add template parameters.
934 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
935 DIDescriptor Element = TParams.getElement(i);
936 if (Element.isTemplateTypeParameter())
937 constructTemplateTypeParameterDIE(Buffer,
938 DITemplateTypeParameter(Element));
939 else if (Element.isTemplateValueParameter())
940 constructTemplateValueParameterDIE(Buffer,
941 DITemplateValueParameter(Element));
945 /// getOrCreateContextDIE - Get context owner's DIE.
946 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
947 if (!Context || Context.isFile())
949 if (Context.isType())
950 return getOrCreateTypeDIE(DIType(Context));
951 if (Context.isNameSpace())
952 return getOrCreateNameSpace(DINameSpace(Context));
953 if (Context.isSubprogram())
954 return getOrCreateSubprogramDIE(DISubprogram(Context));
955 return getDIE(Context);
958 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
959 DIScope Context = resolve(Ty.getContext());
960 DIE *ContextDIE = getOrCreateContextDIE(Context);
962 DIE *TyDIE = getDIE(Ty);
967 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
969 constructTypeDIE(*TyDIE, Ty);
971 updateAcceleratorTables(Context, Ty, TyDIE);
975 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
977 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
983 assert(*&Ty == resolve(Ty.getRef()) &&
984 "type was not uniqued, possible ODR violation.");
986 // Construct the context before querying for the existence of the DIE in case
987 // such construction creates the DIE.
988 DIScope Context = resolve(Ty.getContext());
989 DIE *ContextDIE = getOrCreateContextDIE(Context);
992 DIE *TyDIE = getDIE(Ty);
997 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
999 updateAcceleratorTables(Context, Ty, TyDIE);
1001 if (Ty.isBasicType())
1002 constructTypeDIE(*TyDIE, DIBasicType(Ty));
1003 else if (Ty.isCompositeType()) {
1004 DICompositeType CTy(Ty);
1005 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
1006 if (MDString *TypeId = CTy.getIdentifier()) {
1007 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
1008 // Skip updating the accelerator tables since this is not the full type.
1011 constructTypeDIE(*TyDIE, CTy);
1013 assert(Ty.isDerivedType() && "Unknown kind of DIType");
1014 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
1020 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
1022 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
1023 bool IsImplementation = 0;
1024 if (Ty.isCompositeType()) {
1025 DICompositeType CT(Ty);
1026 // A runtime language of 0 actually means C/C++ and that any
1027 // non-negative value is some version of Objective-C/C++.
1028 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1030 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1031 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
1033 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1034 Context.isNameSpace()) &&
1035 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1036 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
1040 /// addType - Add a new type attribute to the specified entity.
1041 void DwarfUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
1042 assert(Ty && "Trying to add a type that doesn't exist?");
1044 // Check for pre-existence.
1045 DIEEntry *Entry = getDIEEntry(Ty);
1046 // If it exists then use the existing value.
1048 addDIEEntry(Entity, Attribute, Entry);
1053 DIE *Buffer = getOrCreateTypeDIE(Ty);
1056 Entry = createDIEEntry(Buffer);
1057 insertDIEEntry(Ty, Entry);
1058 addDIEEntry(Entity, Attribute, Entry);
1061 // Accelerator table mutators - add each name along with its companion
1062 // DIE to the proper table while ensuring that the name that we're going
1063 // to reference is in the string table. We do this since the names we
1064 // add may not only be identical to the names in the DIE.
1065 void DwarfUnit::addAccelName(StringRef Name, const DIE *Die) {
1066 if (!DD->useDwarfAccelTables())
1068 DU->getStringPoolEntry(Name);
1069 std::vector<const DIE *> &DIEs = AccelNames[Name];
1070 DIEs.push_back(Die);
1073 void DwarfUnit::addAccelObjC(StringRef Name, const DIE *Die) {
1074 if (!DD->useDwarfAccelTables())
1076 DU->getStringPoolEntry(Name);
1077 std::vector<const DIE *> &DIEs = AccelObjC[Name];
1078 DIEs.push_back(Die);
1081 void DwarfUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
1082 if (!DD->useDwarfAccelTables())
1084 DU->getStringPoolEntry(Name);
1085 std::vector<const DIE *> &DIEs = AccelNamespace[Name];
1086 DIEs.push_back(Die);
1089 void DwarfUnit::addAccelType(StringRef Name,
1090 std::pair<const DIE *, unsigned> Die) {
1091 if (!DD->useDwarfAccelTables())
1093 DU->getStringPoolEntry(Name);
1094 std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
1095 DIEs.push_back(Die);
1098 /// addGlobalName - Add a new global name to the compile unit.
1099 void DwarfUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
1100 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1102 std::string FullName = getParentContextString(Context) + Name.str();
1103 GlobalNames[FullName] = Die;
1106 /// getParentContextString - Walks the metadata parent chain in a language
1107 /// specific manner (using the compile unit language) and returns
1108 /// it as a string. This is done at the metadata level because DIEs may
1109 /// not currently have been added to the parent context and walking the
1110 /// DIEs looking for names is more expensive than walking the metadata.
1111 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1115 // FIXME: Decide whether to implement this for non-C++ languages.
1116 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1120 SmallVector<DIScope, 1> Parents;
1121 while (!Context.isCompileUnit()) {
1122 Parents.push_back(Context);
1123 if (Context.getContext())
1124 Context = resolve(Context.getContext());
1126 // Structure, etc types will have a NULL context if they're at the top
1131 // Reverse iterate over our list to go from the outermost construct to the
1133 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1137 StringRef Name = Ctx.getName();
1138 if (!Name.empty()) {
1146 /// constructTypeDIE - Construct basic type die from DIBasicType.
1147 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1148 // Get core information.
1149 StringRef Name = BTy.getName();
1150 // Add name if not anonymous or intermediate type.
1152 addString(&Buffer, dwarf::DW_AT_name, Name);
1154 // An unspecified type only has a name attribute.
1155 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1158 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1161 uint64_t Size = BTy.getSizeInBits() >> 3;
1162 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1165 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1166 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1167 // Get core information.
1168 StringRef Name = DTy.getName();
1169 uint64_t Size = DTy.getSizeInBits() >> 3;
1170 uint16_t Tag = Buffer.getTag();
1172 // Map to main type, void will not have a type.
1173 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1175 addType(&Buffer, FromTy);
1177 // Add name if not anonymous or intermediate type.
1179 addString(&Buffer, dwarf::DW_AT_name, Name);
1181 // Add size if non-zero (derived types might be zero-sized.)
1182 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1183 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1185 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1186 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1187 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1188 // Add source line info if available and TyDesc is not a forward declaration.
1189 if (!DTy.isForwardDecl())
1190 addSourceLine(&Buffer, DTy);
1193 /// constructSubprogramArguments - Construct function argument DIEs.
1194 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1195 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1196 DIDescriptor Ty = Args.getElement(i);
1197 if (Ty.isUnspecifiedParameter()) {
1198 assert(i == N-1 && "Unspecified parameter must be the last argument");
1199 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1201 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1202 addType(Arg, DIType(Ty));
1203 if (DIType(Ty).isArtificial())
1204 addFlag(Arg, dwarf::DW_AT_artificial);
1209 /// constructTypeDIE - Construct type DIE from DICompositeType.
1210 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1211 // Add name if not anonymous or intermediate type.
1212 StringRef Name = CTy.getName();
1214 uint64_t Size = CTy.getSizeInBits() >> 3;
1215 uint16_t Tag = Buffer.getTag();
1218 case dwarf::DW_TAG_array_type:
1219 constructArrayTypeDIE(Buffer, CTy);
1221 case dwarf::DW_TAG_enumeration_type:
1222 constructEnumTypeDIE(Buffer, CTy);
1224 case dwarf::DW_TAG_subroutine_type: {
1225 // Add return type. A void return won't have a type.
1226 DIArray Elements = CTy.getTypeArray();
1227 DIType RTy(Elements.getElement(0));
1229 addType(&Buffer, RTy);
1231 bool isPrototyped = true;
1232 if (Elements.getNumElements() == 2 &&
1233 Elements.getElement(1).isUnspecifiedParameter())
1234 isPrototyped = false;
1236 constructSubprogramArguments(Buffer, Elements);
1238 // Add prototype flag if we're dealing with a C language and the
1239 // function has been prototyped.
1240 uint16_t Language = getLanguage();
1242 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1243 Language == dwarf::DW_LANG_ObjC))
1244 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1246 if (CTy.isLValueReference())
1247 addFlag(&Buffer, dwarf::DW_AT_reference);
1249 if (CTy.isRValueReference())
1250 addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
1252 case dwarf::DW_TAG_structure_type:
1253 case dwarf::DW_TAG_union_type:
1254 case dwarf::DW_TAG_class_type: {
1255 // Add elements to structure type.
1256 DIArray Elements = CTy.getTypeArray();
1257 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1258 DIDescriptor Element = Elements.getElement(i);
1259 DIE *ElemDie = NULL;
1260 if (Element.isSubprogram())
1261 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1262 else if (Element.isDerivedType()) {
1263 DIDerivedType DDTy(Element);
1264 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1265 ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1266 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1267 dwarf::DW_AT_friend);
1268 } else if (DDTy.isStaticMember()) {
1269 getOrCreateStaticMemberDIE(DDTy);
1271 constructMemberDIE(Buffer, DDTy);
1273 } else if (Element.isObjCProperty()) {
1274 DIObjCProperty Property(Element);
1275 ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1276 StringRef PropertyName = Property.getObjCPropertyName();
1277 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1278 if (Property.getType())
1279 addType(ElemDie, Property.getType());
1280 addSourceLine(ElemDie, Property);
1281 StringRef GetterName = Property.getObjCPropertyGetterName();
1282 if (!GetterName.empty())
1283 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1284 StringRef SetterName = Property.getObjCPropertySetterName();
1285 if (!SetterName.empty())
1286 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1287 unsigned PropertyAttributes = 0;
1288 if (Property.isReadOnlyObjCProperty())
1289 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1290 if (Property.isReadWriteObjCProperty())
1291 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1292 if (Property.isAssignObjCProperty())
1293 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1294 if (Property.isRetainObjCProperty())
1295 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1296 if (Property.isCopyObjCProperty())
1297 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1298 if (Property.isNonAtomicObjCProperty())
1299 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1300 if (PropertyAttributes)
1301 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1302 PropertyAttributes);
1304 DIEEntry *Entry = getDIEEntry(Element);
1306 Entry = createDIEEntry(ElemDie);
1307 insertDIEEntry(Element, Entry);
1313 if (CTy.isAppleBlockExtension())
1314 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1316 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1318 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1319 getOrCreateTypeDIE(ContainingType));
1321 if (CTy.isObjcClassComplete())
1322 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1324 // Add template parameters to a class, structure or union types.
1325 // FIXME: The support isn't in the metadata for this yet.
1326 if (Tag == dwarf::DW_TAG_class_type ||
1327 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1328 addTemplateParams(Buffer, CTy.getTemplateParams());
1336 // Add name if not anonymous or intermediate type.
1338 addString(&Buffer, dwarf::DW_AT_name, Name);
1340 if (Tag == dwarf::DW_TAG_enumeration_type ||
1341 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1342 Tag == dwarf::DW_TAG_union_type) {
1343 // Add size if non-zero (derived types might be zero-sized.)
1344 // TODO: Do we care about size for enum forward declarations?
1346 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1347 else if (!CTy.isForwardDecl())
1348 // Add zero size if it is not a forward declaration.
1349 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1351 // If we're a forward decl, say so.
1352 if (CTy.isForwardDecl())
1353 addFlag(&Buffer, dwarf::DW_AT_declaration);
1355 // Add source line info if available.
1356 if (!CTy.isForwardDecl())
1357 addSourceLine(&Buffer, CTy);
1359 // No harm in adding the runtime language to the declaration.
1360 unsigned RLang = CTy.getRunTimeLang();
1362 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1367 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1368 /// DITemplateTypeParameter.
1369 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1370 DITemplateTypeParameter TP) {
1372 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1373 // Add the type if it exists, it could be void and therefore no type.
1375 addType(ParamDIE, resolve(TP.getType()));
1376 if (!TP.getName().empty())
1377 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1380 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1381 /// DITemplateValueParameter.
1383 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1384 DITemplateValueParameter VP) {
1385 DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1387 // Add the type if there is one, template template and template parameter
1388 // packs will not have a type.
1389 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1390 addType(ParamDIE, resolve(VP.getType()));
1391 if (!VP.getName().empty())
1392 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1393 if (Value *Val = VP.getValue()) {
1394 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1395 addConstantValue(ParamDIE, CI,
1396 isUnsignedDIType(DD, resolve(VP.getType())));
1397 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1398 // For declaration non-type template parameters (such as global values and
1400 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1401 addOpAddress(Loc, Asm->getSymbol(GV));
1402 // Emit DW_OP_stack_value to use the address as the immediate value of the
1403 // parameter, rather than a pointer to it.
1404 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1405 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1406 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1407 assert(isa<MDString>(Val));
1408 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1409 cast<MDString>(Val)->getString());
1410 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1411 assert(isa<MDNode>(Val));
1412 DIArray A(cast<MDNode>(Val));
1413 addTemplateParams(*ParamDIE, A);
1418 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1419 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1420 // Construct the context before querying for the existence of the DIE in case
1421 // such construction creates the DIE.
1422 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1424 DIE *NDie = getDIE(NS);
1427 NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1429 if (!NS.getName().empty()) {
1430 addString(NDie, dwarf::DW_AT_name, NS.getName());
1431 addAccelNamespace(NS.getName(), NDie);
1432 addGlobalName(NS.getName(), NDie, NS.getContext());
1434 addAccelNamespace("(anonymous namespace)", NDie);
1435 addSourceLine(NDie, NS);
1439 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1440 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1441 // Construct the context before querying for the existence of the DIE in case
1442 // such construction creates the DIE (as is the case for member function
1444 DIScope Context = resolve(SP.getContext());
1445 DIE *ContextDIE = getOrCreateContextDIE(Context);
1447 // Unique declarations based on the ODR, where applicable.
1448 SP = DISubprogram(DD->resolve(SP.getRef()));
1449 assert(SP.Verify());
1451 DIE *SPDie = getDIE(SP);
1455 DISubprogram SPDecl = SP.getFunctionDeclaration();
1456 if (SPDecl.isSubprogram())
1457 // Add subprogram definitions to the CU die directly.
1458 ContextDIE = UnitDie.get();
1460 // DW_TAG_inlined_subroutine may refer to this DIE.
1461 SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1463 DIE *DeclDie = NULL;
1464 if (SPDecl.isSubprogram())
1465 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1467 // Add function template parameters.
1468 addTemplateParams(*SPDie, SP.getTemplateParams());
1470 // If this DIE is going to refer declaration info using AT_specification
1471 // then there is no need to add other attributes.
1473 // Refer function declaration directly.
1474 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1479 // Add the linkage name if we have one.
1480 StringRef LinkageName = SP.getLinkageName();
1481 if (!LinkageName.empty())
1482 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1483 GlobalValue::getRealLinkageName(LinkageName));
1485 // Constructors and operators for anonymous aggregates do not have names.
1486 if (!SP.getName().empty())
1487 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1489 addSourceLine(SPDie, SP);
1491 // Add the prototype if we have a prototype and we have a C like
1493 uint16_t Language = getLanguage();
1494 if (SP.isPrototyped() &&
1495 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1496 Language == dwarf::DW_LANG_ObjC))
1497 addFlag(SPDie, dwarf::DW_AT_prototyped);
1499 DICompositeType SPTy = SP.getType();
1500 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1501 "the type of a subprogram should be a subroutine");
1503 DIArray Args = SPTy.getTypeArray();
1504 // Add a return type. If this is a type like a C/C++ void type we don't add a
1506 if (Args.getElement(0))
1507 addType(SPDie, DIType(Args.getElement(0)));
1509 unsigned VK = SP.getVirtuality();
1511 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1512 DIELoc *Block = getDIELoc();
1513 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1514 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1515 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1516 ContainingTypeMap.insert(
1517 std::make_pair(SPDie, resolve(SP.getContainingType())));
1520 if (!SP.isDefinition()) {
1521 addFlag(SPDie, dwarf::DW_AT_declaration);
1523 // Add arguments. Do not add arguments for subprogram definition. They will
1524 // be handled while processing variables.
1525 constructSubprogramArguments(*SPDie, Args);
1528 if (SP.isArtificial())
1529 addFlag(SPDie, dwarf::DW_AT_artificial);
1531 if (!SP.isLocalToUnit())
1532 addFlag(SPDie, dwarf::DW_AT_external);
1534 if (SP.isOptimized())
1535 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1537 if (unsigned isa = Asm->getISAEncoding()) {
1538 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1541 if (SP.isLValueReference())
1542 addFlag(SPDie, dwarf::DW_AT_reference);
1544 if (SP.isRValueReference())
1545 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1547 if (SP.isProtected())
1548 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1549 dwarf::DW_ACCESS_protected);
1550 else if (SP.isPrivate())
1551 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1552 dwarf::DW_ACCESS_private);
1554 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1555 dwarf::DW_ACCESS_public);
1557 if (SP.isExplicit())
1558 addFlag(SPDie, dwarf::DW_AT_explicit);
1563 // Return const expression if value is a GEP to access merged global
1565 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1566 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1567 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1568 if (!CE || CE->getNumOperands() != 3 ||
1569 CE->getOpcode() != Instruction::GetElementPtr)
1572 // First operand points to a global struct.
1573 Value *Ptr = CE->getOperand(0);
1574 if (!isa<GlobalValue>(Ptr) ||
1575 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1578 // Second operand is zero.
1579 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1580 if (!CI || !CI->isZero())
1583 // Third operand is offset.
1584 if (!isa<ConstantInt>(CE->getOperand(2)))
1590 /// createGlobalVariableDIE - create global variable DIE.
1591 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1592 // Check for pre-existence.
1596 assert(GV.isGlobalVariable());
1598 DIScope GVContext = GV.getContext();
1599 DIType GTy = DD->resolve(GV.getType());
1601 // If this is a static data member definition, some attributes belong
1602 // to the declaration DIE.
1603 DIE *VariableDIE = NULL;
1604 bool IsStaticMember = false;
1605 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1606 if (SDMDecl.Verify()) {
1607 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1608 // We need the declaration DIE that is in the static member's class.
1609 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1610 IsStaticMember = true;
1613 // If this is not a static data member definition, create the variable
1614 // DIE and add the initial set of attributes to it.
1616 // Construct the context before querying for the existence of the DIE in
1617 // case such construction creates the DIE.
1618 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1621 VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1623 // Add name and type.
1624 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1625 addType(VariableDIE, GTy);
1627 // Add scoping info.
1628 if (!GV.isLocalToUnit())
1629 addFlag(VariableDIE, dwarf::DW_AT_external);
1631 // Add line number info.
1632 addSourceLine(VariableDIE, GV);
1636 bool addToAccelTable = false;
1637 DIE *VariableSpecDIE = NULL;
1638 bool isGlobalVariable = GV.getGlobal() != NULL;
1639 if (isGlobalVariable) {
1640 addToAccelTable = true;
1641 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1642 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1643 if (GV.getGlobal()->isThreadLocal()) {
1644 // FIXME: Make this work with -gsplit-dwarf.
1645 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1646 assert((PointerSize == 4 || PointerSize == 8) &&
1647 "Add support for other sizes if necessary");
1648 // Based on GCC's support for TLS:
1649 if (!DD->useSplitDwarf()) {
1650 // 1) Start with a constNu of the appropriate pointer size
1651 addUInt(Loc, dwarf::DW_FORM_data1,
1652 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1653 // 2) containing the (relocated) offset of the TLS variable
1654 // within the module's TLS block.
1655 addExpr(Loc, dwarf::DW_FORM_udata,
1656 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1658 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1659 addUInt(Loc, dwarf::DW_FORM_udata,
1660 DU->getAddrPoolIndex(Sym, /* TLS */ true));
1662 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1663 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1665 DD->addArangeLabel(SymbolCU(this, Sym));
1666 addOpAddress(Loc, Sym);
1668 // Do not create specification DIE if context is either compile unit
1670 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1671 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1672 // Create specification DIE.
1673 VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1674 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1675 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Loc);
1676 // A static member's declaration is already flagged as such.
1677 if (!SDMDecl.Verify())
1678 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1680 addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1682 // Add the linkage name.
1683 StringRef LinkageName = GV.getLinkageName();
1684 if (!LinkageName.empty())
1685 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1686 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1688 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1690 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
1691 : dwarf::DW_AT_MIPS_linkage_name,
1692 GlobalValue::getRealLinkageName(LinkageName));
1693 } else if (const ConstantInt *CI =
1694 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1695 // AT_const_value was added when the static member was created. To avoid
1696 // emitting AT_const_value multiple times, we only add AT_const_value when
1697 // it is not a static member.
1698 if (!IsStaticMember)
1699 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1700 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1701 addToAccelTable = true;
1702 // GV is a merged global.
1703 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1704 Value *Ptr = CE->getOperand(0);
1705 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1706 DD->addArangeLabel(SymbolCU(this, Sym));
1707 addOpAddress(Loc, Sym);
1708 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1709 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1710 addUInt(Loc, dwarf::DW_FORM_udata,
1711 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1712 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1713 addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1716 if (addToAccelTable) {
1717 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1718 addAccelName(GV.getName(), AddrDIE);
1720 // If the linkage name is different than the name, go ahead and output
1721 // that as well into the name table.
1722 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1723 addAccelName(GV.getLinkageName(), AddrDIE);
1726 if (!GV.isLocalToUnit())
1727 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1731 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1732 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1733 DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1734 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1736 // The LowerBound value defines the lower bounds which is typically zero for
1737 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1738 // Count == -1 then the array is unbounded and we do not emit
1739 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1740 // Count == 0, then the array has zero elements in which case we do not emit
1742 int64_t LowerBound = SR.getLo();
1743 int64_t DefaultLowerBound = getDefaultLowerBound();
1744 int64_t Count = SR.getCount();
1746 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1747 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1749 if (Count != -1 && Count != 0)
1750 // FIXME: An unbounded array should reference the expression that defines
1752 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1753 LowerBound + Count - 1);
1756 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1757 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1759 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1761 // Emit the element type.
1762 addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1764 // Get an anonymous type for index type.
1765 // FIXME: This type should be passed down from the front end
1766 // as different languages may have different sizes for indexes.
1767 DIE *IdxTy = getIndexTyDie();
1769 // Construct an anonymous type for index type.
1770 IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1771 addString(IdxTy, dwarf::DW_AT_name, "int");
1772 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1773 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1774 dwarf::DW_ATE_signed);
1775 setIndexTyDie(IdxTy);
1778 // Add subranges to array type.
1779 DIArray Elements = CTy.getTypeArray();
1780 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1781 DIDescriptor Element = Elements.getElement(i);
1782 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1783 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1787 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1788 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1789 DIArray Elements = CTy.getTypeArray();
1791 // Add enumerators to enumeration type.
1792 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1793 DIEnumerator Enum(Elements.getElement(i));
1794 if (Enum.isEnumerator()) {
1795 DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1796 StringRef Name = Enum.getName();
1797 addString(Enumerator, dwarf::DW_AT_name, Name);
1798 int64_t Value = Enum.getEnumValue();
1799 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1803 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1805 addType(&Buffer, DTy);
1806 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1810 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1812 void DwarfUnit::constructContainingTypeDIEs() {
1813 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1814 CE = ContainingTypeMap.end();
1816 DIE *SPDie = CI->first;
1817 DIDescriptor D(CI->second);
1820 DIE *NDie = getDIE(D);
1823 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1827 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1828 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1829 StringRef Name = DV.getName();
1831 // Define variable debug information entry.
1832 DIE *VariableDie = new DIE(DV.getTag());
1833 DbgVariable *AbsVar = DV.getAbstractVariable();
1834 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1836 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1839 addString(VariableDie, dwarf::DW_AT_name, Name);
1840 addSourceLine(VariableDie, DV.getVariable());
1841 addType(VariableDie, DV.getType());
1844 if (DV.isArtificial())
1845 addFlag(VariableDie, dwarf::DW_AT_artificial);
1847 if (isScopeAbstract) {
1848 DV.setDIE(VariableDie);
1852 // Add variable address.
1854 unsigned Offset = DV.getDotDebugLocOffset();
1855 if (Offset != ~0U) {
1856 addLocationList(VariableDie, dwarf::DW_AT_location, Offset);
1857 DV.setDIE(VariableDie);
1861 // Check if variable is described by a DBG_VALUE instruction.
1862 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1863 assert(DVInsn->getNumOperands() == 3);
1864 if (DVInsn->getOperand(0).isReg()) {
1865 const MachineOperand RegOp = DVInsn->getOperand(0);
1866 // If the second operand is an immediate, this is an indirect value.
1867 if (DVInsn->getOperand(1).isImm()) {
1868 MachineLocation Location(RegOp.getReg(),
1869 DVInsn->getOperand(1).getImm());
1870 addVariableAddress(DV, VariableDie, Location);
1871 } else if (RegOp.getReg())
1872 addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1873 } else if (DVInsn->getOperand(0).isImm())
1874 addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1875 else if (DVInsn->getOperand(0).isFPImm())
1876 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1877 else if (DVInsn->getOperand(0).isCImm())
1878 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1879 isUnsignedDIType(DD, DV.getType()));
1881 DV.setDIE(VariableDie);
1884 // .. else use frame index.
1885 int FI = DV.getFrameIndex();
1887 unsigned FrameReg = 0;
1888 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1889 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1890 MachineLocation Location(FrameReg, Offset);
1891 addVariableAddress(DV, VariableDie, Location);
1895 DV.setDIE(VariableDie);
1899 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1900 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1901 DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1902 StringRef Name = DT.getName();
1904 addString(MemberDie, dwarf::DW_AT_name, Name);
1906 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1908 addSourceLine(MemberDie, DT);
1910 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1912 // For C++, virtual base classes are not at fixed offset. Use following
1913 // expression to extract appropriate offset from vtable.
1914 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1916 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1917 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1918 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1919 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1920 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1921 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1922 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1923 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1925 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1927 uint64_t Size = DT.getSizeInBits();
1928 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1929 uint64_t OffsetInBytes;
1931 if (Size != FieldSize) {
1932 // Handle bitfield, assume bytes are 8 bits.
1933 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1934 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1936 uint64_t Offset = DT.getOffsetInBits();
1937 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1938 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1939 uint64_t FieldOffset = (HiMark - FieldSize);
1940 Offset -= FieldOffset;
1942 // Maybe we need to work from the other end.
1943 if (Asm->getDataLayout().isLittleEndian())
1944 Offset = FieldSize - (Offset + Size);
1945 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1947 // Here DW_AT_data_member_location points to the anonymous
1948 // field that includes this bit field.
1949 OffsetInBytes = FieldOffset >> 3;
1951 // This is not a bitfield.
1952 OffsetInBytes = DT.getOffsetInBits() >> 3;
1954 if (DD->getDwarfVersion() <= 2) {
1955 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1956 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1957 addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1958 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1960 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1964 if (DT.isProtected())
1965 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1966 dwarf::DW_ACCESS_protected);
1967 else if (DT.isPrivate())
1968 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1969 dwarf::DW_ACCESS_private);
1970 // Otherwise C++ member and base classes are considered public.
1972 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1973 dwarf::DW_ACCESS_public);
1975 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1976 dwarf::DW_VIRTUALITY_virtual);
1978 // Objective-C properties.
1979 if (MDNode *PNode = DT.getObjCProperty())
1980 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1981 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1984 if (DT.isArtificial())
1985 addFlag(MemberDie, dwarf::DW_AT_artificial);
1988 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1989 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1993 // Construct the context before querying for the existence of the DIE in case
1994 // such construction creates the DIE.
1995 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1996 assert(dwarf::isType(ContextDIE->getTag()) &&
1997 "Static member should belong to a type.");
1999 DIE *StaticMemberDIE = getDIE(DT);
2000 if (StaticMemberDIE)
2001 return StaticMemberDIE;
2003 StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
2005 DIType Ty = resolve(DT.getTypeDerivedFrom());
2007 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
2008 addType(StaticMemberDIE, Ty);
2009 addSourceLine(StaticMemberDIE, DT);
2010 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
2011 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
2013 // FIXME: We could omit private if the parent is a class_type, and
2014 // public if the parent is something else.
2015 if (DT.isProtected())
2016 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2017 dwarf::DW_ACCESS_protected);
2018 else if (DT.isPrivate())
2019 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2020 dwarf::DW_ACCESS_private);
2022 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
2023 dwarf::DW_ACCESS_public);
2025 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
2026 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
2027 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
2028 addConstantFPValue(StaticMemberDIE, CFP);
2030 return StaticMemberDIE;
2033 void DwarfUnit::emitHeader(const MCSection *ASection,
2034 const MCSymbol *ASectionSym) const {
2035 Asm->OutStreamer.AddComment("DWARF version number");
2036 Asm->EmitInt16(DD->getDwarfVersion());
2037 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2038 // We share one abbreviations table across all units so it's always at the
2039 // start of the section. Use a relocatable offset where needed to ensure
2040 // linking doesn't invalidate that offset.
2041 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2042 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2043 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2046 void DwarfUnit::addRange(RangeSpan Range) {
2047 // Only add a range for this unit if we're emitting full debug.
2048 if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) {
2049 // If we have no current ranges just add the range and return, otherwise,
2050 // check the current section and CU against the previous section and CU we
2051 // emitted into and the subprogram was contained within. If these are the
2052 // same then extend our current range, otherwise add this as a new range.
2053 if (CURanges.size() == 0 ||
2054 this != DD->getPrevCU() ||
2055 Asm->getCurrentSection() != DD->getPrevSection()) {
2056 CURanges.push_back(Range);
2060 assert(&(CURanges.back().getEnd()->getSection()) ==
2061 &(Range.getEnd()->getSection()) &&
2062 "We can only append to a range in the same section!");
2063 CURanges.back().setEnd(Range.getEnd());
2067 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2068 // Define start line table label for each Compile Unit.
2069 MCSymbol *LineTableStartSym =
2070 Asm->GetTempSymbol("line_table_start", getUniqueID());
2071 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
2074 // Use a single line table if we are generating assembly.
2075 bool UseTheFirstCU =
2076 Asm->OutStreamer.hasRawTextSupport() || (getUniqueID() == 0);
2078 stmtListIndex = UnitDie->getValues().size();
2080 // DW_AT_stmt_list is a offset of line number information for this
2081 // compile unit in debug_line section. For split dwarf this is
2082 // left in the skeleton CU and so not included.
2083 // The line table entries are not always emitted in assembly, so it
2084 // is not okay to use line_table_start here.
2085 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2086 addSectionLabel(UnitDie.get(), dwarf::DW_AT_stmt_list,
2087 UseTheFirstCU ? DwarfLineSectionSym : LineTableStartSym);
2088 else if (UseTheFirstCU)
2089 addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
2091 addSectionDelta(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym,
2092 DwarfLineSectionSym);
2095 void DwarfCompileUnit::applyStmtList(DIE &D) {
2096 D.addValue(dwarf::DW_AT_stmt_list,
2097 UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
2098 UnitDie->getValues()[stmtListIndex]);
2101 void DwarfTypeUnit::emitHeader(const MCSection *ASection,
2102 const MCSymbol *ASectionSym) const {
2103 DwarfUnit::emitHeader(ASection, ASectionSym);
2104 Asm->OutStreamer.AddComment("Type Signature");
2105 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2106 Asm->OutStreamer.AddComment("Type DIE Offset");
2107 // In a skeleton type unit there is no type DIE so emit a zero offset.
2108 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2109 sizeof(Ty->getOffset()));
2112 void DwarfTypeUnit::initSection(const MCSection *Section) {
2113 assert(!this->Section);
2114 this->Section = Section;
2115 // Since each type unit is contained in its own COMDAT section, the begin
2116 // label and the section label are the same. Using the begin label emission in
2117 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2118 // the only other alternative of lazily constructing start-of-section labels
2119 // and storing a mapping in DwarfDebug (or AsmPrinter).
2120 this->SectionSym = this->LabelBegin =
2121 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2123 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2124 this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());