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"
35 /// CompileUnit - Compile unit constructor.
36 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
37 DwarfDebug *DW, DwarfUnits *DWU)
38 : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0),
40 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
44 /// ~CompileUnit - Destructor for compile unit.
45 CompileUnit::~CompileUnit() {
46 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
47 DIEBlocks[j]->~DIEBlock();
50 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
51 /// information entry.
52 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
53 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
57 /// getDefaultLowerBound - Return the default lower bound for an array. If the
58 /// DWARF version doesn't handle the language, return -1.
59 int64_t CompileUnit::getDefaultLowerBound() const {
60 switch (DICompileUnit(Node).getLanguage()) {
64 case dwarf::DW_LANG_C89:
65 case dwarf::DW_LANG_C99:
66 case dwarf::DW_LANG_C:
67 case dwarf::DW_LANG_C_plus_plus:
68 case dwarf::DW_LANG_ObjC:
69 case dwarf::DW_LANG_ObjC_plus_plus:
72 case dwarf::DW_LANG_Fortran77:
73 case dwarf::DW_LANG_Fortran90:
74 case dwarf::DW_LANG_Fortran95:
77 // The languages below have valid values only if the DWARF version >= 4.
78 case dwarf::DW_LANG_Java:
79 case dwarf::DW_LANG_Python:
80 case dwarf::DW_LANG_UPC:
81 case dwarf::DW_LANG_D:
82 if (dwarf::DWARF_VERSION >= 4)
86 case dwarf::DW_LANG_Ada83:
87 case dwarf::DW_LANG_Ada95:
88 case dwarf::DW_LANG_Cobol74:
89 case dwarf::DW_LANG_Cobol85:
90 case dwarf::DW_LANG_Modula2:
91 case dwarf::DW_LANG_Pascal83:
92 case dwarf::DW_LANG_PLI:
93 if (dwarf::DWARF_VERSION >= 4)
101 /// Check whether the DIE for this MDNode can be shared across CUs.
102 static bool isShareableAcrossCUs(const MDNode *N) {
103 // When the MDNode can be part of the type system, the DIE can be
104 // shared across CUs.
105 return DIDescriptor(N).isType() ||
106 (DIDescriptor(N).isSubprogram() && !DISubprogram(N).isDefinition());
109 /// getDIE - Returns the debug information entry map slot for the
110 /// specified debug variable. We delegate the request to DwarfDebug
111 /// when the DIE for this MDNode can be shared across CUs. The mappings
112 /// will be kept in DwarfDebug for shareable DIEs.
113 DIE *CompileUnit::getDIE(const MDNode *N) const {
114 if (isShareableAcrossCUs(N))
115 return DD->getDIE(N);
116 return MDNodeToDieMap.lookup(N);
119 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
120 /// when the DIE for this MDNode can be shared across CUs. The mappings
121 /// will be kept in DwarfDebug for shareable DIEs.
122 void CompileUnit::insertDIE(const MDNode *N, DIE *D) {
123 if (isShareableAcrossCUs(N)) {
127 MDNodeToDieMap.insert(std::make_pair(N, D));
130 /// addFlag - Add a flag that is true.
131 void CompileUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
132 if (DD->getDwarfVersion() >= 4)
133 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
135 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
138 /// addUInt - Add an unsigned integer attribute data and value.
140 void CompileUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
141 Optional<dwarf::Form> Form, uint64_t Integer) {
143 Form = DIEInteger::BestForm(false, Integer);
144 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
146 Die->addValue(Attribute, *Form, Value);
149 void CompileUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
150 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
153 /// addSInt - Add an signed integer attribute data and value.
155 void CompileUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
156 Optional<dwarf::Form> Form, int64_t Integer) {
158 Form = DIEInteger::BestForm(true, Integer);
159 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
160 Die->addValue(Attribute, *Form, Value);
163 void CompileUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
165 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
168 /// addString - Add a string attribute data and value. We always emit a
169 /// reference to the string pool instead of immediate strings so that DIEs have
170 /// more predictable sizes. In the case of split dwarf we emit an index
171 /// into another table which gets us the static offset into the string
173 void CompileUnit::addString(DIE *Die, dwarf::Attribute Attribute,
177 if (!DD->useSplitDwarf()) {
178 MCSymbol *Symb = DU->getStringPoolEntry(String);
179 if (Asm->needsRelocationsForDwarfStringPool())
180 Value = new (DIEValueAllocator) DIELabel(Symb);
182 MCSymbol *StringPool = DU->getStringPoolSym();
183 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
185 Form = dwarf::DW_FORM_strp;
187 unsigned idx = DU->getStringPoolIndex(String);
188 Value = new (DIEValueAllocator) DIEInteger(idx);
189 Form = dwarf::DW_FORM_GNU_str_index;
191 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
192 Die->addValue(Attribute, Form, Str);
195 /// addLocalString - Add a string attribute data and value. This is guaranteed
196 /// to be in the local string pool instead of indirected.
197 void CompileUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
199 MCSymbol *Symb = DU->getStringPoolEntry(String);
201 if (Asm->needsRelocationsForDwarfStringPool())
202 Value = new (DIEValueAllocator) DIELabel(Symb);
204 MCSymbol *StringPool = DU->getStringPoolSym();
205 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
207 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
210 /// addExpr - Add a Dwarf expression attribute data and value.
212 void CompileUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
213 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
214 Die->addValue((dwarf::Attribute)0, Form, Value);
217 /// addLabel - Add a Dwarf label attribute data and value.
219 void CompileUnit::addLabel(DIE *Die, dwarf::Attribute Attribute,
220 dwarf::Form Form, const MCSymbol *Label) {
221 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
222 Die->addValue(Attribute, Form, Value);
225 void CompileUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
226 const MCSymbol *Label) {
227 addLabel(Die, (dwarf::Attribute)0, Form, Label);
230 /// addLabelAddress - Add a dwarf label attribute data and value using
231 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
233 void CompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
236 DD->addArangeLabel(SymbolCU(this, Label));
238 if (!DD->useSplitDwarf()) {
240 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
241 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
243 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
244 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
247 unsigned idx = DU->getAddrPoolIndex(Label);
248 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
249 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
253 /// addOpAddress - Add a dwarf op address data and value using the
254 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
256 void CompileUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
257 DD->addArangeLabel(SymbolCU(this, Sym));
258 if (!DD->useSplitDwarf()) {
259 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
260 addLabel(Die, dwarf::DW_FORM_udata, Sym);
262 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
263 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
267 /// addDelta - Add a label delta attribute data and value.
269 void CompileUnit::addDelta(DIE *Die, dwarf::Attribute Attribute,
270 dwarf::Form Form, const MCSymbol *Hi,
271 const MCSymbol *Lo) {
272 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
273 Die->addValue(Attribute, Form, Value);
276 /// addDIEEntry - Add a DIE attribute data and value.
278 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
280 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
283 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
285 const DIE *DieCU = Die->getCompileUnitOrNull();
286 const DIE *EntryCU = Entry->getEntry()->getCompileUnitOrNull();
288 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
291 EntryCU = getCUDie();
292 Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
293 : dwarf::DW_FORM_ref_addr,
297 /// Create a DIE with the given Tag, add the DIE to its parent, and
298 /// call insertDIE if MD is not null.
299 DIE *CompileUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const MDNode *MD) {
300 DIE *Die = new DIE(Tag);
301 Parent.addChild(Die);
307 /// addBlock - Add block data.
309 void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
311 Block->ComputeSize(Asm);
312 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
313 Die->addValue(Attribute, Block->BestForm(), Block);
316 /// addSourceLine - Add location information to specified debug information
318 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
323 unsigned Line = V.getLineNumber();
327 DD->getOrCreateSourceID(V.getContext().getFilename(),
328 V.getContext().getDirectory(), getUniqueID());
329 assert(FileID && "Invalid file id");
330 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
331 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
334 /// addSourceLine - Add location information to specified debug information
336 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
337 // Verify global variable.
338 if (!G.isGlobalVariable())
341 unsigned Line = G.getLineNumber();
345 DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
346 assert(FileID && "Invalid file id");
347 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
348 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
351 /// addSourceLine - Add location information to specified debug information
353 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
354 // Verify subprogram.
355 if (!SP.isSubprogram())
358 // If the line number is 0, don't add it.
359 unsigned Line = SP.getLineNumber();
363 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
365 assert(FileID && "Invalid file id");
366 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
367 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
370 /// addSourceLine - Add location information to specified debug information
372 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
377 unsigned Line = Ty.getLineNumber();
380 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
382 assert(FileID && "Invalid file id");
383 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
384 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
387 /// addSourceLine - Add location information to specified debug information
389 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
391 if (!Ty.isObjCProperty())
394 unsigned Line = Ty.getLineNumber();
397 DIFile File = Ty.getFile();
398 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
399 File.getDirectory(), getUniqueID());
400 assert(FileID && "Invalid file id");
401 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
402 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
405 /// addSourceLine - Add location information to specified debug information
407 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
412 unsigned Line = NS.getLineNumber();
415 StringRef FN = NS.getFilename();
418 DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
419 assert(FileID && "Invalid file id");
420 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
421 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
424 /// addVariableAddress - Add DW_AT_location attribute for a
425 /// DbgVariable based on provided MachineLocation.
426 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
427 MachineLocation Location) {
428 if (DV.variableHasComplexAddress())
429 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
430 else if (DV.isBlockByrefVariable())
431 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
433 addAddress(Die, dwarf::DW_AT_location, Location,
434 DV.getVariable().isIndirect());
437 /// addRegisterOp - Add register operand.
438 void CompileUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
439 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
440 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
442 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
444 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
445 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
449 /// addRegisterOffset - Add register offset.
450 void CompileUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
452 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
453 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
454 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
455 if (Reg == TRI->getFrameRegister(*Asm->MF))
456 // If variable offset is based in frame register then use fbreg.
457 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
459 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
461 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
462 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
464 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
467 /// addAddress - Add an address attribute to a die based on the location
469 void CompileUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
470 const MachineLocation &Location, bool Indirect) {
471 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
473 if (Location.isReg() && !Indirect)
474 addRegisterOp(Block, Location.getReg());
476 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
477 if (Indirect && !Location.isReg()) {
478 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
482 // Now attach the location information to the DIE.
483 addBlock(Die, Attribute, Block);
486 /// addComplexAddress - Start with the address based on the location provided,
487 /// and generate the DWARF information necessary to find the actual variable
488 /// given the extra address information encoded in the DIVariable, starting from
489 /// the starting location. Add the DWARF information to the die.
491 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
492 dwarf::Attribute Attribute,
493 const MachineLocation &Location) {
494 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
495 unsigned N = DV.getNumAddrElements();
497 if (Location.isReg()) {
498 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
499 // If first address element is OpPlus then emit
500 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
501 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
504 addRegisterOp(Block, Location.getReg());
506 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
509 uint64_t Element = DV.getAddrElement(i);
510 if (Element == DIBuilder::OpPlus) {
511 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
512 addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
513 } else if (Element == DIBuilder::OpDeref) {
514 if (!Location.isReg())
515 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
517 llvm_unreachable("unknown DIBuilder Opcode");
520 // Now attach the location information to the DIE.
521 addBlock(Die, Attribute, Block);
524 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
525 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
526 gives the variable VarName either the struct, or a pointer to the struct, as
527 its type. This is necessary for various behind-the-scenes things the
528 compiler needs to do with by-reference variables in Blocks.
530 However, as far as the original *programmer* is concerned, the variable
531 should still have type 'SomeType', as originally declared.
533 The function getBlockByrefType dives into the __Block_byref_x_VarName
534 struct to find the original type of the variable, which is then assigned to
535 the variable's Debug Information Entry as its real type. So far, so good.
536 However now the debugger will expect the variable VarName to have the type
537 SomeType. So we need the location attribute for the variable to be an
538 expression that explains to the debugger how to navigate through the
539 pointers and struct to find the actual variable of type SomeType.
541 The following function does just that. We start by getting
542 the "normal" location for the variable. This will be the location
543 of either the struct __Block_byref_x_VarName or the pointer to the
544 struct __Block_byref_x_VarName.
546 The struct will look something like:
548 struct __Block_byref_x_VarName {
550 struct __Block_byref_x_VarName *forwarding;
551 ... <various other fields>
553 ... <maybe more fields>
556 If we are given the struct directly (as our starting point) we
557 need to tell the debugger to:
559 1). Add the offset of the forwarding field.
561 2). Follow that pointer to get the real __Block_byref_x_VarName
562 struct to use (the real one may have been copied onto the heap).
564 3). Add the offset for the field VarName, to find the actual variable.
566 If we started with a pointer to the struct, then we need to
567 dereference that pointer first, before the other steps.
568 Translating this into DWARF ops, we will need to append the following
569 to the current location description for the variable:
571 DW_OP_deref -- optional, if we start with a pointer
572 DW_OP_plus_uconst <forward_fld_offset>
574 DW_OP_plus_uconst <varName_fld_offset>
576 That is what this function does. */
578 /// addBlockByrefAddress - Start with the address based on the location
579 /// provided, and generate the DWARF information necessary to find the
580 /// actual Block variable (navigating the Block struct) based on the
581 /// starting location. Add the DWARF information to the die. For
582 /// more information, read large comment just above here.
584 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
585 dwarf::Attribute Attribute,
586 const MachineLocation &Location) {
587 DIType Ty = DV.getType();
589 uint16_t Tag = Ty.getTag();
590 bool isPointer = false;
592 StringRef varName = DV.getName();
594 if (Tag == dwarf::DW_TAG_pointer_type) {
595 DIDerivedType DTy = DIDerivedType(Ty);
596 TmpTy = resolve(DTy.getTypeDerivedFrom());
600 DICompositeType blockStruct = DICompositeType(TmpTy);
602 // Find the __forwarding field and the variable field in the __Block_byref
604 DIArray Fields = blockStruct.getTypeArray();
605 DIDescriptor varField = DIDescriptor();
606 DIDescriptor forwardingField = DIDescriptor();
608 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
609 DIDescriptor Element = Fields.getElement(i);
610 DIDerivedType DT = DIDerivedType(Element);
611 StringRef fieldName = DT.getName();
612 if (fieldName == "__forwarding")
613 forwardingField = Element;
614 else if (fieldName == varName)
618 // Get the offsets for the forwarding field and the variable field.
619 unsigned forwardingFieldOffset =
620 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
621 unsigned varFieldOffset = DIDerivedType(varField).getOffsetInBits() >> 3;
623 // Decode the original location, and use that as the start of the byref
624 // variable's location.
625 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
627 if (Location.isReg())
628 addRegisterOp(Block, Location.getReg());
630 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
632 // If we started with a pointer to the __Block_byref... struct, then
633 // the first thing we need to do is dereference the pointer (DW_OP_deref).
635 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
637 // Next add the offset for the '__forwarding' field:
638 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
639 // adding the offset if it's 0.
640 if (forwardingFieldOffset > 0) {
641 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
642 addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
645 // Now dereference the __forwarding field to get to the real __Block_byref
646 // struct: DW_OP_deref.
647 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
649 // Now that we've got the real __Block_byref... struct, add the offset
650 // for the variable's field to get to the location of the actual variable:
651 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
652 if (varFieldOffset > 0) {
653 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
654 addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
657 // Now attach the location information to the DIE.
658 addBlock(Die, Attribute, Block);
661 /// isTypeSigned - Return true if the type is signed.
662 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
663 if (Ty.isDerivedType())
664 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
666 if (Ty.isBasicType())
667 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
668 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
669 *SizeInBits = Ty.getSizeInBits();
675 /// Return true if type encoding is unsigned.
676 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
677 DIDerivedType DTy(Ty);
678 if (DTy.isDerivedType())
679 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
682 if (BTy.isBasicType()) {
683 unsigned Encoding = BTy.getEncoding();
684 if (Encoding == dwarf::DW_ATE_unsigned ||
685 Encoding == dwarf::DW_ATE_unsigned_char ||
686 Encoding == dwarf::DW_ATE_boolean)
692 /// If this type is derived from a base type then return base type size.
693 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
694 unsigned Tag = Ty.getTag();
696 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
697 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
698 Tag != dwarf::DW_TAG_restrict_type)
699 return Ty.getSizeInBits();
701 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
703 // If this type is not derived from any type then take conservative approach.
704 if (!BaseType.isValid())
705 return Ty.getSizeInBits();
707 // If this is a derived type, go ahead and get the base type, unless it's a
708 // reference then it's just the size of the field. Pointer types have no need
709 // of this since they're a different type of qualification on the type.
710 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
711 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
712 return Ty.getSizeInBits();
714 if (BaseType.isDerivedType())
715 return getBaseTypeSize(DD, DIDerivedType(BaseType));
717 return BaseType.getSizeInBits();
720 /// addConstantValue - Add constant value entry in variable DIE.
721 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
723 // FIXME: This is a bit conservative/simple - it emits negative values at
724 // their maximum bit width which is a bit unfortunate (& doesn't prefer
725 // udata/sdata over dataN as suggested by the DWARF spec)
726 assert(MO.isImm() && "Invalid machine operand!");
728 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
731 // If we're a signed constant definitely use sdata.
732 if (SignedConstant) {
733 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
737 // Else use data for now unless it's larger than we can deal with.
738 switch (SizeInBits) {
740 Form = dwarf::DW_FORM_data1;
743 Form = dwarf::DW_FORM_data2;
746 Form = dwarf::DW_FORM_data4;
749 Form = dwarf::DW_FORM_data8;
752 Form = dwarf::DW_FORM_udata;
753 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
756 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
759 /// addConstantFPValue - Add constant value entry in variable DIE.
760 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
761 assert(MO.isFPImm() && "Invalid machine operand!");
762 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
763 APFloat FPImm = MO.getFPImm()->getValueAPF();
765 // Get the raw data form of the floating point.
766 const APInt FltVal = FPImm.bitcastToAPInt();
767 const char *FltPtr = (const char *)FltVal.getRawData();
769 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
770 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
771 int Incr = (LittleEndian ? 1 : -1);
772 int Start = (LittleEndian ? 0 : NumBytes - 1);
773 int Stop = (LittleEndian ? NumBytes : -1);
775 // Output the constant to DWARF one byte at a time.
776 for (; Start != Stop; Start += Incr)
777 addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
779 addBlock(Die, dwarf::DW_AT_const_value, Block);
782 /// addConstantFPValue - Add constant value entry in variable DIE.
783 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
784 // Pass this down to addConstantValue as an unsigned bag of bits.
785 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
788 /// addConstantValue - Add constant value entry in variable DIE.
789 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
791 addConstantValue(Die, CI->getValue(), Unsigned);
794 // addConstantValue - Add constant value entry in variable DIE.
795 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
796 unsigned CIBitWidth = Val.getBitWidth();
797 if (CIBitWidth <= 64) {
798 // If we're a signed constant definitely use sdata.
800 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
805 // Else use data for now unless it's larger than we can deal with.
807 switch (CIBitWidth) {
809 Form = dwarf::DW_FORM_data1;
812 Form = dwarf::DW_FORM_data2;
815 Form = dwarf::DW_FORM_data4;
818 Form = dwarf::DW_FORM_data8;
821 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
825 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
829 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
831 // Get the raw data form of the large APInt.
832 const uint64_t *Ptr64 = Val.getRawData();
834 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
835 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
837 // Output the constant to DWARF one byte at a time.
838 for (int i = 0; i < NumBytes; i++) {
841 c = Ptr64[i / 8] >> (8 * (i & 7));
843 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
844 addUInt(Block, dwarf::DW_FORM_data1, c);
847 addBlock(Die, dwarf::DW_AT_const_value, Block);
850 /// addTemplateParams - Add template parameters into buffer.
851 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
852 // Add template parameters.
853 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
854 DIDescriptor Element = TParams.getElement(i);
855 if (Element.isTemplateTypeParameter())
856 constructTemplateTypeParameterDIE(Buffer,
857 DITemplateTypeParameter(Element));
858 else if (Element.isTemplateValueParameter())
859 constructTemplateValueParameterDIE(Buffer,
860 DITemplateValueParameter(Element));
864 /// getOrCreateContextDIE - Get context owner's DIE.
865 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
866 if (Context.isType())
867 return getOrCreateTypeDIE(DIType(Context));
868 else if (Context.isNameSpace())
869 return getOrCreateNameSpace(DINameSpace(Context));
870 else if (Context.isSubprogram())
871 return getOrCreateSubprogramDIE(DISubprogram(Context));
873 return getDIE(Context);
876 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
878 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
883 // Construct the context before querying for the existence of the DIE in case
884 // such construction creates the DIE.
885 DIE *ContextDIE = getOrCreateContextDIE(resolve(Ty.getContext()));
887 ContextDIE = CUDie.get();
889 DIE *TyDIE = getDIE(Ty);
894 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
896 if (Ty.isBasicType())
897 constructTypeDIE(*TyDIE, DIBasicType(Ty));
898 else if (Ty.isCompositeType())
899 constructTypeDIE(*TyDIE, DICompositeType(Ty));
901 assert(Ty.isDerivedType() && "Unknown kind of DIType");
902 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
904 // If this is a named finished type then include it in the list of types
905 // for the accelerator tables.
906 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
907 bool IsImplementation = 0;
908 if (Ty.isCompositeType()) {
909 DICompositeType CT(Ty);
910 // A runtime language of 0 actually means C/C++ and that any
911 // non-negative value is some version of Objective-C/C++.
912 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
914 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
915 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
921 /// addType - Add a new type attribute to the specified entity.
922 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
923 assert(Ty && "Trying to add a type that doesn't exist?");
925 // Check for pre-existence.
926 DIEEntry *Entry = getDIEEntry(Ty);
927 // If it exists then use the existing value.
929 addDIEEntry(Entity, Attribute, Entry);
934 DIE *Buffer = getOrCreateTypeDIE(Ty);
937 Entry = createDIEEntry(Buffer);
938 insertDIEEntry(Ty, Entry);
939 addDIEEntry(Entity, Attribute, Entry);
941 // If this is a complete composite type then include it in the
942 // list of global types.
946 // Accelerator table mutators - add each name along with its companion
947 // DIE to the proper table while ensuring that the name that we're going
948 // to reference is in the string table. We do this since the names we
949 // add may not only be identical to the names in the DIE.
950 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
951 DU->getStringPoolEntry(Name);
952 std::vector<DIE *> &DIEs = AccelNames[Name];
956 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
957 DU->getStringPoolEntry(Name);
958 std::vector<DIE *> &DIEs = AccelObjC[Name];
962 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
963 DU->getStringPoolEntry(Name);
964 std::vector<DIE *> &DIEs = AccelNamespace[Name];
968 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
969 DU->getStringPoolEntry(Name);
970 std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
974 /// addGlobalName - Add a new global name to the compile unit.
975 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
976 std::string FullName = getParentContextString(Context) + Name.str();
977 GlobalNames[FullName] = Die;
980 /// addGlobalType - Add a new global type to the compile unit.
982 void CompileUnit::addGlobalType(DIType Ty) {
983 DIScope Context = resolve(Ty.getContext());
984 if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
985 (!Context || Context.isCompileUnit() || Context.isFile() ||
986 Context.isNameSpace()))
987 if (DIEEntry *Entry = getDIEEntry(Ty)) {
988 std::string FullName =
989 getParentContextString(Context) + Ty.getName().str();
990 GlobalTypes[FullName] = Entry->getEntry();
994 /// getParentContextString - Walks the metadata parent chain in a language
995 /// specific manner (using the compile unit language) and returns
996 /// it as a string. This is done at the metadata level because DIEs may
997 /// not currently have been added to the parent context and walking the
998 /// DIEs looking for names is more expensive than walking the metadata.
999 std::string CompileUnit::getParentContextString(DIScope Context) const {
1003 // FIXME: Decide whether to implement this for non-C++ languages.
1004 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1008 SmallVector<DIScope, 1> Parents;
1009 while (!Context.isCompileUnit()) {
1010 Parents.push_back(Context);
1011 if (Context.getContext())
1012 Context = resolve(Context.getContext());
1014 // Structure, etc types will have a NULL context if they're at the top
1019 // Reverse iterate over our list to go from the outermost construct to the
1021 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1025 StringRef Name = Ctx.getName();
1026 if (!Name.empty()) {
1034 /// addPubTypes - Add subprogram argument types for pubtypes section.
1035 void CompileUnit::addPubTypes(DISubprogram SP) {
1036 DICompositeType SPTy = SP.getType();
1037 uint16_t SPTag = SPTy.getTag();
1038 if (SPTag != dwarf::DW_TAG_subroutine_type)
1041 DIArray Args = SPTy.getTypeArray();
1042 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1043 DIType ATy(Args.getElement(i));
1050 /// constructTypeDIE - Construct basic type die from DIBasicType.
1051 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1052 // Get core information.
1053 StringRef Name = BTy.getName();
1054 // Add name if not anonymous or intermediate type.
1056 addString(&Buffer, dwarf::DW_AT_name, Name);
1058 // An unspecified type only has a name attribute.
1059 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1062 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1065 uint64_t Size = BTy.getSizeInBits() >> 3;
1066 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1069 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1070 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1071 // Get core information.
1072 StringRef Name = DTy.getName();
1073 uint64_t Size = DTy.getSizeInBits() >> 3;
1074 uint16_t Tag = Buffer.getTag();
1076 // Map to main type, void will not have a type.
1077 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1079 addType(&Buffer, FromTy);
1081 // Add name if not anonymous or intermediate type.
1083 addString(&Buffer, dwarf::DW_AT_name, Name);
1085 // Add size if non-zero (derived types might be zero-sized.)
1086 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1087 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1089 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1090 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1091 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1092 // Add source line info if available and TyDesc is not a forward declaration.
1093 if (!DTy.isForwardDecl())
1094 addSourceLine(&Buffer, DTy);
1097 /// Return true if the type is appropriately scoped to be contained inside
1098 /// its own type unit.
1099 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1100 DIScope Parent = DD->resolve(Ty.getContext());
1102 // Don't generate a hash for anything scoped inside a function.
1103 if (Parent.isSubprogram())
1105 Parent = DD->resolve(Parent.getContext());
1110 /// Return true if the type should be split out into a type unit.
1111 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1112 uint16_t Tag = CTy.getTag();
1115 case dwarf::DW_TAG_structure_type:
1116 case dwarf::DW_TAG_union_type:
1117 case dwarf::DW_TAG_enumeration_type:
1118 case dwarf::DW_TAG_class_type:
1119 // If this is a class, structure, union, or enumeration type
1120 // that is a definition (not a declaration), and not scoped
1121 // inside a function then separate this out as a type unit.
1122 return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1128 /// constructTypeDIE - Construct type DIE from DICompositeType.
1129 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1130 // Get core information.
1131 StringRef Name = CTy.getName();
1133 uint64_t Size = CTy.getSizeInBits() >> 3;
1134 uint16_t Tag = Buffer.getTag();
1137 case dwarf::DW_TAG_array_type:
1138 constructArrayTypeDIE(Buffer, CTy);
1140 case dwarf::DW_TAG_enumeration_type: {
1141 DIArray Elements = CTy.getTypeArray();
1143 // Add enumerators to enumeration type.
1144 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1145 DIDescriptor Enum(Elements.getElement(i));
1146 if (Enum.isEnumerator())
1147 constructEnumTypeDIE(Buffer, DIEnumerator(Enum));
1149 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1151 addType(&Buffer, DTy);
1152 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1155 case dwarf::DW_TAG_subroutine_type: {
1156 // Add return type. A void return won't have a type.
1157 DIArray Elements = CTy.getTypeArray();
1158 DIDescriptor RTy = Elements.getElement(0);
1160 addType(&Buffer, DIType(RTy));
1162 bool isPrototyped = true;
1164 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1165 DIDescriptor Ty = Elements.getElement(i);
1166 if (Ty.isUnspecifiedParameter()) {
1167 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1168 isPrototyped = false;
1170 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1171 addType(Arg, DIType(Ty));
1172 if (DIType(Ty).isArtificial())
1173 addFlag(Arg, dwarf::DW_AT_artificial);
1176 // Add prototype flag if we're dealing with a C language and the
1177 // function has been prototyped.
1178 uint16_t Language = DICompileUnit(Node).getLanguage();
1180 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1181 Language == dwarf::DW_LANG_ObjC))
1182 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1184 case dwarf::DW_TAG_structure_type:
1185 case dwarf::DW_TAG_union_type:
1186 case dwarf::DW_TAG_class_type: {
1187 // Add elements to structure type.
1188 DIArray Elements = CTy.getTypeArray();
1189 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1190 DIDescriptor Element = Elements.getElement(i);
1191 DIE *ElemDie = NULL;
1192 if (Element.isSubprogram()) {
1193 DISubprogram SP(Element);
1194 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1195 if (SP.isProtected())
1196 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1197 dwarf::DW_ACCESS_protected);
1198 else if (SP.isPrivate())
1199 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1200 dwarf::DW_ACCESS_private);
1202 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1203 dwarf::DW_ACCESS_public);
1204 if (SP.isExplicit())
1205 addFlag(ElemDie, dwarf::DW_AT_explicit);
1206 } else if (Element.isDerivedType()) {
1207 DIDerivedType DDTy(Element);
1208 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1209 ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1210 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1211 dwarf::DW_AT_friend);
1212 } else if (DDTy.isStaticMember()) {
1213 getOrCreateStaticMemberDIE(DDTy);
1215 constructMemberDIE(Buffer, DDTy);
1217 } else if (Element.isObjCProperty()) {
1218 DIObjCProperty Property(Element);
1219 ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1220 StringRef PropertyName = Property.getObjCPropertyName();
1221 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1222 addType(ElemDie, Property.getType());
1223 addSourceLine(ElemDie, Property);
1224 StringRef GetterName = Property.getObjCPropertyGetterName();
1225 if (!GetterName.empty())
1226 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1227 StringRef SetterName = Property.getObjCPropertySetterName();
1228 if (!SetterName.empty())
1229 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1230 unsigned PropertyAttributes = 0;
1231 if (Property.isReadOnlyObjCProperty())
1232 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1233 if (Property.isReadWriteObjCProperty())
1234 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1235 if (Property.isAssignObjCProperty())
1236 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1237 if (Property.isRetainObjCProperty())
1238 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1239 if (Property.isCopyObjCProperty())
1240 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1241 if (Property.isNonAtomicObjCProperty())
1242 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1243 if (PropertyAttributes)
1244 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1245 PropertyAttributes);
1247 DIEEntry *Entry = getDIEEntry(Element);
1249 Entry = createDIEEntry(ElemDie);
1250 insertDIEEntry(Element, Entry);
1256 if (CTy.isAppleBlockExtension())
1257 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1259 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1260 if (DIDescriptor(ContainingType).isCompositeType())
1261 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1262 getOrCreateTypeDIE(DIType(ContainingType)));
1264 if (CTy.isObjcClassComplete())
1265 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1267 // Add template parameters to a class, structure or union types.
1268 // FIXME: The support isn't in the metadata for this yet.
1269 if (Tag == dwarf::DW_TAG_class_type ||
1270 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1271 addTemplateParams(Buffer, CTy.getTemplateParams());
1279 // Add name if not anonymous or intermediate type.
1281 addString(&Buffer, dwarf::DW_AT_name, Name);
1283 if (Tag == dwarf::DW_TAG_enumeration_type ||
1284 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1285 Tag == dwarf::DW_TAG_union_type) {
1286 // Add size if non-zero (derived types might be zero-sized.)
1287 // TODO: Do we care about size for enum forward declarations?
1289 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1290 else if (!CTy.isForwardDecl())
1291 // Add zero size if it is not a forward declaration.
1292 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1294 // If we're a forward decl, say so.
1295 if (CTy.isForwardDecl())
1296 addFlag(&Buffer, dwarf::DW_AT_declaration);
1298 // Add source line info if available.
1299 if (!CTy.isForwardDecl())
1300 addSourceLine(&Buffer, CTy);
1302 // No harm in adding the runtime language to the declaration.
1303 unsigned RLang = CTy.getRunTimeLang();
1305 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1308 // If this is a type applicable to a type unit it then add it to the
1309 // list of types we'll compute a hash for later.
1310 if (shouldCreateTypeUnit(CTy, DD))
1311 DD->addTypeUnitType(&Buffer);
1314 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1315 /// DITemplateTypeParameter.
1317 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1318 DITemplateTypeParameter TP) {
1320 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1321 // Add the type if it exists, it could be void and therefore no type.
1323 addType(ParamDIE, resolve(TP.getType()));
1324 if (!TP.getName().empty())
1325 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1328 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1329 /// DITemplateValueParameter.
1331 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1332 DITemplateValueParameter VP) {
1333 DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1335 // Add the type if there is one, template template and template parameter
1336 // packs will not have a type.
1337 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1338 addType(ParamDIE, resolve(VP.getType()));
1339 if (!VP.getName().empty())
1340 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1341 if (Value *Val = VP.getValue()) {
1342 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1343 addConstantValue(ParamDIE, CI,
1344 isUnsignedDIType(DD, resolve(VP.getType())));
1345 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1346 // For declaration non-type template parameters (such as global values and
1348 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1349 addOpAddress(Block, Asm->getSymbol(GV));
1350 // Emit DW_OP_stack_value to use the address as the immediate value of the
1351 // parameter, rather than a pointer to it.
1352 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1353 addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1354 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1355 assert(isa<MDString>(Val));
1356 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1357 cast<MDString>(Val)->getString());
1358 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1359 assert(isa<MDNode>(Val));
1360 DIArray A(cast<MDNode>(Val));
1361 addTemplateParams(*ParamDIE, A);
1366 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1367 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1368 // Construct the context before querying for the existence of the DIE in case
1369 // such construction creates the DIE.
1370 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1372 // If the context is null, DIE should belong to the CU we call construct
1374 ContextDIE = CUDie.get();
1376 DIE *NDie = getDIE(NS);
1379 NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1381 if (!NS.getName().empty()) {
1382 addString(NDie, dwarf::DW_AT_name, NS.getName());
1383 addAccelNamespace(NS.getName(), NDie);
1384 addGlobalName(NS.getName(), NDie, NS.getContext());
1386 addAccelNamespace("(anonymous namespace)", NDie);
1387 addSourceLine(NDie, NS);
1391 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1392 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1393 // Construct the context before querying for the existence of the DIE in case
1394 // such construction creates the DIE (as is the case for member function
1396 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1398 ContextDIE = CUDie.get();
1400 DIE *SPDie = getDIE(SP);
1404 DISubprogram SPDecl = SP.getFunctionDeclaration();
1405 if (SPDecl.isSubprogram())
1406 // Add subprogram definitions to the CU die directly.
1407 ContextDIE = CUDie.get();
1409 // DW_TAG_inlined_subroutine may refer to this DIE.
1410 SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1412 DIE *DeclDie = NULL;
1413 if (SPDecl.isSubprogram())
1414 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1416 // Add function template parameters.
1417 addTemplateParams(*SPDie, SP.getTemplateParams());
1419 // If this DIE is going to refer declaration info using AT_specification
1420 // then there is no need to add other attributes.
1422 // Refer function declaration directly.
1423 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1428 // Add the linkage name if we have one.
1429 StringRef LinkageName = SP.getLinkageName();
1430 if (!LinkageName.empty())
1431 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1432 GlobalValue::getRealLinkageName(LinkageName));
1434 // Constructors and operators for anonymous aggregates do not have names.
1435 if (!SP.getName().empty())
1436 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1438 addSourceLine(SPDie, SP);
1440 // Add the prototype if we have a prototype and we have a C like
1442 uint16_t Language = DICompileUnit(Node).getLanguage();
1443 if (SP.isPrototyped() &&
1444 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1445 Language == dwarf::DW_LANG_ObjC))
1446 addFlag(SPDie, dwarf::DW_AT_prototyped);
1448 DICompositeType SPTy = SP.getType();
1449 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1450 "the type of a subprogram should be a subroutine");
1452 DIArray Args = SPTy.getTypeArray();
1453 // Add a return type. If this is a type like a C/C++ void type we don't add a
1455 if (Args.getElement(0))
1456 addType(SPDie, DIType(Args.getElement(0)));
1458 unsigned VK = SP.getVirtuality();
1460 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1461 DIEBlock *Block = getDIEBlock();
1462 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1463 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1464 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1465 ContainingTypeMap.insert(
1466 std::make_pair(SPDie, resolve(SP.getContainingType())));
1469 if (!SP.isDefinition()) {
1470 addFlag(SPDie, dwarf::DW_AT_declaration);
1472 // Add arguments. Do not add arguments for subprogram definition. They will
1473 // be handled while processing variables.
1474 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1475 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1476 DIType ATy = DIType(Args.getElement(i));
1478 if (ATy.isArtificial())
1479 addFlag(Arg, dwarf::DW_AT_artificial);
1483 if (SP.isArtificial())
1484 addFlag(SPDie, dwarf::DW_AT_artificial);
1486 if (!SP.isLocalToUnit())
1487 addFlag(SPDie, dwarf::DW_AT_external);
1489 if (SP.isOptimized())
1490 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1492 if (unsigned isa = Asm->getISAEncoding()) {
1493 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1499 // Return const expression if value is a GEP to access merged global
1501 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1502 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1503 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1504 if (!CE || CE->getNumOperands() != 3 ||
1505 CE->getOpcode() != Instruction::GetElementPtr)
1508 // First operand points to a global struct.
1509 Value *Ptr = CE->getOperand(0);
1510 if (!isa<GlobalValue>(Ptr) ||
1511 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1514 // Second operand is zero.
1515 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1516 if (!CI || !CI->isZero())
1519 // Third operand is offset.
1520 if (!isa<ConstantInt>(CE->getOperand(2)))
1526 /// createGlobalVariableDIE - create global variable DIE.
1527 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1528 // Check for pre-existence.
1532 DIGlobalVariable GV(N);
1533 if (!GV.isGlobalVariable())
1536 DIScope GVContext = GV.getContext();
1537 DIType GTy = GV.getType();
1539 // If this is a static data member definition, some attributes belong
1540 // to the declaration DIE.
1541 DIE *VariableDIE = NULL;
1542 bool IsStaticMember = false;
1543 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1544 if (SDMDecl.Verify()) {
1545 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1546 // We need the declaration DIE that is in the static member's class.
1547 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1548 IsStaticMember = true;
1551 // If this is not a static data member definition, create the variable
1552 // DIE and add the initial set of attributes to it.
1554 // Construct the context before querying for the existence of the DIE in
1555 // case such construction creates the DIE.
1556 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1558 ContextDIE = CUDie.get();
1561 VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, N);
1563 // Add name and type.
1564 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1565 addType(VariableDIE, GTy);
1567 // Add scoping info.
1568 if (!GV.isLocalToUnit())
1569 addFlag(VariableDIE, dwarf::DW_AT_external);
1571 // Add line number info.
1572 addSourceLine(VariableDIE, GV);
1576 bool addToAccelTable = false;
1577 DIE *VariableSpecDIE = NULL;
1578 bool isGlobalVariable = GV.getGlobal() != NULL;
1579 if (isGlobalVariable) {
1580 addToAccelTable = true;
1581 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1582 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1583 if (GV.getGlobal()->isThreadLocal()) {
1584 // FIXME: Make this work with -gsplit-dwarf.
1585 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1586 assert((PointerSize == 4 || PointerSize == 8) &&
1587 "Add support for other sizes if necessary");
1588 const MCExpr *Expr =
1589 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1590 // Based on GCC's support for TLS:
1591 if (!DD->useSplitDwarf()) {
1592 // 1) Start with a constNu of the appropriate pointer size
1593 addUInt(Block, dwarf::DW_FORM_data1,
1594 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1595 // 2) containing the (relocated) offset of the TLS variable
1596 // within the module's TLS block.
1597 addExpr(Block, dwarf::DW_FORM_udata, Expr);
1599 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1600 addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1602 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1603 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1605 addOpAddress(Block, Sym);
1606 // Do not create specification DIE if context is either compile unit
1608 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1609 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1610 // Create specification DIE.
1611 VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie.get());
1612 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1613 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1614 // A static member's declaration is already flagged as such.
1615 if (!SDMDecl.Verify())
1616 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1618 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1620 // Add the linkage name.
1621 StringRef LinkageName = GV.getLinkageName();
1622 if (!LinkageName.empty())
1623 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1624 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1626 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1628 dwarf::DW_AT_MIPS_linkage_name,
1629 GlobalValue::getRealLinkageName(LinkageName));
1630 } else if (const ConstantInt *CI =
1631 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1632 // AT_const_value was added when the static member was created. To avoid
1633 // emitting AT_const_value multiple times, we only add AT_const_value when
1634 // it is not a static member.
1635 if (!IsStaticMember)
1636 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1637 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1638 addToAccelTable = true;
1639 // GV is a merged global.
1640 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1641 Value *Ptr = CE->getOperand(0);
1642 addOpAddress(Block, Asm->getSymbol(cast<GlobalValue>(Ptr)));
1643 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1644 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1645 addUInt(Block, dwarf::DW_FORM_udata,
1646 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1647 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1648 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1651 if (addToAccelTable) {
1652 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1653 addAccelName(GV.getName(), AddrDIE);
1655 // If the linkage name is different than the name, go ahead and output
1656 // that as well into the name table.
1657 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1658 addAccelName(GV.getLinkageName(), AddrDIE);
1661 if (!GV.isLocalToUnit())
1662 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1666 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1667 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1669 DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1670 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1672 // The LowerBound value defines the lower bounds which is typically zero for
1673 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1674 // Count == -1 then the array is unbounded and we do not emit
1675 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1676 // Count == 0, then the array has zero elements in which case we do not emit
1678 int64_t LowerBound = SR.getLo();
1679 int64_t DefaultLowerBound = getDefaultLowerBound();
1680 int64_t Count = SR.getCount();
1682 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1683 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1685 if (Count != -1 && Count != 0)
1686 // FIXME: An unbounded array should reference the expression that defines
1688 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1689 LowerBound + Count - 1);
1692 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1693 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1695 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1697 // Emit the element type.
1698 addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1700 // Get an anonymous type for index type.
1701 // FIXME: This type should be passed down from the front end
1702 // as different languages may have different sizes for indexes.
1703 DIE *IdxTy = getIndexTyDie();
1705 // Construct an anonymous type for index type.
1706 IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
1707 addString(IdxTy, dwarf::DW_AT_name, "int");
1708 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1709 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1710 dwarf::DW_ATE_signed);
1711 setIndexTyDie(IdxTy);
1714 // Add subranges to array type.
1715 DIArray Elements = CTy.getTypeArray();
1716 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1717 DIDescriptor Element = Elements.getElement(i);
1718 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1719 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1723 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1724 void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DIEnumerator ETy) {
1725 DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1726 StringRef Name = ETy.getName();
1727 addString(Enumerator, dwarf::DW_AT_name, Name);
1728 int64_t Value = ETy.getEnumValue();
1729 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1732 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1734 void CompileUnit::constructContainingTypeDIEs() {
1735 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1736 CE = ContainingTypeMap.end();
1738 DIE *SPDie = CI->first;
1739 const MDNode *N = CI->second;
1742 DIE *NDie = getDIE(N);
1745 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1749 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1750 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1751 StringRef Name = DV->getName();
1753 // Define variable debug information entry.
1754 DIE *VariableDie = new DIE(DV->getTag());
1755 DbgVariable *AbsVar = DV->getAbstractVariable();
1756 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1758 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1761 addString(VariableDie, dwarf::DW_AT_name, Name);
1762 addSourceLine(VariableDie, DV->getVariable());
1763 addType(VariableDie, DV->getType());
1766 if (DV->isArtificial())
1767 addFlag(VariableDie, dwarf::DW_AT_artificial);
1769 if (isScopeAbstract) {
1770 DV->setDIE(VariableDie);
1774 // Add variable address.
1776 unsigned Offset = DV->getDotDebugLocOffset();
1777 if (Offset != ~0U) {
1778 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1779 Asm->GetTempSymbol("debug_loc", Offset));
1780 DV->setDIE(VariableDie);
1784 // Check if variable is described by a DBG_VALUE instruction.
1785 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1786 assert(DVInsn->getNumOperands() == 3);
1787 if (DVInsn->getOperand(0).isReg()) {
1788 const MachineOperand RegOp = DVInsn->getOperand(0);
1789 // If the second operand is an immediate, this is an indirect value.
1790 if (DVInsn->getOperand(1).isImm()) {
1791 MachineLocation Location(RegOp.getReg(),
1792 DVInsn->getOperand(1).getImm());
1793 addVariableAddress(*DV, VariableDie, Location);
1794 } else if (RegOp.getReg())
1795 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1796 } else if (DVInsn->getOperand(0).isImm())
1797 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1798 else if (DVInsn->getOperand(0).isFPImm())
1799 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1800 else if (DVInsn->getOperand(0).isCImm())
1801 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1802 isUnsignedDIType(DD, DV->getType()));
1804 DV->setDIE(VariableDie);
1807 // .. else use frame index.
1808 int FI = DV->getFrameIndex();
1810 unsigned FrameReg = 0;
1811 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1812 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1813 MachineLocation Location(FrameReg, Offset);
1814 addVariableAddress(*DV, VariableDie, Location);
1818 DV->setDIE(VariableDie);
1822 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1823 void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1824 DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1825 StringRef Name = DT.getName();
1827 addString(MemberDie, dwarf::DW_AT_name, Name);
1829 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1831 addSourceLine(MemberDie, DT);
1833 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1834 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1836 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1838 // For C++, virtual base classes are not at fixed offset. Use following
1839 // expression to extract appropriate offset from vtable.
1840 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1842 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1843 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1844 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1845 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1846 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1847 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1848 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1849 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1851 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1853 uint64_t Size = DT.getSizeInBits();
1854 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1855 uint64_t OffsetInBytes;
1857 if (Size != FieldSize) {
1859 addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1860 getBaseTypeSize(DD, DT) >> 3);
1861 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1863 uint64_t Offset = DT.getOffsetInBits();
1864 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1865 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1866 uint64_t FieldOffset = (HiMark - FieldSize);
1867 Offset -= FieldOffset;
1869 // Maybe we need to work from the other end.
1870 if (Asm->getDataLayout().isLittleEndian())
1871 Offset = FieldSize - (Offset + Size);
1872 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1874 // Here WD_AT_data_member_location points to the anonymous
1875 // field that includes this bit field.
1876 OffsetInBytes = FieldOffset >> 3;
1878 // This is not a bitfield.
1879 OffsetInBytes = DT.getOffsetInBits() >> 3;
1880 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1883 if (DT.isProtected())
1884 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1885 dwarf::DW_ACCESS_protected);
1886 else if (DT.isPrivate())
1887 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1888 dwarf::DW_ACCESS_private);
1889 // Otherwise C++ member and base classes are considered public.
1891 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1892 dwarf::DW_ACCESS_public);
1894 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1895 dwarf::DW_VIRTUALITY_virtual);
1897 // Objective-C properties.
1898 if (MDNode *PNode = DT.getObjCProperty())
1899 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1900 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1903 if (DT.isArtificial())
1904 addFlag(MemberDie, dwarf::DW_AT_artificial);
1907 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1908 DIE *CompileUnit::getOrCreateStaticMemberDIE(const DIDerivedType DT) {
1912 // Construct the context before querying for the existence of the DIE in case
1913 // such construction creates the DIE.
1914 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1915 assert(ContextDIE && "Static member should belong to a non-CU context.");
1917 DIE *StaticMemberDIE = getDIE(DT);
1918 if (StaticMemberDIE)
1919 return StaticMemberDIE;
1921 StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1923 DIType Ty = resolve(DT.getTypeDerivedFrom());
1925 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1926 addType(StaticMemberDIE, Ty);
1927 addSourceLine(StaticMemberDIE, DT);
1928 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1929 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1931 // FIXME: We could omit private if the parent is a class_type, and
1932 // public if the parent is something else.
1933 if (DT.isProtected())
1934 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1935 dwarf::DW_ACCESS_protected);
1936 else if (DT.isPrivate())
1937 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1938 dwarf::DW_ACCESS_private);
1940 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1941 dwarf::DW_ACCESS_public);
1943 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1944 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1945 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1946 addConstantFPValue(StaticMemberDIE, CFP);
1948 return StaticMemberDIE;
1951 void CompileUnit::emitHeader(const MCSection *ASection,
1952 const MCSymbol *ASectionSym) {
1953 Asm->OutStreamer.AddComment("DWARF version number");
1954 Asm->EmitInt16(DD->getDwarfVersion());
1955 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1956 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1958 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1959 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());