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 : DwarfUnit(UID, D, CU.getCUNode(), A, DW, DWU), CU(CU) {}
62 /// ~Unit - Destructor for compile unit.
63 DwarfUnit::~DwarfUnit() {
64 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
65 DIEBlocks[j]->~DIEBlock();
66 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
67 DIELocs[j]->~DIELoc();
70 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
71 /// information entry.
72 DIEEntry *DwarfUnit::createDIEEntry(DIE *Entry) {
73 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
77 /// getDefaultLowerBound - Return the default lower bound for an array. If the
78 /// DWARF version doesn't handle the language, return -1.
79 int64_t DwarfUnit::getDefaultLowerBound() const {
80 switch (getLanguage()) {
84 case dwarf::DW_LANG_C89:
85 case dwarf::DW_LANG_C99:
86 case dwarf::DW_LANG_C:
87 case dwarf::DW_LANG_C_plus_plus:
88 case dwarf::DW_LANG_ObjC:
89 case dwarf::DW_LANG_ObjC_plus_plus:
92 case dwarf::DW_LANG_Fortran77:
93 case dwarf::DW_LANG_Fortran90:
94 case dwarf::DW_LANG_Fortran95:
97 // The languages below have valid values only if the DWARF version >= 4.
98 case dwarf::DW_LANG_Java:
99 case dwarf::DW_LANG_Python:
100 case dwarf::DW_LANG_UPC:
101 case dwarf::DW_LANG_D:
102 if (dwarf::DWARF_VERSION >= 4)
106 case dwarf::DW_LANG_Ada83:
107 case dwarf::DW_LANG_Ada95:
108 case dwarf::DW_LANG_Cobol74:
109 case dwarf::DW_LANG_Cobol85:
110 case dwarf::DW_LANG_Modula2:
111 case dwarf::DW_LANG_Pascal83:
112 case dwarf::DW_LANG_PLI:
113 if (dwarf::DWARF_VERSION >= 4)
121 /// Check whether the DIE for this MDNode can be shared across CUs.
122 static bool isShareableAcrossCUs(DIDescriptor D) {
123 // When the MDNode can be part of the type system, the DIE can be shared
125 // Combining type units and cross-CU DIE sharing is lower value (since
126 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
127 // level already) but may be implementable for some value in projects
128 // building multiple independent libraries with LTO and then linking those
130 return (D.isType() ||
131 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
132 !GenerateDwarfTypeUnits;
135 /// getDIE - Returns the debug information entry map slot for the
136 /// specified debug variable. We delegate the request to DwarfDebug
137 /// when the DIE for this MDNode can be shared across CUs. The mappings
138 /// will be kept in DwarfDebug for shareable DIEs.
139 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
140 if (isShareableAcrossCUs(D))
141 return DD->getDIE(D);
142 return MDNodeToDieMap.lookup(D);
145 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
146 /// when the DIE for this MDNode can be shared across CUs. The mappings
147 /// will be kept in DwarfDebug for shareable DIEs.
148 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
149 if (isShareableAcrossCUs(Desc)) {
150 DD->insertDIE(Desc, D);
153 MDNodeToDieMap.insert(std::make_pair(Desc, D));
156 /// addFlag - Add a flag that is true.
157 void DwarfUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
158 if (DD->getDwarfVersion() >= 4)
159 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
161 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
164 /// addUInt - Add an unsigned integer attribute data and value.
166 void DwarfUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
167 Optional<dwarf::Form> Form, uint64_t Integer) {
169 Form = DIEInteger::BestForm(false, Integer);
170 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
172 Die->addValue(Attribute, *Form, Value);
175 void DwarfUnit::addUInt(DIE *Block, dwarf::Form Form, uint64_t Integer) {
176 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
179 /// addSInt - Add an signed integer attribute data and value.
181 void DwarfUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
182 Optional<dwarf::Form> Form, int64_t Integer) {
184 Form = DIEInteger::BestForm(true, Integer);
185 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
186 Die->addValue(Attribute, *Form, Value);
189 void DwarfUnit::addSInt(DIELoc *Die, Optional<dwarf::Form> Form,
191 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
194 /// addString - Add a string attribute data and value. We always emit a
195 /// reference to the string pool instead of immediate strings so that DIEs have
196 /// more predictable sizes. In the case of split dwarf we emit an index
197 /// into another table which gets us the static offset into the string
199 void DwarfUnit::addString(DIE *Die, dwarf::Attribute Attribute,
202 if (!DD->useSplitDwarf())
203 return addLocalString(Die, Attribute, String);
205 unsigned idx = DU->getStringPoolIndex(String);
206 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
207 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
208 Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
211 /// addLocalString - Add a string attribute data and value. This is guaranteed
212 /// to be in the local string pool instead of indirected.
213 void DwarfUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
215 MCSymbol *Symb = DU->getStringPoolEntry(String);
217 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
218 Value = new (DIEValueAllocator) DIELabel(Symb);
220 MCSymbol *StringPool = DU->getStringPoolSym();
221 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
223 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
224 Die->addValue(Attribute, dwarf::DW_FORM_strp, Str);
227 /// addExpr - Add a Dwarf expression attribute data and value.
229 void DwarfUnit::addExpr(DIELoc *Die, dwarf::Form Form, const MCExpr *Expr) {
230 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
231 Die->addValue((dwarf::Attribute)0, Form, Value);
234 /// addLocationList - Add a Dwarf loclistptr attribute data and value.
236 void DwarfUnit::addLocationList(DIE *Die, dwarf::Attribute Attribute,
238 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
239 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
240 : dwarf::DW_FORM_data4;
241 Die->addValue(Attribute, Form, Value);
244 /// addLabel - Add a Dwarf label attribute data and value.
246 void DwarfUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
247 const MCSymbol *Label) {
248 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
249 Die->addValue(Attribute, Form, Value);
252 void DwarfUnit::addLabel(DIELoc *Die, dwarf::Form Form, const MCSymbol *Label) {
253 addLabel(Die, (dwarf::Attribute)0, Form, Label);
256 /// addSectionLabel - Add a Dwarf section label attribute data and value.
258 void DwarfUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
259 const MCSymbol *Label) {
260 if (DD->getDwarfVersion() >= 4)
261 addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
263 addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
266 /// addSectionOffset - Add an offset into a section attribute data and value.
268 void DwarfUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
270 if (DD->getDwarfVersion() >= 4)
271 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
273 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
276 /// addLabelAddress - Add a dwarf label attribute data and value using
277 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
279 void DwarfCompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
282 DD->addArangeLabel(SymbolCU(this, Label));
284 if (!DD->useSplitDwarf()) {
286 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
287 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
289 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
290 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
293 unsigned idx = DU->getAddrPoolIndex(Label);
294 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
295 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
299 /// addOpAddress - Add a dwarf op address data and value using the
300 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
302 void DwarfUnit::addOpAddress(DIELoc *Die, const MCSymbol *Sym) {
303 if (!DD->useSplitDwarf()) {
304 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
305 addLabel(Die, dwarf::DW_FORM_udata, Sym);
307 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
308 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
312 /// addSectionDelta - Add a section label delta attribute data and value.
314 void DwarfUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
315 const MCSymbol *Hi, const MCSymbol *Lo) {
316 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
317 if (DD->getDwarfVersion() >= 4)
318 Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
320 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
323 void DwarfUnit::addLabelDelta(DIE *Die, dwarf::Attribute Attribute,
324 const MCSymbol *Hi, const MCSymbol *Lo) {
325 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
326 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
329 /// addDIEEntry - Add a DIE attribute data and value.
331 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
332 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
335 void DwarfUnit::addDIETypeSignature(DIE *Die, const DwarfTypeUnit &Type) {
336 Die->addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
337 new (DIEValueAllocator) DIETypeSignature(Type));
340 void DwarfUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
342 const DIE *DieCU = Die->getUnitOrNull();
343 const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
345 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
346 DieCU = getUnitDie();
348 EntryCU = getUnitDie();
349 Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
350 : dwarf::DW_FORM_ref_addr,
354 /// Create a DIE with the given Tag, add the DIE to its parent, and
355 /// call insertDIE if MD is not null.
356 DIE *DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
357 DIE *Die = new DIE(Tag);
358 Parent.addChild(Die);
364 /// addBlock - Add block data.
366 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute, DIELoc *Loc) {
367 Loc->ComputeSize(Asm);
368 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
369 Die->addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
372 void DwarfUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
374 Block->ComputeSize(Asm);
375 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
376 Die->addValue(Attribute, Block->BestForm(), Block);
379 /// addSourceLine - Add location information to specified debug information
381 void DwarfUnit::addSourceLine(DIE *Die, unsigned Line, StringRef File,
382 StringRef Directory) {
387 DD->getOrCreateSourceID(File, Directory, getCU().getUniqueID());
388 assert(FileID && "Invalid file id");
389 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
390 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
393 /// addSourceLine - Add location information to specified debug information
395 void DwarfUnit::addSourceLine(DIE *Die, DIVariable V) {
396 assert(V.isVariable());
398 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
399 V.getContext().getDirectory());
402 /// addSourceLine - Add location information to specified debug information
404 void DwarfUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
405 assert(G.isGlobalVariable());
407 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
410 /// addSourceLine - Add location information to specified debug information
412 void DwarfUnit::addSourceLine(DIE *Die, DISubprogram SP) {
413 assert(SP.isSubprogram());
415 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
418 /// addSourceLine - Add location information to specified debug information
420 void DwarfUnit::addSourceLine(DIE *Die, DIType Ty) {
423 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
426 /// addSourceLine - Add location information to specified debug information
428 void DwarfUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
429 assert(Ty.isObjCProperty());
431 DIFile File = Ty.getFile();
432 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
433 File.getDirectory());
436 /// addSourceLine - Add location information to specified debug information
438 void DwarfUnit::addSourceLine(DIE *Die, DINameSpace NS) {
441 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
444 /// addVariableAddress - Add DW_AT_location attribute for a
445 /// DbgVariable based on provided MachineLocation.
446 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
447 MachineLocation Location) {
448 if (DV.variableHasComplexAddress())
449 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
450 else if (DV.isBlockByrefVariable())
451 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
453 addAddress(Die, dwarf::DW_AT_location, Location,
454 DV.getVariable().isIndirect());
457 /// addRegisterOp - Add register operand.
458 void DwarfUnit::addRegisterOp(DIELoc *TheDie, unsigned Reg) {
459 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
460 int DWReg = RI->getDwarfRegNum(Reg, false);
461 bool isSubRegister = DWReg < 0;
465 // Go up the super-register chain until we hit a valid dwarf register number.
466 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) {
467 DWReg = RI->getDwarfRegNum(*SR, false);
469 Idx = RI->getSubRegIndex(*SR, Reg);
473 DEBUG(dbgs() << "Invalid Dwarf register number.\n");
474 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop);
480 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
482 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
483 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
488 unsigned Size = RI->getSubRegIdxSize(Idx);
489 unsigned Offset = RI->getSubRegIdxOffset(Idx);
491 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece);
492 addUInt(TheDie, dwarf::DW_FORM_data1, Size);
493 addUInt(TheDie, dwarf::DW_FORM_data1, Offset);
495 unsigned ByteSize = Size / 8; // Assuming 8 bits per byte.
496 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece);
497 addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize);
502 /// addRegisterOffset - Add register offset.
503 void DwarfUnit::addRegisterOffset(DIELoc *TheDie, unsigned Reg,
505 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
506 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
507 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
508 if (Reg == TRI->getFrameRegister(*Asm->MF))
509 // If variable offset is based in frame register then use fbreg.
510 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
512 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
514 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
515 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
517 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
520 /// addAddress - Add an address attribute to a die based on the location
522 void DwarfUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
523 const MachineLocation &Location, bool Indirect) {
524 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
526 if (Location.isReg() && !Indirect)
527 addRegisterOp(Loc, Location.getReg());
529 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
530 if (Indirect && !Location.isReg()) {
531 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
535 // Now attach the location information to the DIE.
536 addBlock(Die, Attribute, Loc);
539 /// addComplexAddress - Start with the address based on the location provided,
540 /// and generate the DWARF information necessary to find the actual variable
541 /// given the extra address information encoded in the DbgVariable, starting
542 /// from the starting location. Add the DWARF information to the die.
544 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
545 dwarf::Attribute Attribute,
546 const MachineLocation &Location) {
547 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
548 unsigned N = DV.getNumAddrElements();
550 if (Location.isReg()) {
551 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
552 // If first address element is OpPlus then emit
553 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
554 addRegisterOffset(Loc, Location.getReg(), DV.getAddrElement(1));
557 addRegisterOp(Loc, Location.getReg());
559 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
562 uint64_t Element = DV.getAddrElement(i);
563 if (Element == DIBuilder::OpPlus) {
564 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
565 addUInt(Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
566 } else if (Element == DIBuilder::OpDeref) {
567 if (!Location.isReg())
568 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
570 llvm_unreachable("unknown DIBuilder Opcode");
573 // Now attach the location information to the DIE.
574 addBlock(Die, Attribute, Loc);
577 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
578 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
579 gives the variable VarName either the struct, or a pointer to the struct, as
580 its type. This is necessary for various behind-the-scenes things the
581 compiler needs to do with by-reference variables in Blocks.
583 However, as far as the original *programmer* is concerned, the variable
584 should still have type 'SomeType', as originally declared.
586 The function getBlockByrefType dives into the __Block_byref_x_VarName
587 struct to find the original type of the variable, which is then assigned to
588 the variable's Debug Information Entry as its real type. So far, so good.
589 However now the debugger will expect the variable VarName to have the type
590 SomeType. So we need the location attribute for the variable to be an
591 expression that explains to the debugger how to navigate through the
592 pointers and struct to find the actual variable of type SomeType.
594 The following function does just that. We start by getting
595 the "normal" location for the variable. This will be the location
596 of either the struct __Block_byref_x_VarName or the pointer to the
597 struct __Block_byref_x_VarName.
599 The struct will look something like:
601 struct __Block_byref_x_VarName {
603 struct __Block_byref_x_VarName *forwarding;
604 ... <various other fields>
606 ... <maybe more fields>
609 If we are given the struct directly (as our starting point) we
610 need to tell the debugger to:
612 1). Add the offset of the forwarding field.
614 2). Follow that pointer to get the real __Block_byref_x_VarName
615 struct to use (the real one may have been copied onto the heap).
617 3). Add the offset for the field VarName, to find the actual variable.
619 If we started with a pointer to the struct, then we need to
620 dereference that pointer first, before the other steps.
621 Translating this into DWARF ops, we will need to append the following
622 to the current location description for the variable:
624 DW_OP_deref -- optional, if we start with a pointer
625 DW_OP_plus_uconst <forward_fld_offset>
627 DW_OP_plus_uconst <varName_fld_offset>
629 That is what this function does. */
631 /// addBlockByrefAddress - Start with the address based on the location
632 /// provided, and generate the DWARF information necessary to find the
633 /// actual Block variable (navigating the Block struct) based on the
634 /// starting location. Add the DWARF information to the die. For
635 /// more information, read large comment just above here.
637 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
638 dwarf::Attribute Attribute,
639 const MachineLocation &Location) {
640 DIType Ty = DV.getType();
642 uint16_t Tag = Ty.getTag();
643 bool isPointer = false;
645 StringRef varName = DV.getName();
647 if (Tag == dwarf::DW_TAG_pointer_type) {
648 DIDerivedType DTy(Ty);
649 TmpTy = resolve(DTy.getTypeDerivedFrom());
653 DICompositeType blockStruct(TmpTy);
655 // Find the __forwarding field and the variable field in the __Block_byref
657 DIArray Fields = blockStruct.getTypeArray();
658 DIDerivedType varField;
659 DIDerivedType forwardingField;
661 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
662 DIDerivedType DT(Fields.getElement(i));
663 StringRef fieldName = DT.getName();
664 if (fieldName == "__forwarding")
665 forwardingField = DT;
666 else if (fieldName == varName)
670 // Get the offsets for the forwarding field and the variable field.
671 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
672 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
674 // Decode the original location, and use that as the start of the byref
675 // variable's location.
676 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
678 if (Location.isReg())
679 addRegisterOp(Loc, Location.getReg());
681 addRegisterOffset(Loc, Location.getReg(), Location.getOffset());
683 // If we started with a pointer to the __Block_byref... struct, then
684 // the first thing we need to do is dereference the pointer (DW_OP_deref).
686 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
688 // Next add the offset for the '__forwarding' field:
689 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
690 // adding the offset if it's 0.
691 if (forwardingFieldOffset > 0) {
692 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
693 addUInt(Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
696 // Now dereference the __forwarding field to get to the real __Block_byref
697 // struct: DW_OP_deref.
698 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
700 // Now that we've got the real __Block_byref... struct, add the offset
701 // for the variable's field to get to the location of the actual variable:
702 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
703 if (varFieldOffset > 0) {
704 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
705 addUInt(Loc, dwarf::DW_FORM_udata, varFieldOffset);
708 // Now attach the location information to the DIE.
709 addBlock(Die, Attribute, Loc);
712 /// isTypeSigned - Return true if the type is signed.
713 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
714 if (Ty.isDerivedType())
715 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
717 if (Ty.isBasicType())
718 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
719 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
720 *SizeInBits = Ty.getSizeInBits();
726 /// Return true if type encoding is unsigned.
727 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
728 DIDerivedType DTy(Ty);
729 if (DTy.isDerivedType())
730 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
733 if (BTy.isBasicType()) {
734 unsigned Encoding = BTy.getEncoding();
735 if (Encoding == dwarf::DW_ATE_unsigned ||
736 Encoding == dwarf::DW_ATE_unsigned_char ||
737 Encoding == dwarf::DW_ATE_boolean)
743 /// If this type is derived from a base type then return base type size.
744 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
745 unsigned Tag = Ty.getTag();
747 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
748 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
749 Tag != dwarf::DW_TAG_restrict_type)
750 return Ty.getSizeInBits();
752 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
754 // If this type is not derived from any type then take conservative approach.
755 if (!BaseType.isValid())
756 return Ty.getSizeInBits();
758 // If this is a derived type, go ahead and get the base type, unless it's a
759 // reference then it's just the size of the field. Pointer types have no need
760 // of this since they're a different type of qualification on the type.
761 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
762 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
763 return Ty.getSizeInBits();
765 if (BaseType.isDerivedType())
766 return getBaseTypeSize(DD, DIDerivedType(BaseType));
768 return BaseType.getSizeInBits();
771 /// addConstantValue - Add constant value entry in variable DIE.
772 void DwarfUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
774 // FIXME: This is a bit conservative/simple - it emits negative values at
775 // their maximum bit width which is a bit unfortunate (& doesn't prefer
776 // udata/sdata over dataN as suggested by the DWARF spec)
777 assert(MO.isImm() && "Invalid machine operand!");
779 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
782 // If we're a signed constant definitely use sdata.
783 if (SignedConstant) {
784 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
788 // Else use data for now unless it's larger than we can deal with.
789 switch (SizeInBits) {
791 Form = dwarf::DW_FORM_data1;
794 Form = dwarf::DW_FORM_data2;
797 Form = dwarf::DW_FORM_data4;
800 Form = dwarf::DW_FORM_data8;
803 Form = dwarf::DW_FORM_udata;
804 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
807 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
810 /// addConstantFPValue - Add constant value entry in variable DIE.
811 void DwarfUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
812 assert(MO.isFPImm() && "Invalid machine operand!");
813 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
814 APFloat FPImm = MO.getFPImm()->getValueAPF();
816 // Get the raw data form of the floating point.
817 const APInt FltVal = FPImm.bitcastToAPInt();
818 const char *FltPtr = (const char *)FltVal.getRawData();
820 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
821 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
822 int Incr = (LittleEndian ? 1 : -1);
823 int Start = (LittleEndian ? 0 : NumBytes - 1);
824 int Stop = (LittleEndian ? NumBytes : -1);
826 // Output the constant to DWARF one byte at a time.
827 for (; Start != Stop; Start += Incr)
828 addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
830 addBlock(Die, dwarf::DW_AT_const_value, Block);
833 /// addConstantFPValue - Add constant value entry in variable DIE.
834 void DwarfUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
835 // Pass this down to addConstantValue as an unsigned bag of bits.
836 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
839 /// addConstantValue - Add constant value entry in variable DIE.
840 void DwarfUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
842 addConstantValue(Die, CI->getValue(), Unsigned);
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 // If we're a signed constant definitely use sdata.
851 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
856 // Else use data for now unless it's larger than we can deal with.
858 switch (CIBitWidth) {
860 Form = dwarf::DW_FORM_data1;
863 Form = dwarf::DW_FORM_data2;
866 Form = dwarf::DW_FORM_data4;
869 Form = dwarf::DW_FORM_data8;
872 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
876 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
880 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
882 // Get the raw data form of the large APInt.
883 const uint64_t *Ptr64 = Val.getRawData();
885 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
886 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
888 // Output the constant to DWARF one byte at a time.
889 for (int i = 0; i < NumBytes; i++) {
892 c = Ptr64[i / 8] >> (8 * (i & 7));
894 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
895 addUInt(Block, dwarf::DW_FORM_data1, c);
898 addBlock(Die, dwarf::DW_AT_const_value, Block);
901 /// addTemplateParams - Add template parameters into buffer.
902 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
903 // Add template parameters.
904 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
905 DIDescriptor Element = TParams.getElement(i);
906 if (Element.isTemplateTypeParameter())
907 constructTemplateTypeParameterDIE(Buffer,
908 DITemplateTypeParameter(Element));
909 else if (Element.isTemplateValueParameter())
910 constructTemplateValueParameterDIE(Buffer,
911 DITemplateValueParameter(Element));
915 /// getOrCreateContextDIE - Get context owner's DIE.
916 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
917 if (!Context || Context.isFile())
919 if (Context.isType())
920 return getOrCreateTypeDIE(DIType(Context));
921 if (Context.isNameSpace())
922 return getOrCreateNameSpace(DINameSpace(Context));
923 if (Context.isSubprogram())
924 return getOrCreateSubprogramDIE(DISubprogram(Context));
925 return getDIE(Context);
928 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
929 DIScope Context = resolve(Ty.getContext());
930 DIE *ContextDIE = getOrCreateContextDIE(Context);
932 DIE *TyDIE = getDIE(Ty);
937 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
939 constructTypeDIE(*TyDIE, Ty);
941 updateAcceleratorTables(Context, Ty, TyDIE);
945 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
947 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
954 // Construct the context before querying for the existence of the DIE in case
955 // such construction creates the DIE.
956 DIScope Context = resolve(Ty.getContext());
957 DIE *ContextDIE = getOrCreateContextDIE(Context);
960 DIE *TyDIE = getDIE(Ty);
965 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
967 updateAcceleratorTables(Context, Ty, TyDIE);
969 if (Ty.isBasicType())
970 constructTypeDIE(*TyDIE, DIBasicType(Ty));
971 else if (Ty.isCompositeType()) {
972 DICompositeType CTy(Ty);
973 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
974 if (MDString *TypeId = CTy.getIdentifier()) {
975 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
976 // Skip updating the accellerator tables since this is not the full type
979 constructTypeDIE(*TyDIE, CTy);
981 assert(Ty.isDerivedType() && "Unknown kind of DIType");
982 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
988 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
990 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
991 bool IsImplementation = 0;
992 if (Ty.isCompositeType()) {
993 DICompositeType CT(Ty);
994 // A runtime language of 0 actually means C/C++ and that any
995 // non-negative value is some version of Objective-C/C++.
996 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
998 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
999 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
1001 if ((!Context || Context.isCompileUnit() || Context.isFile() ||
1002 Context.isNameSpace()) &&
1003 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly)
1004 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
1008 /// addType - Add a new type attribute to the specified entity.
1009 void DwarfUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
1010 assert(Ty && "Trying to add a type that doesn't exist?");
1012 // Check for pre-existence.
1013 DIEEntry *Entry = getDIEEntry(Ty);
1014 // If it exists then use the existing value.
1016 addDIEEntry(Entity, Attribute, Entry);
1021 DIE *Buffer = getOrCreateTypeDIE(Ty);
1024 Entry = createDIEEntry(Buffer);
1025 insertDIEEntry(Ty, Entry);
1026 addDIEEntry(Entity, Attribute, Entry);
1029 // Accelerator table mutators - add each name along with its companion
1030 // DIE to the proper table while ensuring that the name that we're going
1031 // to reference is in the string table. We do this since the names we
1032 // add may not only be identical to the names in the DIE.
1033 void DwarfUnit::addAccelName(StringRef Name, const DIE *Die) {
1034 if (!DD->useDwarfAccelTables())
1036 DU->getStringPoolEntry(Name);
1037 std::vector<const DIE *> &DIEs = AccelNames[Name];
1038 DIEs.push_back(Die);
1041 void DwarfUnit::addAccelObjC(StringRef Name, const DIE *Die) {
1042 if (!DD->useDwarfAccelTables())
1044 DU->getStringPoolEntry(Name);
1045 std::vector<const DIE *> &DIEs = AccelObjC[Name];
1046 DIEs.push_back(Die);
1049 void DwarfUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
1050 if (!DD->useDwarfAccelTables())
1052 DU->getStringPoolEntry(Name);
1053 std::vector<const DIE *> &DIEs = AccelNamespace[Name];
1054 DIEs.push_back(Die);
1057 void DwarfUnit::addAccelType(StringRef Name,
1058 std::pair<const DIE *, unsigned> Die) {
1059 if (!DD->useDwarfAccelTables())
1061 DU->getStringPoolEntry(Name);
1062 std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
1063 DIEs.push_back(Die);
1066 /// addGlobalName - Add a new global name to the compile unit.
1067 void DwarfUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
1068 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly)
1070 std::string FullName = getParentContextString(Context) + Name.str();
1071 GlobalNames[FullName] = Die;
1074 /// getParentContextString - Walks the metadata parent chain in a language
1075 /// specific manner (using the compile unit language) and returns
1076 /// it as a string. This is done at the metadata level because DIEs may
1077 /// not currently have been added to the parent context and walking the
1078 /// DIEs looking for names is more expensive than walking the metadata.
1079 std::string DwarfUnit::getParentContextString(DIScope Context) const {
1083 // FIXME: Decide whether to implement this for non-C++ languages.
1084 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1088 SmallVector<DIScope, 1> Parents;
1089 while (!Context.isCompileUnit()) {
1090 Parents.push_back(Context);
1091 if (Context.getContext())
1092 Context = resolve(Context.getContext());
1094 // Structure, etc types will have a NULL context if they're at the top
1099 // Reverse iterate over our list to go from the outermost construct to the
1101 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1105 StringRef Name = Ctx.getName();
1106 if (!Name.empty()) {
1114 /// constructTypeDIE - Construct basic type die from DIBasicType.
1115 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1116 // Get core information.
1117 StringRef Name = BTy.getName();
1118 // Add name if not anonymous or intermediate type.
1120 addString(&Buffer, dwarf::DW_AT_name, Name);
1122 // An unspecified type only has a name attribute.
1123 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1126 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1129 uint64_t Size = BTy.getSizeInBits() >> 3;
1130 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1133 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1134 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1135 // Get core information.
1136 StringRef Name = DTy.getName();
1137 uint64_t Size = DTy.getSizeInBits() >> 3;
1138 uint16_t Tag = Buffer.getTag();
1140 // Map to main type, void will not have a type.
1141 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1143 addType(&Buffer, FromTy);
1145 // Add name if not anonymous or intermediate type.
1147 addString(&Buffer, dwarf::DW_AT_name, Name);
1149 // Add size if non-zero (derived types might be zero-sized.)
1150 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1151 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1153 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1154 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1155 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1156 // Add source line info if available and TyDesc is not a forward declaration.
1157 if (!DTy.isForwardDecl())
1158 addSourceLine(&Buffer, DTy);
1161 /// constructSubprogramArguments - Construct function argument DIEs.
1162 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) {
1163 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1164 DIDescriptor Ty = Args.getElement(i);
1165 if (Ty.isUnspecifiedParameter()) {
1166 assert(i == N-1 && "Unspecified parameter must be the last argument");
1167 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1169 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1170 addType(Arg, DIType(Ty));
1171 if (DIType(Ty).isArtificial())
1172 addFlag(Arg, dwarf::DW_AT_artificial);
1177 /// constructTypeDIE - Construct type DIE from DICompositeType.
1178 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1179 // Add name if not anonymous or intermediate type.
1180 StringRef Name = CTy.getName();
1182 uint64_t Size = CTy.getSizeInBits() >> 3;
1183 uint16_t Tag = Buffer.getTag();
1186 case dwarf::DW_TAG_array_type:
1187 constructArrayTypeDIE(Buffer, CTy);
1189 case dwarf::DW_TAG_enumeration_type:
1190 constructEnumTypeDIE(Buffer, CTy);
1192 case dwarf::DW_TAG_subroutine_type: {
1193 // Add return type. A void return won't have a type.
1194 DIArray Elements = CTy.getTypeArray();
1195 DIType RTy(Elements.getElement(0));
1197 addType(&Buffer, RTy);
1199 bool isPrototyped = true;
1200 if (Elements.getNumElements() == 2 &&
1201 Elements.getElement(1).isUnspecifiedParameter())
1202 isPrototyped = false;
1204 constructSubprogramArguments(Buffer, Elements);
1206 // Add prototype flag if we're dealing with a C language and the
1207 // function has been prototyped.
1208 uint16_t Language = getLanguage();
1210 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1211 Language == dwarf::DW_LANG_ObjC))
1212 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1214 if (CTy.isLValueReference())
1215 addFlag(&Buffer, dwarf::DW_AT_reference);
1217 if (CTy.isRValueReference())
1218 addFlag(&Buffer, dwarf::DW_AT_rvalue_reference);
1220 case dwarf::DW_TAG_structure_type:
1221 case dwarf::DW_TAG_union_type:
1222 case dwarf::DW_TAG_class_type: {
1223 // Add elements to structure type.
1224 DIArray Elements = CTy.getTypeArray();
1225 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1226 DIDescriptor Element = Elements.getElement(i);
1227 DIE *ElemDie = NULL;
1228 if (Element.isSubprogram())
1229 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1230 else if (Element.isDerivedType()) {
1231 DIDerivedType DDTy(Element);
1232 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1233 ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1234 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1235 dwarf::DW_AT_friend);
1236 } else if (DDTy.isStaticMember()) {
1237 getOrCreateStaticMemberDIE(DDTy);
1239 constructMemberDIE(Buffer, DDTy);
1241 } else if (Element.isObjCProperty()) {
1242 DIObjCProperty Property(Element);
1243 ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1244 StringRef PropertyName = Property.getObjCPropertyName();
1245 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1246 if (Property.getType())
1247 addType(ElemDie, Property.getType());
1248 addSourceLine(ElemDie, Property);
1249 StringRef GetterName = Property.getObjCPropertyGetterName();
1250 if (!GetterName.empty())
1251 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1252 StringRef SetterName = Property.getObjCPropertySetterName();
1253 if (!SetterName.empty())
1254 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1255 unsigned PropertyAttributes = 0;
1256 if (Property.isReadOnlyObjCProperty())
1257 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1258 if (Property.isReadWriteObjCProperty())
1259 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1260 if (Property.isAssignObjCProperty())
1261 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1262 if (Property.isRetainObjCProperty())
1263 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1264 if (Property.isCopyObjCProperty())
1265 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1266 if (Property.isNonAtomicObjCProperty())
1267 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1268 if (PropertyAttributes)
1269 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1270 PropertyAttributes);
1272 DIEEntry *Entry = getDIEEntry(Element);
1274 Entry = createDIEEntry(ElemDie);
1275 insertDIEEntry(Element, Entry);
1281 if (CTy.isAppleBlockExtension())
1282 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1284 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1286 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1287 getOrCreateTypeDIE(ContainingType));
1289 if (CTy.isObjcClassComplete())
1290 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1292 // Add template parameters to a class, structure or union types.
1293 // FIXME: The support isn't in the metadata for this yet.
1294 if (Tag == dwarf::DW_TAG_class_type ||
1295 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1296 addTemplateParams(Buffer, CTy.getTemplateParams());
1304 // Add name if not anonymous or intermediate type.
1306 addString(&Buffer, dwarf::DW_AT_name, Name);
1308 if (Tag == dwarf::DW_TAG_enumeration_type ||
1309 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1310 Tag == dwarf::DW_TAG_union_type) {
1311 // Add size if non-zero (derived types might be zero-sized.)
1312 // TODO: Do we care about size for enum forward declarations?
1314 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1315 else if (!CTy.isForwardDecl())
1316 // Add zero size if it is not a forward declaration.
1317 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1319 // If we're a forward decl, say so.
1320 if (CTy.isForwardDecl())
1321 addFlag(&Buffer, dwarf::DW_AT_declaration);
1323 // Add source line info if available.
1324 if (!CTy.isForwardDecl())
1325 addSourceLine(&Buffer, CTy);
1327 // No harm in adding the runtime language to the declaration.
1328 unsigned RLang = CTy.getRunTimeLang();
1330 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1335 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1336 /// DITemplateTypeParameter.
1337 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1338 DITemplateTypeParameter TP) {
1340 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1341 // Add the type if it exists, it could be void and therefore no type.
1343 addType(ParamDIE, resolve(TP.getType()));
1344 if (!TP.getName().empty())
1345 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1348 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1349 /// DITemplateValueParameter.
1351 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1352 DITemplateValueParameter VP) {
1353 DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1355 // Add the type if there is one, template template and template parameter
1356 // packs will not have a type.
1357 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1358 addType(ParamDIE, resolve(VP.getType()));
1359 if (!VP.getName().empty())
1360 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1361 if (Value *Val = VP.getValue()) {
1362 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1363 addConstantValue(ParamDIE, CI,
1364 isUnsignedDIType(DD, resolve(VP.getType())));
1365 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1366 // For declaration non-type template parameters (such as global values and
1368 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1369 addOpAddress(Loc, Asm->getSymbol(GV));
1370 // Emit DW_OP_stack_value to use the address as the immediate value of the
1371 // parameter, rather than a pointer to it.
1372 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1373 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1374 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1375 assert(isa<MDString>(Val));
1376 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1377 cast<MDString>(Val)->getString());
1378 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1379 assert(isa<MDNode>(Val));
1380 DIArray A(cast<MDNode>(Val));
1381 addTemplateParams(*ParamDIE, A);
1386 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1387 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1388 // Construct the context before querying for the existence of the DIE in case
1389 // such construction creates the DIE.
1390 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1392 DIE *NDie = getDIE(NS);
1395 NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1397 if (!NS.getName().empty()) {
1398 addString(NDie, dwarf::DW_AT_name, NS.getName());
1399 addAccelNamespace(NS.getName(), NDie);
1400 addGlobalName(NS.getName(), NDie, NS.getContext());
1402 addAccelNamespace("(anonymous namespace)", NDie);
1403 addSourceLine(NDie, NS);
1407 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1408 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1409 // Construct the context before querying for the existence of the DIE in case
1410 // such construction creates the DIE (as is the case for member function
1412 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1414 DIE *SPDie = getDIE(SP);
1418 DISubprogram SPDecl = SP.getFunctionDeclaration();
1419 if (SPDecl.isSubprogram())
1420 // Add subprogram definitions to the CU die directly.
1421 ContextDIE = UnitDie.get();
1423 // DW_TAG_inlined_subroutine may refer to this DIE.
1424 SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1426 DIE *DeclDie = NULL;
1427 if (SPDecl.isSubprogram())
1428 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1430 // Add function template parameters.
1431 addTemplateParams(*SPDie, SP.getTemplateParams());
1433 // If this DIE is going to refer declaration info using AT_specification
1434 // then there is no need to add other attributes.
1436 // Refer function declaration directly.
1437 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1442 // Add the linkage name if we have one.
1443 StringRef LinkageName = SP.getLinkageName();
1444 if (!LinkageName.empty())
1445 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1446 GlobalValue::getRealLinkageName(LinkageName));
1448 // Constructors and operators for anonymous aggregates do not have names.
1449 if (!SP.getName().empty())
1450 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1452 addSourceLine(SPDie, SP);
1454 // Add the prototype if we have a prototype and we have a C like
1456 uint16_t Language = getLanguage();
1457 if (SP.isPrototyped() &&
1458 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1459 Language == dwarf::DW_LANG_ObjC))
1460 addFlag(SPDie, dwarf::DW_AT_prototyped);
1462 DICompositeType SPTy = SP.getType();
1463 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1464 "the type of a subprogram should be a subroutine");
1466 DIArray Args = SPTy.getTypeArray();
1467 // Add a return type. If this is a type like a C/C++ void type we don't add a
1469 if (Args.getElement(0))
1470 addType(SPDie, DIType(Args.getElement(0)));
1472 unsigned VK = SP.getVirtuality();
1474 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1475 DIELoc *Block = getDIELoc();
1476 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1477 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1478 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1479 ContainingTypeMap.insert(
1480 std::make_pair(SPDie, resolve(SP.getContainingType())));
1483 if (!SP.isDefinition()) {
1484 addFlag(SPDie, dwarf::DW_AT_declaration);
1486 // Add arguments. Do not add arguments for subprogram definition. They will
1487 // be handled while processing variables.
1488 constructSubprogramArguments(*SPDie, Args);
1491 if (SP.isArtificial())
1492 addFlag(SPDie, dwarf::DW_AT_artificial);
1494 if (!SP.isLocalToUnit())
1495 addFlag(SPDie, dwarf::DW_AT_external);
1497 if (SP.isOptimized())
1498 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1500 if (unsigned isa = Asm->getISAEncoding()) {
1501 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1504 if (SP.isLValueReference())
1505 addFlag(SPDie, dwarf::DW_AT_reference);
1507 if (SP.isRValueReference())
1508 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1510 if (SP.isProtected())
1511 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1512 dwarf::DW_ACCESS_protected);
1513 else if (SP.isPrivate())
1514 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1515 dwarf::DW_ACCESS_private);
1517 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1518 dwarf::DW_ACCESS_public);
1520 if (SP.isExplicit())
1521 addFlag(SPDie, dwarf::DW_AT_explicit);
1526 // Return const expression if value is a GEP to access merged global
1528 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1529 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1530 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1531 if (!CE || CE->getNumOperands() != 3 ||
1532 CE->getOpcode() != Instruction::GetElementPtr)
1535 // First operand points to a global struct.
1536 Value *Ptr = CE->getOperand(0);
1537 if (!isa<GlobalValue>(Ptr) ||
1538 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1541 // Second operand is zero.
1542 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1543 if (!CI || !CI->isZero())
1546 // Third operand is offset.
1547 if (!isa<ConstantInt>(CE->getOperand(2)))
1553 /// createGlobalVariableDIE - create global variable DIE.
1554 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1555 // Check for pre-existence.
1559 assert(GV.isGlobalVariable());
1561 DIScope GVContext = GV.getContext();
1562 DIType GTy = GV.getType();
1564 // If this is a static data member definition, some attributes belong
1565 // to the declaration DIE.
1566 DIE *VariableDIE = NULL;
1567 bool IsStaticMember = false;
1568 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1569 if (SDMDecl.Verify()) {
1570 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1571 // We need the declaration DIE that is in the static member's class.
1572 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1573 IsStaticMember = true;
1576 // If this is not a static data member definition, create the variable
1577 // DIE and add the initial set of attributes to it.
1579 // Construct the context before querying for the existence of the DIE in
1580 // case such construction creates the DIE.
1581 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1584 VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1586 // Add name and type.
1587 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1588 addType(VariableDIE, GTy);
1590 // Add scoping info.
1591 if (!GV.isLocalToUnit())
1592 addFlag(VariableDIE, dwarf::DW_AT_external);
1594 // Add line number info.
1595 addSourceLine(VariableDIE, GV);
1599 bool addToAccelTable = false;
1600 DIE *VariableSpecDIE = NULL;
1601 bool isGlobalVariable = GV.getGlobal() != NULL;
1602 if (isGlobalVariable) {
1603 addToAccelTable = true;
1604 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1605 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1606 if (GV.getGlobal()->isThreadLocal()) {
1607 // FIXME: Make this work with -gsplit-dwarf.
1608 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1609 assert((PointerSize == 4 || PointerSize == 8) &&
1610 "Add support for other sizes if necessary");
1611 // Based on GCC's support for TLS:
1612 if (!DD->useSplitDwarf()) {
1613 // 1) Start with a constNu of the appropriate pointer size
1614 addUInt(Loc, dwarf::DW_FORM_data1,
1615 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1616 // 2) containing the (relocated) offset of the TLS variable
1617 // within the module's TLS block.
1618 addExpr(Loc, dwarf::DW_FORM_udata,
1619 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
1621 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1622 addUInt(Loc, dwarf::DW_FORM_udata,
1623 DU->getAddrPoolIndex(Sym, /* TLS */ true));
1625 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1626 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1628 DD->addArangeLabel(SymbolCU(this, Sym));
1629 addOpAddress(Loc, Sym);
1631 // Do not create specification DIE if context is either compile unit
1633 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1634 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1635 // Create specification DIE.
1636 VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *UnitDie);
1637 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1638 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Loc);
1639 // A static member's declaration is already flagged as such.
1640 if (!SDMDecl.Verify())
1641 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1643 addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1645 // Add the linkage name.
1646 StringRef LinkageName = GV.getLinkageName();
1647 if (!LinkageName.empty())
1648 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1649 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1651 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1653 dwarf::DW_AT_MIPS_linkage_name,
1654 GlobalValue::getRealLinkageName(LinkageName));
1655 } else if (const ConstantInt *CI =
1656 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1657 // AT_const_value was added when the static member was created. To avoid
1658 // emitting AT_const_value multiple times, we only add AT_const_value when
1659 // it is not a static member.
1660 if (!IsStaticMember)
1661 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1662 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1663 addToAccelTable = true;
1664 // GV is a merged global.
1665 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1666 Value *Ptr = CE->getOperand(0);
1667 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1668 DD->addArangeLabel(SymbolCU(this, Sym));
1669 addOpAddress(Loc, Sym);
1670 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1671 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1672 addUInt(Loc, dwarf::DW_FORM_udata,
1673 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1674 addUInt(Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1675 addBlock(VariableDIE, dwarf::DW_AT_location, Loc);
1678 if (addToAccelTable) {
1679 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1680 addAccelName(GV.getName(), AddrDIE);
1682 // If the linkage name is different than the name, go ahead and output
1683 // that as well into the name table.
1684 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1685 addAccelName(GV.getLinkageName(), AddrDIE);
1688 if (!GV.isLocalToUnit())
1689 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1693 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1694 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1695 DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1696 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1698 // The LowerBound value defines the lower bounds which is typically zero for
1699 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1700 // Count == -1 then the array is unbounded and we do not emit
1701 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1702 // Count == 0, then the array has zero elements in which case we do not emit
1704 int64_t LowerBound = SR.getLo();
1705 int64_t DefaultLowerBound = getDefaultLowerBound();
1706 int64_t Count = SR.getCount();
1708 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1709 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1711 if (Count != -1 && Count != 0)
1712 // FIXME: An unbounded array should reference the expression that defines
1714 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1715 LowerBound + Count - 1);
1718 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1719 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1721 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1723 // Emit the element type.
1724 addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1726 // Get an anonymous type for index type.
1727 // FIXME: This type should be passed down from the front end
1728 // as different languages may have different sizes for indexes.
1729 DIE *IdxTy = getIndexTyDie();
1731 // Construct an anonymous type for index type.
1732 IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *UnitDie);
1733 addString(IdxTy, dwarf::DW_AT_name, "int");
1734 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1735 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1736 dwarf::DW_ATE_signed);
1737 setIndexTyDie(IdxTy);
1740 // Add subranges to array type.
1741 DIArray Elements = CTy.getTypeArray();
1742 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1743 DIDescriptor Element = Elements.getElement(i);
1744 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1745 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1749 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1750 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1751 DIArray Elements = CTy.getTypeArray();
1753 // Add enumerators to enumeration type.
1754 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1755 DIEnumerator Enum(Elements.getElement(i));
1756 if (Enum.isEnumerator()) {
1757 DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1758 StringRef Name = Enum.getName();
1759 addString(Enumerator, dwarf::DW_AT_name, Name);
1760 int64_t Value = Enum.getEnumValue();
1761 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1765 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1767 addType(&Buffer, DTy);
1768 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1772 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1774 void DwarfUnit::constructContainingTypeDIEs() {
1775 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1776 CE = ContainingTypeMap.end();
1778 DIE *SPDie = CI->first;
1779 DIDescriptor D(CI->second);
1782 DIE *NDie = getDIE(D);
1785 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1789 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1790 DIE *DwarfUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1791 StringRef Name = DV.getName();
1793 // Define variable debug information entry.
1794 DIE *VariableDie = new DIE(DV.getTag());
1795 DbgVariable *AbsVar = DV.getAbstractVariable();
1796 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1798 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1801 addString(VariableDie, dwarf::DW_AT_name, Name);
1802 addSourceLine(VariableDie, DV.getVariable());
1803 addType(VariableDie, DV.getType());
1806 if (DV.isArtificial())
1807 addFlag(VariableDie, dwarf::DW_AT_artificial);
1809 if (isScopeAbstract) {
1810 DV.setDIE(VariableDie);
1814 // Add variable address.
1816 unsigned Offset = DV.getDotDebugLocOffset();
1817 if (Offset != ~0U) {
1818 addLocationList(VariableDie, dwarf::DW_AT_location, Offset);
1819 DV.setDIE(VariableDie);
1823 // Check if variable is described by a DBG_VALUE instruction.
1824 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1825 assert(DVInsn->getNumOperands() == 3);
1826 if (DVInsn->getOperand(0).isReg()) {
1827 const MachineOperand RegOp = DVInsn->getOperand(0);
1828 // If the second operand is an immediate, this is an indirect value.
1829 if (DVInsn->getOperand(1).isImm()) {
1830 MachineLocation Location(RegOp.getReg(),
1831 DVInsn->getOperand(1).getImm());
1832 addVariableAddress(DV, VariableDie, Location);
1833 } else if (RegOp.getReg())
1834 addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1835 } else if (DVInsn->getOperand(0).isImm())
1836 addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1837 else if (DVInsn->getOperand(0).isFPImm())
1838 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1839 else if (DVInsn->getOperand(0).isCImm())
1840 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1841 isUnsignedDIType(DD, DV.getType()));
1843 DV.setDIE(VariableDie);
1846 // .. else use frame index.
1847 int FI = DV.getFrameIndex();
1849 unsigned FrameReg = 0;
1850 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1851 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1852 MachineLocation Location(FrameReg, Offset);
1853 addVariableAddress(DV, VariableDie, Location);
1857 DV.setDIE(VariableDie);
1861 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1862 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1863 DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1864 StringRef Name = DT.getName();
1866 addString(MemberDie, dwarf::DW_AT_name, Name);
1868 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1870 addSourceLine(MemberDie, DT);
1872 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1874 // For C++, virtual base classes are not at fixed offset. Use following
1875 // expression to extract appropriate offset from vtable.
1876 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1878 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1879 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1880 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1881 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1882 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1883 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1884 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1885 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1887 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1889 uint64_t Size = DT.getSizeInBits();
1890 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1891 uint64_t OffsetInBytes;
1893 if (Size != FieldSize) {
1895 addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1896 getBaseTypeSize(DD, DT) >> 3);
1897 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1899 uint64_t Offset = DT.getOffsetInBits();
1900 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1901 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1902 uint64_t FieldOffset = (HiMark - FieldSize);
1903 Offset -= FieldOffset;
1905 // Maybe we need to work from the other end.
1906 if (Asm->getDataLayout().isLittleEndian())
1907 Offset = FieldSize - (Offset + Size);
1908 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1910 // Here DW_AT_data_member_location points to the anonymous
1911 // field that includes this bit field.
1912 OffsetInBytes = FieldOffset >> 3;
1914 // This is not a bitfield.
1915 OffsetInBytes = DT.getOffsetInBits() >> 3;
1917 if (DD->getDwarfVersion() <= 2) {
1918 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1919 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1920 addUInt(MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1921 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1923 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1927 if (DT.isProtected())
1928 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1929 dwarf::DW_ACCESS_protected);
1930 else if (DT.isPrivate())
1931 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1932 dwarf::DW_ACCESS_private);
1933 // Otherwise C++ member and base classes are considered public.
1935 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1936 dwarf::DW_ACCESS_public);
1938 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1939 dwarf::DW_VIRTUALITY_virtual);
1941 // Objective-C properties.
1942 if (MDNode *PNode = DT.getObjCProperty())
1943 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1944 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1947 if (DT.isArtificial())
1948 addFlag(MemberDie, dwarf::DW_AT_artificial);
1951 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1952 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1956 // Construct the context before querying for the existence of the DIE in case
1957 // such construction creates the DIE.
1958 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1959 assert(dwarf::isType(ContextDIE->getTag()) &&
1960 "Static member should belong to a type.");
1962 DIE *StaticMemberDIE = getDIE(DT);
1963 if (StaticMemberDIE)
1964 return StaticMemberDIE;
1966 StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1968 DIType Ty = resolve(DT.getTypeDerivedFrom());
1970 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1971 addType(StaticMemberDIE, Ty);
1972 addSourceLine(StaticMemberDIE, DT);
1973 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1974 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1976 // FIXME: We could omit private if the parent is a class_type, and
1977 // public if the parent is something else.
1978 if (DT.isProtected())
1979 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1980 dwarf::DW_ACCESS_protected);
1981 else if (DT.isPrivate())
1982 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1983 dwarf::DW_ACCESS_private);
1985 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1986 dwarf::DW_ACCESS_public);
1988 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1989 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1990 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1991 addConstantFPValue(StaticMemberDIE, CFP);
1993 return StaticMemberDIE;
1996 void DwarfUnit::emitHeader(const MCSection *ASection,
1997 const MCSymbol *ASectionSym) const {
1998 Asm->OutStreamer.AddComment("DWARF version number");
1999 Asm->EmitInt16(DD->getDwarfVersion());
2000 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2001 // We share one abbreviations table across all units so it's always at the
2002 // start of the section. Use a relocatable offset where needed to ensure
2003 // linking doesn't invalidate that offset.
2004 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
2005 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2006 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2009 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
2010 // Define start line table label for each Compile Unit.
2011 MCSymbol *LineTableStartSym =
2012 Asm->GetTempSymbol("line_table_start", getUniqueID());
2013 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
2016 // Use a single line table if we are generating assembly.
2017 bool UseTheFirstCU =
2018 Asm->OutStreamer.hasRawTextSupport() || (getUniqueID() == 0);
2020 stmtListIndex = UnitDie->getValues().size();
2022 // DW_AT_stmt_list is a offset of line number information for this
2023 // compile unit in debug_line section. For split dwarf this is
2024 // left in the skeleton CU and so not included.
2025 // The line table entries are not always emitted in assembly, so it
2026 // is not okay to use line_table_start here.
2027 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2028 addSectionLabel(UnitDie.get(), dwarf::DW_AT_stmt_list,
2029 UseTheFirstCU ? DwarfLineSectionSym : LineTableStartSym);
2030 else if (UseTheFirstCU)
2031 addSectionOffset(UnitDie.get(), dwarf::DW_AT_stmt_list, 0);
2033 addSectionDelta(UnitDie.get(), dwarf::DW_AT_stmt_list, LineTableStartSym,
2034 DwarfLineSectionSym);
2037 void DwarfCompileUnit::applyStmtList(DIE &D) {
2038 D.addValue(dwarf::DW_AT_stmt_list,
2039 UnitDie->getAbbrev().getData()[stmtListIndex].getForm(),
2040 UnitDie->getValues()[stmtListIndex]);
2043 void DwarfTypeUnit::emitHeader(const MCSection *ASection,
2044 const MCSymbol *ASectionSym) const {
2045 DwarfUnit::emitHeader(ASection, ASectionSym);
2046 Asm->OutStreamer.AddComment("Type Signature");
2047 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
2048 Asm->OutStreamer.AddComment("Type DIE Offset");
2049 // In a skeleton type unit there is no type DIE so emit a zero offset.
2050 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
2051 sizeof(Ty->getOffset()));
2054 void DwarfTypeUnit::initSection(const MCSection *Section) {
2055 assert(!this->Section);
2056 this->Section = Section;
2057 // Since each type unit is contained in its own COMDAT section, the begin
2058 // label and the section label are the same. Using the begin label emission in
2059 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
2060 // the only other alternative of lazily constructing start-of-section labels
2061 // and storing a mapping in DwarfDebug (or AsmPrinter).
2062 this->SectionSym = this->LabelBegin =
2063 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
2065 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
2066 this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());