1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
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 "DwarfCompileUnit.h"
17 #include "DwarfAccelTable.h"
18 #include "DwarfDebug.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/DIBuilder.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/MC/MCSection.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
32 #include "llvm/Support/CommandLine.h"
36 static cl::opt<bool> GenerateTypeUnits("generate-type-units", cl::Hidden,
37 cl::desc("Generate DWARF4 type units."),
40 /// CompileUnit - Compile unit constructor.
41 CompileUnit::CompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
42 AsmPrinter *A, DwarfDebug *DW, DwarfUnits *DWU)
43 : UniqueID(UID), Node(Node), Language(Node.getLanguage()), CUDie(D),
44 DebugInfoOffset(0), Asm(A), DD(DW), DU(DWU), IndexTyDie(0) {
45 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
49 CompileUnit::CompileUnit(unsigned UID, DIE *D, uint16_t Language, AsmPrinter *A,
50 DwarfDebug *DD, DwarfUnits *DU)
51 : UniqueID(UID), Node(NULL), Language(Language), CUDie(D),
52 DebugInfoOffset(0), Asm(A), DD(DD), DU(DU), IndexTyDie(0) {
53 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
56 /// ~CompileUnit - Destructor for compile unit.
57 CompileUnit::~CompileUnit() {
58 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
59 DIEBlocks[j]->~DIEBlock();
62 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
63 /// information entry.
64 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
65 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
69 /// getDefaultLowerBound - Return the default lower bound for an array. If the
70 /// DWARF version doesn't handle the language, return -1.
71 int64_t CompileUnit::getDefaultLowerBound() const {
72 switch (getLanguage()) {
76 case dwarf::DW_LANG_C89:
77 case dwarf::DW_LANG_C99:
78 case dwarf::DW_LANG_C:
79 case dwarf::DW_LANG_C_plus_plus:
80 case dwarf::DW_LANG_ObjC:
81 case dwarf::DW_LANG_ObjC_plus_plus:
84 case dwarf::DW_LANG_Fortran77:
85 case dwarf::DW_LANG_Fortran90:
86 case dwarf::DW_LANG_Fortran95:
89 // The languages below have valid values only if the DWARF version >= 4.
90 case dwarf::DW_LANG_Java:
91 case dwarf::DW_LANG_Python:
92 case dwarf::DW_LANG_UPC:
93 case dwarf::DW_LANG_D:
94 if (dwarf::DWARF_VERSION >= 4)
98 case dwarf::DW_LANG_Ada83:
99 case dwarf::DW_LANG_Ada95:
100 case dwarf::DW_LANG_Cobol74:
101 case dwarf::DW_LANG_Cobol85:
102 case dwarf::DW_LANG_Modula2:
103 case dwarf::DW_LANG_Pascal83:
104 case dwarf::DW_LANG_PLI:
105 if (dwarf::DWARF_VERSION >= 4)
113 /// Check whether the DIE for this MDNode can be shared across CUs.
114 static bool isShareableAcrossCUs(DIDescriptor D) {
115 // When the MDNode can be part of the type system, the DIE can be shared
117 // Combining type units and cross-CU DIE sharing is lower value (since
118 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
119 // level already) but may be implementable for some value in projects
120 // building multiple independent libraries with LTO and then linking those
122 return (D.isType() ||
123 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
127 /// getDIE - Returns the debug information entry map slot for the
128 /// specified debug variable. We delegate the request to DwarfDebug
129 /// when the DIE for this MDNode can be shared across CUs. The mappings
130 /// will be kept in DwarfDebug for shareable DIEs.
131 DIE *CompileUnit::getDIE(DIDescriptor D) const {
132 if (isShareableAcrossCUs(D))
133 return DD->getDIE(D);
134 return MDNodeToDieMap.lookup(D);
137 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
138 /// when the DIE for this MDNode can be shared across CUs. The mappings
139 /// will be kept in DwarfDebug for shareable DIEs.
140 void CompileUnit::insertDIE(DIDescriptor Desc, DIE *D) {
141 if (isShareableAcrossCUs(Desc)) {
142 DD->insertDIE(Desc, D);
145 MDNodeToDieMap.insert(std::make_pair(Desc, D));
148 /// addFlag - Add a flag that is true.
149 void CompileUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
150 if (DD->getDwarfVersion() >= 4)
151 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
153 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
156 /// addUInt - Add an unsigned integer attribute data and value.
158 void CompileUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
159 Optional<dwarf::Form> Form, uint64_t Integer) {
161 Form = DIEInteger::BestForm(false, Integer);
162 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
164 Die->addValue(Attribute, *Form, Value);
167 void CompileUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
168 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
171 /// addSInt - Add an signed integer attribute data and value.
173 void CompileUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
174 Optional<dwarf::Form> Form, int64_t Integer) {
176 Form = DIEInteger::BestForm(true, Integer);
177 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
178 Die->addValue(Attribute, *Form, Value);
181 void CompileUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
183 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
186 /// addString - Add a string attribute data and value. We always emit a
187 /// reference to the string pool instead of immediate strings so that DIEs have
188 /// more predictable sizes. In the case of split dwarf we emit an index
189 /// into another table which gets us the static offset into the string
191 void CompileUnit::addString(DIE *Die, dwarf::Attribute Attribute,
195 if (!DD->useSplitDwarf()) {
196 MCSymbol *Symb = DU->getStringPoolEntry(String);
197 if (Asm->needsRelocationsForDwarfStringPool())
198 Value = new (DIEValueAllocator) DIELabel(Symb);
200 MCSymbol *StringPool = DU->getStringPoolSym();
201 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
203 Form = dwarf::DW_FORM_strp;
205 unsigned idx = DU->getStringPoolIndex(String);
206 Value = new (DIEValueAllocator) DIEInteger(idx);
207 Form = dwarf::DW_FORM_GNU_str_index;
209 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
210 Die->addValue(Attribute, Form, Str);
213 /// addLocalString - Add a string attribute data and value. This is guaranteed
214 /// to be in the local string pool instead of indirected.
215 void CompileUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
217 MCSymbol *Symb = DU->getStringPoolEntry(String);
219 if (Asm->needsRelocationsForDwarfStringPool())
220 Value = new (DIEValueAllocator) DIELabel(Symb);
222 MCSymbol *StringPool = DU->getStringPoolSym();
223 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
225 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
228 /// addExpr - Add a Dwarf expression attribute data and value.
230 void CompileUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
231 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
232 Die->addValue((dwarf::Attribute)0, Form, Value);
235 /// addLabel - Add a Dwarf label attribute data and value.
237 void CompileUnit::addLabel(DIE *Die, dwarf::Attribute Attribute,
238 dwarf::Form Form, const MCSymbol *Label) {
239 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
240 Die->addValue(Attribute, Form, Value);
243 void CompileUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
244 const MCSymbol *Label) {
245 addLabel(Die, (dwarf::Attribute)0, Form, Label);
248 /// addSectionLabel - Add a Dwarf section label attribute data and value.
250 void CompileUnit::addSectionLabel(DIE *Die, dwarf::Attribute Attribute,
251 const MCSymbol *Label) {
252 if (DD->getDwarfVersion() >= 4)
253 addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label);
255 addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label);
258 /// addSectionOffset - Add an offset into a section attribute data and value.
260 void CompileUnit::addSectionOffset(DIE *Die, dwarf::Attribute Attribute,
262 if (DD->getDwarfVersion() >= 4)
263 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
265 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
268 /// addLabelAddress - Add a dwarf label attribute data and value using
269 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
271 void CompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
274 DD->addArangeLabel(SymbolCU(this, Label));
276 if (!DD->useSplitDwarf()) {
278 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
279 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
281 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
282 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
285 unsigned idx = DU->getAddrPoolIndex(Label);
286 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
287 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
291 /// addOpAddress - Add a dwarf op address data and value using the
292 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
294 void CompileUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
295 if (!DD->useSplitDwarf()) {
296 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
297 addLabel(Die, dwarf::DW_FORM_udata, Sym);
299 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
300 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
304 /// addSectionDelta - Add a section label delta attribute data and value.
306 void CompileUnit::addSectionDelta(DIE *Die, dwarf::Attribute Attribute,
307 const MCSymbol *Hi, const MCSymbol *Lo) {
308 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
309 if (DD->getDwarfVersion() >= 4)
310 Die->addValue(Attribute, dwarf::DW_FORM_sec_offset, Value);
312 Die->addValue(Attribute, dwarf::DW_FORM_data4, Value);
315 /// addDIEEntry - Add a DIE attribute data and value.
317 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
319 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
322 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
324 const DIE *DieCU = Die->getUnitOrNull();
325 const DIE *EntryCU = Entry->getEntry()->getUnitOrNull();
327 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
330 EntryCU = getCUDie();
331 Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
332 : dwarf::DW_FORM_ref_addr,
336 /// Create a DIE with the given Tag, add the DIE to its parent, and
337 /// call insertDIE if MD is not null.
338 DIE *CompileUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
339 DIE *Die = new DIE(Tag);
340 Parent.addChild(Die);
346 /// addBlock - Add block data.
348 void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
350 Block->ComputeSize(Asm);
351 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
352 Die->addValue(Attribute, Block->BestForm(), Block);
355 /// addSourceLine - Add location information to specified debug information
357 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
362 unsigned Line = V.getLineNumber();
366 DD->getOrCreateSourceID(V.getContext().getFilename(),
367 V.getContext().getDirectory(), getUniqueID());
368 assert(FileID && "Invalid file id");
369 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
370 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
373 /// addSourceLine - Add location information to specified debug information
375 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
376 // Verify global variable.
377 if (!G.isGlobalVariable())
380 unsigned Line = G.getLineNumber();
384 DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
385 assert(FileID && "Invalid file id");
386 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
387 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
390 /// addSourceLine - Add location information to specified debug information
392 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
393 // Verify subprogram.
394 if (!SP.isSubprogram())
397 // If the line number is 0, don't add it.
398 unsigned Line = SP.getLineNumber();
402 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
404 assert(FileID && "Invalid file id");
405 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
406 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
409 /// addSourceLine - Add location information to specified debug information
411 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
416 unsigned Line = Ty.getLineNumber();
419 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
421 assert(FileID && "Invalid file id");
422 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
423 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
426 /// addSourceLine - Add location information to specified debug information
428 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
430 if (!Ty.isObjCProperty())
433 unsigned Line = Ty.getLineNumber();
436 DIFile File = Ty.getFile();
437 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
438 File.getDirectory(), getUniqueID());
439 assert(FileID && "Invalid file id");
440 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
441 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
444 /// addSourceLine - Add location information to specified debug information
446 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
451 unsigned Line = NS.getLineNumber();
454 StringRef FN = NS.getFilename();
457 DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
458 assert(FileID && "Invalid file id");
459 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
460 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
463 /// addVariableAddress - Add DW_AT_location attribute for a
464 /// DbgVariable based on provided MachineLocation.
465 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
466 MachineLocation Location) {
467 if (DV.variableHasComplexAddress())
468 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
469 else if (DV.isBlockByrefVariable())
470 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
472 addAddress(Die, dwarf::DW_AT_location, Location,
473 DV.getVariable().isIndirect());
476 /// addRegisterOp - Add register operand.
477 void CompileUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
478 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
479 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
481 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
483 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
484 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
488 /// addRegisterOffset - Add register offset.
489 void CompileUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
491 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
492 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
493 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
494 if (Reg == TRI->getFrameRegister(*Asm->MF))
495 // If variable offset is based in frame register then use fbreg.
496 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
498 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
500 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
501 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
503 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
506 /// addAddress - Add an address attribute to a die based on the location
508 void CompileUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
509 const MachineLocation &Location, bool Indirect) {
510 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
512 if (Location.isReg() && !Indirect)
513 addRegisterOp(Block, Location.getReg());
515 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
516 if (Indirect && !Location.isReg()) {
517 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
521 // Now attach the location information to the DIE.
522 addBlock(Die, Attribute, Block);
525 /// addComplexAddress - Start with the address based on the location provided,
526 /// and generate the DWARF information necessary to find the actual variable
527 /// given the extra address information encoded in the DIVariable, starting from
528 /// the starting location. Add the DWARF information to the die.
530 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
531 dwarf::Attribute Attribute,
532 const MachineLocation &Location) {
533 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
534 unsigned N = DV.getNumAddrElements();
536 if (Location.isReg()) {
537 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
538 // If first address element is OpPlus then emit
539 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
540 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
543 addRegisterOp(Block, Location.getReg());
545 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
548 uint64_t Element = DV.getAddrElement(i);
549 if (Element == DIBuilder::OpPlus) {
550 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
551 addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
552 } else if (Element == DIBuilder::OpDeref) {
553 if (!Location.isReg())
554 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
556 llvm_unreachable("unknown DIBuilder Opcode");
559 // Now attach the location information to the DIE.
560 addBlock(Die, Attribute, Block);
563 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
564 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
565 gives the variable VarName either the struct, or a pointer to the struct, as
566 its type. This is necessary for various behind-the-scenes things the
567 compiler needs to do with by-reference variables in Blocks.
569 However, as far as the original *programmer* is concerned, the variable
570 should still have type 'SomeType', as originally declared.
572 The function getBlockByrefType dives into the __Block_byref_x_VarName
573 struct to find the original type of the variable, which is then assigned to
574 the variable's Debug Information Entry as its real type. So far, so good.
575 However now the debugger will expect the variable VarName to have the type
576 SomeType. So we need the location attribute for the variable to be an
577 expression that explains to the debugger how to navigate through the
578 pointers and struct to find the actual variable of type SomeType.
580 The following function does just that. We start by getting
581 the "normal" location for the variable. This will be the location
582 of either the struct __Block_byref_x_VarName or the pointer to the
583 struct __Block_byref_x_VarName.
585 The struct will look something like:
587 struct __Block_byref_x_VarName {
589 struct __Block_byref_x_VarName *forwarding;
590 ... <various other fields>
592 ... <maybe more fields>
595 If we are given the struct directly (as our starting point) we
596 need to tell the debugger to:
598 1). Add the offset of the forwarding field.
600 2). Follow that pointer to get the real __Block_byref_x_VarName
601 struct to use (the real one may have been copied onto the heap).
603 3). Add the offset for the field VarName, to find the actual variable.
605 If we started with a pointer to the struct, then we need to
606 dereference that pointer first, before the other steps.
607 Translating this into DWARF ops, we will need to append the following
608 to the current location description for the variable:
610 DW_OP_deref -- optional, if we start with a pointer
611 DW_OP_plus_uconst <forward_fld_offset>
613 DW_OP_plus_uconst <varName_fld_offset>
615 That is what this function does. */
617 /// addBlockByrefAddress - Start with the address based on the location
618 /// provided, and generate the DWARF information necessary to find the
619 /// actual Block variable (navigating the Block struct) based on the
620 /// starting location. Add the DWARF information to the die. For
621 /// more information, read large comment just above here.
623 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
624 dwarf::Attribute Attribute,
625 const MachineLocation &Location) {
626 DIType Ty = DV.getType();
628 uint16_t Tag = Ty.getTag();
629 bool isPointer = false;
631 StringRef varName = DV.getName();
633 if (Tag == dwarf::DW_TAG_pointer_type) {
634 DIDerivedType DTy(Ty);
635 TmpTy = resolve(DTy.getTypeDerivedFrom());
639 DICompositeType blockStruct(TmpTy);
641 // Find the __forwarding field and the variable field in the __Block_byref
643 DIArray Fields = blockStruct.getTypeArray();
644 DIDerivedType varField;
645 DIDerivedType forwardingField;
647 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
648 DIDerivedType DT(Fields.getElement(i));
649 StringRef fieldName = DT.getName();
650 if (fieldName == "__forwarding")
651 forwardingField = DT;
652 else if (fieldName == varName)
656 // Get the offsets for the forwarding field and the variable field.
657 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
658 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
660 // Decode the original location, and use that as the start of the byref
661 // variable's location.
662 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
664 if (Location.isReg())
665 addRegisterOp(Block, Location.getReg());
667 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
669 // If we started with a pointer to the __Block_byref... struct, then
670 // the first thing we need to do is dereference the pointer (DW_OP_deref).
672 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
674 // Next add the offset for the '__forwarding' field:
675 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
676 // adding the offset if it's 0.
677 if (forwardingFieldOffset > 0) {
678 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
679 addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
682 // Now dereference the __forwarding field to get to the real __Block_byref
683 // struct: DW_OP_deref.
684 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
686 // Now that we've got the real __Block_byref... struct, add the offset
687 // for the variable's field to get to the location of the actual variable:
688 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
689 if (varFieldOffset > 0) {
690 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
691 addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
694 // Now attach the location information to the DIE.
695 addBlock(Die, Attribute, Block);
698 /// isTypeSigned - Return true if the type is signed.
699 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
700 if (Ty.isDerivedType())
701 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
703 if (Ty.isBasicType())
704 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
705 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
706 *SizeInBits = Ty.getSizeInBits();
712 /// Return true if type encoding is unsigned.
713 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
714 DIDerivedType DTy(Ty);
715 if (DTy.isDerivedType())
716 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
719 if (BTy.isBasicType()) {
720 unsigned Encoding = BTy.getEncoding();
721 if (Encoding == dwarf::DW_ATE_unsigned ||
722 Encoding == dwarf::DW_ATE_unsigned_char ||
723 Encoding == dwarf::DW_ATE_boolean)
729 /// If this type is derived from a base type then return base type size.
730 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
731 unsigned Tag = Ty.getTag();
733 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
734 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
735 Tag != dwarf::DW_TAG_restrict_type)
736 return Ty.getSizeInBits();
738 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
740 // If this type is not derived from any type then take conservative approach.
741 if (!BaseType.isValid())
742 return Ty.getSizeInBits();
744 // If this is a derived type, go ahead and get the base type, unless it's a
745 // reference then it's just the size of the field. Pointer types have no need
746 // of this since they're a different type of qualification on the type.
747 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
748 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
749 return Ty.getSizeInBits();
751 if (BaseType.isDerivedType())
752 return getBaseTypeSize(DD, DIDerivedType(BaseType));
754 return BaseType.getSizeInBits();
757 /// addConstantValue - Add constant value entry in variable DIE.
758 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
760 // FIXME: This is a bit conservative/simple - it emits negative values at
761 // their maximum bit width which is a bit unfortunate (& doesn't prefer
762 // udata/sdata over dataN as suggested by the DWARF spec)
763 assert(MO.isImm() && "Invalid machine operand!");
765 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
768 // If we're a signed constant definitely use sdata.
769 if (SignedConstant) {
770 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
774 // Else use data for now unless it's larger than we can deal with.
775 switch (SizeInBits) {
777 Form = dwarf::DW_FORM_data1;
780 Form = dwarf::DW_FORM_data2;
783 Form = dwarf::DW_FORM_data4;
786 Form = dwarf::DW_FORM_data8;
789 Form = dwarf::DW_FORM_udata;
790 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
793 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
796 /// addConstantFPValue - Add constant value entry in variable DIE.
797 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
798 assert(MO.isFPImm() && "Invalid machine operand!");
799 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
800 APFloat FPImm = MO.getFPImm()->getValueAPF();
802 // Get the raw data form of the floating point.
803 const APInt FltVal = FPImm.bitcastToAPInt();
804 const char *FltPtr = (const char *)FltVal.getRawData();
806 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
807 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
808 int Incr = (LittleEndian ? 1 : -1);
809 int Start = (LittleEndian ? 0 : NumBytes - 1);
810 int Stop = (LittleEndian ? NumBytes : -1);
812 // Output the constant to DWARF one byte at a time.
813 for (; Start != Stop; Start += Incr)
814 addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
816 addBlock(Die, dwarf::DW_AT_const_value, Block);
819 /// addConstantFPValue - Add constant value entry in variable DIE.
820 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
821 // Pass this down to addConstantValue as an unsigned bag of bits.
822 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
825 /// addConstantValue - Add constant value entry in variable DIE.
826 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
828 addConstantValue(Die, CI->getValue(), Unsigned);
831 // addConstantValue - Add constant value entry in variable DIE.
832 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
833 unsigned CIBitWidth = Val.getBitWidth();
834 if (CIBitWidth <= 64) {
835 // If we're a signed constant definitely use sdata.
837 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
842 // Else use data for now unless it's larger than we can deal with.
844 switch (CIBitWidth) {
846 Form = dwarf::DW_FORM_data1;
849 Form = dwarf::DW_FORM_data2;
852 Form = dwarf::DW_FORM_data4;
855 Form = dwarf::DW_FORM_data8;
858 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
862 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
866 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
868 // Get the raw data form of the large APInt.
869 const uint64_t *Ptr64 = Val.getRawData();
871 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
872 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
874 // Output the constant to DWARF one byte at a time.
875 for (int i = 0; i < NumBytes; i++) {
878 c = Ptr64[i / 8] >> (8 * (i & 7));
880 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
881 addUInt(Block, dwarf::DW_FORM_data1, c);
884 addBlock(Die, dwarf::DW_AT_const_value, Block);
887 /// addTemplateParams - Add template parameters into buffer.
888 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
889 // Add template parameters.
890 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
891 DIDescriptor Element = TParams.getElement(i);
892 if (Element.isTemplateTypeParameter())
893 constructTemplateTypeParameterDIE(Buffer,
894 DITemplateTypeParameter(Element));
895 else if (Element.isTemplateValueParameter())
896 constructTemplateValueParameterDIE(Buffer,
897 DITemplateValueParameter(Element));
901 /// getOrCreateContextDIE - Get context owner's DIE.
902 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
903 if (!Context || Context.isFile())
905 if (Context.isType())
906 return getOrCreateTypeDIE(DIType(Context));
907 if (Context.isNameSpace())
908 return getOrCreateNameSpace(DINameSpace(Context));
909 if (Context.isSubprogram())
910 return getOrCreateSubprogramDIE(DISubprogram(Context));
911 return getDIE(Context);
914 DIE *CompileUnit::createTypeDIE(DICompositeType Ty) {
915 DIScope Context = resolve(Ty.getContext());
916 DIE *ContextDIE = getOrCreateContextDIE(Context);
918 DIE *TyDIE = getDIE(Ty);
923 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
925 constructTypeDIE(*TyDIE, Ty);
927 updateAcceleratorTables(Context, Ty, TyDIE);
931 /// Return true if the type is appropriately scoped to be contained inside
932 /// its own type unit.
933 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
934 DIScope Parent = DD->resolve(Ty.getContext());
936 // Don't generate a hash for anything scoped inside a function.
937 if (Parent.isSubprogram())
939 Parent = DD->resolve(Parent.getContext());
944 /// Return true if the type should be split out into a type unit.
945 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
946 if (!GenerateTypeUnits)
949 uint16_t Tag = CTy.getTag();
952 case dwarf::DW_TAG_structure_type:
953 case dwarf::DW_TAG_union_type:
954 case dwarf::DW_TAG_enumeration_type:
955 case dwarf::DW_TAG_class_type:
956 // If this is a class, structure, union, or enumeration type
957 // that is a definition (not a declaration), and not scoped
958 // inside a function then separate this out as a type unit.
959 return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
965 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
967 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
974 // Construct the context before querying for the existence of the DIE in case
975 // such construction creates the DIE.
976 DIScope Context = resolve(Ty.getContext());
977 DIE *ContextDIE = getOrCreateContextDIE(Context);
980 DIE *TyDIE = getDIE(Ty);
985 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
987 if (Ty.isBasicType())
988 constructTypeDIE(*TyDIE, DIBasicType(Ty));
989 else if (Ty.isCompositeType()) {
990 DICompositeType CTy(Ty);
991 if (shouldCreateTypeUnit(CTy, DD)) {
992 DD->addTypeUnitType(getLanguage(), TyDIE, CTy);
993 // Skip updating the accellerator tables since this is not the full type
996 constructTypeDIE(*TyDIE, CTy);
998 assert(Ty.isDerivedType() && "Unknown kind of DIType");
999 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
1002 updateAcceleratorTables(Context, Ty, TyDIE);
1007 void CompileUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
1009 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
1010 bool IsImplementation = 0;
1011 if (Ty.isCompositeType()) {
1012 DICompositeType CT(Ty);
1013 // A runtime language of 0 actually means C/C++ and that any
1014 // non-negative value is some version of Objective-C/C++.
1015 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
1017 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
1018 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
1020 if (!Context || Context.isCompileUnit() || Context.isFile() ||
1021 Context.isNameSpace())
1022 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = TyDIE;
1026 /// addType - Add a new type attribute to the specified entity.
1027 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
1028 assert(Ty && "Trying to add a type that doesn't exist?");
1030 // Check for pre-existence.
1031 DIEEntry *Entry = getDIEEntry(Ty);
1032 // If it exists then use the existing value.
1034 addDIEEntry(Entity, Attribute, Entry);
1039 DIE *Buffer = getOrCreateTypeDIE(Ty);
1042 Entry = createDIEEntry(Buffer);
1043 insertDIEEntry(Ty, Entry);
1044 addDIEEntry(Entity, Attribute, Entry);
1047 // Accelerator table mutators - add each name along with its companion
1048 // DIE to the proper table while ensuring that the name that we're going
1049 // to reference is in the string table. We do this since the names we
1050 // add may not only be identical to the names in the DIE.
1051 void CompileUnit::addAccelName(StringRef Name, const DIE *Die) {
1052 DU->getStringPoolEntry(Name);
1053 std::vector<const DIE *> &DIEs = AccelNames[Name];
1054 DIEs.push_back(Die);
1057 void CompileUnit::addAccelObjC(StringRef Name, const DIE *Die) {
1058 DU->getStringPoolEntry(Name);
1059 std::vector<const DIE *> &DIEs = AccelObjC[Name];
1060 DIEs.push_back(Die);
1063 void CompileUnit::addAccelNamespace(StringRef Name, const DIE *Die) {
1064 DU->getStringPoolEntry(Name);
1065 std::vector<const DIE *> &DIEs = AccelNamespace[Name];
1066 DIEs.push_back(Die);
1069 void CompileUnit::addAccelType(StringRef Name,
1070 std::pair<const DIE *, unsigned> Die) {
1071 DU->getStringPoolEntry(Name);
1072 std::vector<std::pair<const DIE *, unsigned> > &DIEs = AccelTypes[Name];
1073 DIEs.push_back(Die);
1076 /// addGlobalName - Add a new global name to the compile unit.
1077 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
1078 std::string FullName = getParentContextString(Context) + Name.str();
1079 GlobalNames[FullName] = Die;
1082 /// getParentContextString - Walks the metadata parent chain in a language
1083 /// specific manner (using the compile unit language) and returns
1084 /// it as a string. This is done at the metadata level because DIEs may
1085 /// not currently have been added to the parent context and walking the
1086 /// DIEs looking for names is more expensive than walking the metadata.
1087 std::string CompileUnit::getParentContextString(DIScope Context) const {
1091 // FIXME: Decide whether to implement this for non-C++ languages.
1092 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1096 SmallVector<DIScope, 1> Parents;
1097 while (!Context.isCompileUnit()) {
1098 Parents.push_back(Context);
1099 if (Context.getContext())
1100 Context = resolve(Context.getContext());
1102 // Structure, etc types will have a NULL context if they're at the top
1107 // Reverse iterate over our list to go from the outermost construct to the
1109 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1113 StringRef Name = Ctx.getName();
1114 if (!Name.empty()) {
1122 /// constructTypeDIE - Construct basic type die from DIBasicType.
1123 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1124 // Get core information.
1125 StringRef Name = BTy.getName();
1126 // Add name if not anonymous or intermediate type.
1128 addString(&Buffer, dwarf::DW_AT_name, Name);
1130 // An unspecified type only has a name attribute.
1131 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1134 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1137 uint64_t Size = BTy.getSizeInBits() >> 3;
1138 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1141 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1142 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1143 // Get core information.
1144 StringRef Name = DTy.getName();
1145 uint64_t Size = DTy.getSizeInBits() >> 3;
1146 uint16_t Tag = Buffer.getTag();
1148 // Map to main type, void will not have a type.
1149 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1151 addType(&Buffer, FromTy);
1153 // Add name if not anonymous or intermediate type.
1155 addString(&Buffer, dwarf::DW_AT_name, Name);
1157 // Add size if non-zero (derived types might be zero-sized.)
1158 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1159 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1161 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1162 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1163 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1164 // Add source line info if available and TyDesc is not a forward declaration.
1165 if (!DTy.isForwardDecl())
1166 addSourceLine(&Buffer, DTy);
1169 /// constructTypeDIE - Construct type DIE from DICompositeType.
1170 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1171 // Add name if not anonymous or intermediate type.
1172 StringRef Name = CTy.getName();
1174 uint64_t Size = CTy.getSizeInBits() >> 3;
1175 uint16_t Tag = Buffer.getTag();
1178 case dwarf::DW_TAG_array_type:
1179 constructArrayTypeDIE(Buffer, CTy);
1181 case dwarf::DW_TAG_enumeration_type:
1182 constructEnumTypeDIE(Buffer, CTy);
1184 case dwarf::DW_TAG_subroutine_type: {
1185 // Add return type. A void return won't have a type.
1186 DIArray Elements = CTy.getTypeArray();
1187 DIType RTy(Elements.getElement(0));
1189 addType(&Buffer, RTy);
1191 bool isPrototyped = true;
1193 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1194 DIDescriptor Ty = Elements.getElement(i);
1195 if (Ty.isUnspecifiedParameter()) {
1196 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1197 isPrototyped = false;
1199 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1200 addType(Arg, DIType(Ty));
1201 if (DIType(Ty).isArtificial())
1202 addFlag(Arg, dwarf::DW_AT_artificial);
1205 // Add prototype flag if we're dealing with a C language and the
1206 // function has been prototyped.
1207 uint16_t Language = getLanguage();
1209 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1210 Language == dwarf::DW_LANG_ObjC))
1211 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1213 case dwarf::DW_TAG_structure_type:
1214 case dwarf::DW_TAG_union_type:
1215 case dwarf::DW_TAG_class_type: {
1216 // Add elements to structure type.
1217 DIArray Elements = CTy.getTypeArray();
1218 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1219 DIDescriptor Element = Elements.getElement(i);
1220 DIE *ElemDie = NULL;
1221 if (Element.isSubprogram()) {
1222 DISubprogram SP(Element);
1223 ElemDie = getOrCreateSubprogramDIE(SP);
1224 if (SP.isProtected())
1225 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1226 dwarf::DW_ACCESS_protected);
1227 else if (SP.isPrivate())
1228 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1229 dwarf::DW_ACCESS_private);
1231 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1232 dwarf::DW_ACCESS_public);
1233 if (SP.isExplicit())
1234 addFlag(ElemDie, dwarf::DW_AT_explicit);
1235 } else if (Element.isDerivedType()) {
1236 DIDerivedType DDTy(Element);
1237 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1238 ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1239 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1240 dwarf::DW_AT_friend);
1241 } else if (DDTy.isStaticMember()) {
1242 getOrCreateStaticMemberDIE(DDTy);
1244 constructMemberDIE(Buffer, DDTy);
1246 } else if (Element.isObjCProperty()) {
1247 DIObjCProperty Property(Element);
1248 ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1249 StringRef PropertyName = Property.getObjCPropertyName();
1250 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1251 addType(ElemDie, Property.getType());
1252 addSourceLine(ElemDie, Property);
1253 StringRef GetterName = Property.getObjCPropertyGetterName();
1254 if (!GetterName.empty())
1255 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1256 StringRef SetterName = Property.getObjCPropertySetterName();
1257 if (!SetterName.empty())
1258 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1259 unsigned PropertyAttributes = 0;
1260 if (Property.isReadOnlyObjCProperty())
1261 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1262 if (Property.isReadWriteObjCProperty())
1263 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1264 if (Property.isAssignObjCProperty())
1265 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1266 if (Property.isRetainObjCProperty())
1267 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1268 if (Property.isCopyObjCProperty())
1269 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1270 if (Property.isNonAtomicObjCProperty())
1271 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1272 if (PropertyAttributes)
1273 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1274 PropertyAttributes);
1276 DIEEntry *Entry = getDIEEntry(Element);
1278 Entry = createDIEEntry(ElemDie);
1279 insertDIEEntry(Element, Entry);
1285 if (CTy.isAppleBlockExtension())
1286 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1288 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1290 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1291 getOrCreateTypeDIE(ContainingType));
1293 if (CTy.isObjcClassComplete())
1294 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1296 // Add template parameters to a class, structure or union types.
1297 // FIXME: The support isn't in the metadata for this yet.
1298 if (Tag == dwarf::DW_TAG_class_type ||
1299 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1300 addTemplateParams(Buffer, CTy.getTemplateParams());
1308 // Add name if not anonymous or intermediate type.
1310 addString(&Buffer, dwarf::DW_AT_name, Name);
1312 if (Tag == dwarf::DW_TAG_enumeration_type ||
1313 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1314 Tag == dwarf::DW_TAG_union_type) {
1315 // Add size if non-zero (derived types might be zero-sized.)
1316 // TODO: Do we care about size for enum forward declarations?
1318 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1319 else if (!CTy.isForwardDecl())
1320 // Add zero size if it is not a forward declaration.
1321 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1323 // If we're a forward decl, say so.
1324 if (CTy.isForwardDecl())
1325 addFlag(&Buffer, dwarf::DW_AT_declaration);
1327 // Add source line info if available.
1328 if (!CTy.isForwardDecl())
1329 addSourceLine(&Buffer, CTy);
1331 // No harm in adding the runtime language to the declaration.
1332 unsigned RLang = CTy.getRunTimeLang();
1334 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1339 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1340 /// DITemplateTypeParameter.
1342 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1343 DITemplateTypeParameter TP) {
1345 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1346 // Add the type if it exists, it could be void and therefore no type.
1348 addType(ParamDIE, resolve(TP.getType()));
1349 if (!TP.getName().empty())
1350 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1353 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1354 /// DITemplateValueParameter.
1356 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1357 DITemplateValueParameter VP) {
1358 DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1360 // Add the type if there is one, template template and template parameter
1361 // packs will not have a type.
1362 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1363 addType(ParamDIE, resolve(VP.getType()));
1364 if (!VP.getName().empty())
1365 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1366 if (Value *Val = VP.getValue()) {
1367 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1368 addConstantValue(ParamDIE, CI,
1369 isUnsignedDIType(DD, resolve(VP.getType())));
1370 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1371 // For declaration non-type template parameters (such as global values and
1373 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1374 addOpAddress(Block, Asm->getSymbol(GV));
1375 // Emit DW_OP_stack_value to use the address as the immediate value of the
1376 // parameter, rather than a pointer to it.
1377 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1378 addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1379 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1380 assert(isa<MDString>(Val));
1381 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1382 cast<MDString>(Val)->getString());
1383 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1384 assert(isa<MDNode>(Val));
1385 DIArray A(cast<MDNode>(Val));
1386 addTemplateParams(*ParamDIE, A);
1391 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1392 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1393 // Construct the context before querying for the existence of the DIE in case
1394 // such construction creates the DIE.
1395 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1397 DIE *NDie = getDIE(NS);
1400 NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1402 if (!NS.getName().empty()) {
1403 addString(NDie, dwarf::DW_AT_name, NS.getName());
1404 addAccelNamespace(NS.getName(), NDie);
1405 addGlobalName(NS.getName(), NDie, NS.getContext());
1407 addAccelNamespace("(anonymous namespace)", NDie);
1408 addSourceLine(NDie, NS);
1412 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1413 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1414 // Construct the context before querying for the existence of the DIE in case
1415 // such construction creates the DIE (as is the case for member function
1417 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1419 DIE *SPDie = getDIE(SP);
1423 DISubprogram SPDecl = SP.getFunctionDeclaration();
1424 if (SPDecl.isSubprogram())
1425 // Add subprogram definitions to the CU die directly.
1426 ContextDIE = CUDie.get();
1428 // DW_TAG_inlined_subroutine may refer to this DIE.
1429 SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1431 DIE *DeclDie = NULL;
1432 if (SPDecl.isSubprogram())
1433 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1435 // Add function template parameters.
1436 addTemplateParams(*SPDie, SP.getTemplateParams());
1438 // If this DIE is going to refer declaration info using AT_specification
1439 // then there is no need to add other attributes.
1441 // Refer function declaration directly.
1442 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1447 // Add the linkage name if we have one.
1448 StringRef LinkageName = SP.getLinkageName();
1449 if (!LinkageName.empty())
1450 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1451 GlobalValue::getRealLinkageName(LinkageName));
1453 // Constructors and operators for anonymous aggregates do not have names.
1454 if (!SP.getName().empty())
1455 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1457 addSourceLine(SPDie, SP);
1459 // Add the prototype if we have a prototype and we have a C like
1461 uint16_t Language = getLanguage();
1462 if (SP.isPrototyped() &&
1463 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1464 Language == dwarf::DW_LANG_ObjC))
1465 addFlag(SPDie, dwarf::DW_AT_prototyped);
1467 DICompositeType SPTy = SP.getType();
1468 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1469 "the type of a subprogram should be a subroutine");
1471 DIArray Args = SPTy.getTypeArray();
1472 // Add a return type. If this is a type like a C/C++ void type we don't add a
1474 if (Args.getElement(0))
1475 addType(SPDie, DIType(Args.getElement(0)));
1477 unsigned VK = SP.getVirtuality();
1479 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1480 DIEBlock *Block = getDIEBlock();
1481 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1482 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1483 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1484 ContainingTypeMap.insert(
1485 std::make_pair(SPDie, resolve(SP.getContainingType())));
1488 if (!SP.isDefinition()) {
1489 addFlag(SPDie, dwarf::DW_AT_declaration);
1491 // Add arguments. Do not add arguments for subprogram definition. They will
1492 // be handled while processing variables.
1493 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1494 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1495 DIType ATy(Args.getElement(i));
1497 if (ATy.isArtificial())
1498 addFlag(Arg, dwarf::DW_AT_artificial);
1502 if (SP.isArtificial())
1503 addFlag(SPDie, dwarf::DW_AT_artificial);
1505 if (!SP.isLocalToUnit())
1506 addFlag(SPDie, dwarf::DW_AT_external);
1508 if (SP.isOptimized())
1509 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1511 if (unsigned isa = Asm->getISAEncoding()) {
1512 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1518 // Return const expression if value is a GEP to access merged global
1520 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1521 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1522 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1523 if (!CE || CE->getNumOperands() != 3 ||
1524 CE->getOpcode() != Instruction::GetElementPtr)
1527 // First operand points to a global struct.
1528 Value *Ptr = CE->getOperand(0);
1529 if (!isa<GlobalValue>(Ptr) ||
1530 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1533 // Second operand is zero.
1534 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1535 if (!CI || !CI->isZero())
1538 // Third operand is offset.
1539 if (!isa<ConstantInt>(CE->getOperand(2)))
1545 /// createGlobalVariableDIE - create global variable DIE.
1546 void CompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1547 // Check for pre-existence.
1551 if (!GV.isGlobalVariable())
1554 DIScope GVContext = GV.getContext();
1555 DIType GTy = GV.getType();
1557 // If this is a static data member definition, some attributes belong
1558 // to the declaration DIE.
1559 DIE *VariableDIE = NULL;
1560 bool IsStaticMember = false;
1561 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1562 if (SDMDecl.Verify()) {
1563 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1564 // We need the declaration DIE that is in the static member's class.
1565 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1566 IsStaticMember = true;
1569 // If this is not a static data member definition, create the variable
1570 // DIE and add the initial set of attributes to it.
1572 // Construct the context before querying for the existence of the DIE in
1573 // case such construction creates the DIE.
1574 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1577 VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1579 // Add name and type.
1580 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1581 addType(VariableDIE, GTy);
1583 // Add scoping info.
1584 if (!GV.isLocalToUnit())
1585 addFlag(VariableDIE, dwarf::DW_AT_external);
1587 // Add line number info.
1588 addSourceLine(VariableDIE, GV);
1592 bool addToAccelTable = false;
1593 DIE *VariableSpecDIE = NULL;
1594 bool isGlobalVariable = GV.getGlobal() != NULL;
1595 if (isGlobalVariable) {
1596 addToAccelTable = true;
1597 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1598 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1599 if (GV.getGlobal()->isThreadLocal()) {
1600 // FIXME: Make this work with -gsplit-dwarf.
1601 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1602 assert((PointerSize == 4 || PointerSize == 8) &&
1603 "Add support for other sizes if necessary");
1604 const MCExpr *Expr =
1605 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1606 // Based on GCC's support for TLS:
1607 if (!DD->useSplitDwarf()) {
1608 // 1) Start with a constNu of the appropriate pointer size
1609 addUInt(Block, dwarf::DW_FORM_data1,
1610 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1611 // 2) containing the (relocated) offset of the TLS variable
1612 // within the module's TLS block.
1613 addExpr(Block, dwarf::DW_FORM_udata, Expr);
1615 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1616 addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1618 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1619 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1621 DD->addArangeLabel(SymbolCU(this, Sym));
1622 addOpAddress(Block, Sym);
1624 // Do not create specification DIE if context is either compile unit
1626 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1627 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1628 // Create specification DIE.
1629 VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie);
1630 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1631 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1632 // A static member's declaration is already flagged as such.
1633 if (!SDMDecl.Verify())
1634 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1636 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1638 // Add the linkage name.
1639 StringRef LinkageName = GV.getLinkageName();
1640 if (!LinkageName.empty())
1641 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1642 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1644 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1646 dwarf::DW_AT_MIPS_linkage_name,
1647 GlobalValue::getRealLinkageName(LinkageName));
1648 } else if (const ConstantInt *CI =
1649 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1650 // AT_const_value was added when the static member was created. To avoid
1651 // emitting AT_const_value multiple times, we only add AT_const_value when
1652 // it is not a static member.
1653 if (!IsStaticMember)
1654 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1655 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1656 addToAccelTable = true;
1657 // GV is a merged global.
1658 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1659 Value *Ptr = CE->getOperand(0);
1660 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
1661 DD->addArangeLabel(SymbolCU(this, Sym));
1662 addOpAddress(Block, Sym);
1663 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1664 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1665 addUInt(Block, dwarf::DW_FORM_udata,
1666 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1667 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1668 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1671 if (addToAccelTable) {
1672 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1673 addAccelName(GV.getName(), AddrDIE);
1675 // If the linkage name is different than the name, go ahead and output
1676 // that as well into the name table.
1677 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1678 addAccelName(GV.getLinkageName(), AddrDIE);
1681 if (!GV.isLocalToUnit())
1682 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1686 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1687 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1689 DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1690 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1692 // The LowerBound value defines the lower bounds which is typically zero for
1693 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1694 // Count == -1 then the array is unbounded and we do not emit
1695 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1696 // Count == 0, then the array has zero elements in which case we do not emit
1698 int64_t LowerBound = SR.getLo();
1699 int64_t DefaultLowerBound = getDefaultLowerBound();
1700 int64_t Count = SR.getCount();
1702 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1703 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1705 if (Count != -1 && Count != 0)
1706 // FIXME: An unbounded array should reference the expression that defines
1708 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1709 LowerBound + Count - 1);
1712 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1713 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1715 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1717 // Emit the element type.
1718 addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1720 // Get an anonymous type for index type.
1721 // FIXME: This type should be passed down from the front end
1722 // as different languages may have different sizes for indexes.
1723 DIE *IdxTy = getIndexTyDie();
1725 // Construct an anonymous type for index type.
1726 IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
1727 addString(IdxTy, dwarf::DW_AT_name, "int");
1728 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1729 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1730 dwarf::DW_ATE_signed);
1731 setIndexTyDie(IdxTy);
1734 // Add subranges to array type.
1735 DIArray Elements = CTy.getTypeArray();
1736 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1737 DIDescriptor Element = Elements.getElement(i);
1738 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1739 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1743 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1744 void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1745 DIArray Elements = CTy.getTypeArray();
1747 // Add enumerators to enumeration type.
1748 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1749 DIEnumerator Enum(Elements.getElement(i));
1750 if (Enum.isEnumerator()) {
1751 DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1752 StringRef Name = Enum.getName();
1753 addString(Enumerator, dwarf::DW_AT_name, Name);
1754 int64_t Value = Enum.getEnumValue();
1755 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1759 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1761 addType(&Buffer, DTy);
1762 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1766 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1768 void CompileUnit::constructContainingTypeDIEs() {
1769 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1770 CE = ContainingTypeMap.end();
1772 DIE *SPDie = CI->first;
1773 DIDescriptor D(CI->second);
1776 DIE *NDie = getDIE(D);
1779 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1783 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1784 DIE *CompileUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1785 StringRef Name = DV.getName();
1787 // Define variable debug information entry.
1788 DIE *VariableDie = new DIE(DV.getTag());
1789 DbgVariable *AbsVar = DV.getAbstractVariable();
1790 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1792 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1795 addString(VariableDie, dwarf::DW_AT_name, Name);
1796 addSourceLine(VariableDie, DV.getVariable());
1797 addType(VariableDie, DV.getType());
1800 if (DV.isArtificial())
1801 addFlag(VariableDie, dwarf::DW_AT_artificial);
1803 if (isScopeAbstract) {
1804 DV.setDIE(VariableDie);
1808 // Add variable address.
1810 unsigned Offset = DV.getDotDebugLocOffset();
1811 if (Offset != ~0U) {
1812 addSectionLabel(VariableDie, dwarf::DW_AT_location,
1813 Asm->GetTempSymbol("debug_loc", Offset));
1814 DV.setDIE(VariableDie);
1818 // Check if variable is described by a DBG_VALUE instruction.
1819 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1820 assert(DVInsn->getNumOperands() == 3);
1821 if (DVInsn->getOperand(0).isReg()) {
1822 const MachineOperand RegOp = DVInsn->getOperand(0);
1823 // If the second operand is an immediate, this is an indirect value.
1824 if (DVInsn->getOperand(1).isImm()) {
1825 MachineLocation Location(RegOp.getReg(),
1826 DVInsn->getOperand(1).getImm());
1827 addVariableAddress(DV, VariableDie, Location);
1828 } else if (RegOp.getReg())
1829 addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1830 } else if (DVInsn->getOperand(0).isImm())
1831 addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1832 else if (DVInsn->getOperand(0).isFPImm())
1833 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1834 else if (DVInsn->getOperand(0).isCImm())
1835 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1836 isUnsignedDIType(DD, DV.getType()));
1838 DV.setDIE(VariableDie);
1841 // .. else use frame index.
1842 int FI = DV.getFrameIndex();
1844 unsigned FrameReg = 0;
1845 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1846 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1847 MachineLocation Location(FrameReg, Offset);
1848 addVariableAddress(DV, VariableDie, Location);
1852 DV.setDIE(VariableDie);
1856 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1857 void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1858 DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1859 StringRef Name = DT.getName();
1861 addString(MemberDie, dwarf::DW_AT_name, Name);
1863 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1865 addSourceLine(MemberDie, DT);
1867 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1868 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1870 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1872 // For C++, virtual base classes are not at fixed offset. Use following
1873 // expression to extract appropriate offset from vtable.
1874 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1876 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1877 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1878 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1879 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1880 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1881 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1882 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1883 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1885 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1887 uint64_t Size = DT.getSizeInBits();
1888 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1889 uint64_t OffsetInBytes;
1891 if (Size != FieldSize) {
1893 addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1894 getBaseTypeSize(DD, DT) >> 3);
1895 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1897 uint64_t Offset = DT.getOffsetInBits();
1898 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1899 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1900 uint64_t FieldOffset = (HiMark - FieldSize);
1901 Offset -= FieldOffset;
1903 // Maybe we need to work from the other end.
1904 if (Asm->getDataLayout().isLittleEndian())
1905 Offset = FieldSize - (Offset + Size);
1906 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1908 // Here WD_AT_data_member_location points to the anonymous
1909 // field that includes this bit field.
1910 OffsetInBytes = FieldOffset >> 3;
1912 // This is not a bitfield.
1913 OffsetInBytes = DT.getOffsetInBits() >> 3;
1914 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1917 if (DT.isProtected())
1918 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1919 dwarf::DW_ACCESS_protected);
1920 else if (DT.isPrivate())
1921 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1922 dwarf::DW_ACCESS_private);
1923 // Otherwise C++ member and base classes are considered public.
1925 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1926 dwarf::DW_ACCESS_public);
1928 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1929 dwarf::DW_VIRTUALITY_virtual);
1931 // Objective-C properties.
1932 if (MDNode *PNode = DT.getObjCProperty())
1933 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1934 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1937 if (DT.isArtificial())
1938 addFlag(MemberDie, dwarf::DW_AT_artificial);
1941 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1942 DIE *CompileUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1946 // Construct the context before querying for the existence of the DIE in case
1947 // such construction creates the DIE.
1948 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1949 assert(dwarf::isType(ContextDIE->getTag()) &&
1950 "Static member should belong to a type.");
1952 DIE *StaticMemberDIE = getDIE(DT);
1953 if (StaticMemberDIE)
1954 return StaticMemberDIE;
1956 StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1958 DIType Ty = resolve(DT.getTypeDerivedFrom());
1960 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1961 addType(StaticMemberDIE, Ty);
1962 addSourceLine(StaticMemberDIE, DT);
1963 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1964 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1966 // FIXME: We could omit private if the parent is a class_type, and
1967 // public if the parent is something else.
1968 if (DT.isProtected())
1969 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1970 dwarf::DW_ACCESS_protected);
1971 else if (DT.isPrivate())
1972 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1973 dwarf::DW_ACCESS_private);
1975 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1976 dwarf::DW_ACCESS_public);
1978 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1979 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1980 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1981 addConstantFPValue(StaticMemberDIE, CFP);
1983 return StaticMemberDIE;
1986 void CompileUnit::emitHeader(const MCSection *ASection,
1987 const MCSymbol *ASectionSym) {
1988 Asm->OutStreamer.AddComment("DWARF version number");
1989 Asm->EmitInt16(DD->getDwarfVersion());
1990 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1991 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1993 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1994 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());