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, DICompileUnit Node,
37 AsmPrinter *A, DwarfDebug *DW, DwarfUnits *DWU)
38 : UniqueID(UID), Node(Node), CUDie(D), Asm(A), DD(DW), DU(DWU),
39 IndexTyDie(0), DebugInfoOffset(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 (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(DIDescriptor D) {
103 // When the MDNode can be part of the type system, the DIE can be
104 // shared across CUs.
105 return D.isType() || (D.isSubprogram() && !DISubprogram(D).isDefinition());
108 /// getDIE - Returns the debug information entry map slot for the
109 /// specified debug variable. We delegate the request to DwarfDebug
110 /// when the DIE for this MDNode can be shared across CUs. The mappings
111 /// will be kept in DwarfDebug for shareable DIEs.
112 DIE *CompileUnit::getDIE(DIDescriptor D) const {
113 if (isShareableAcrossCUs(D))
114 return DD->getDIE(D);
115 return MDNodeToDieMap.lookup(D);
118 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
119 /// when the DIE for this MDNode can be shared across CUs. The mappings
120 /// will be kept in DwarfDebug for shareable DIEs.
121 void CompileUnit::insertDIE(DIDescriptor Desc, DIE *D) {
122 if (isShareableAcrossCUs(Desc)) {
123 DD->insertDIE(Desc, D);
126 MDNodeToDieMap.insert(std::make_pair(Desc, D));
129 /// addFlag - Add a flag that is true.
130 void CompileUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
131 if (DD->getDwarfVersion() >= 4)
132 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
134 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
137 /// addUInt - Add an unsigned integer attribute data and value.
139 void CompileUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
140 Optional<dwarf::Form> Form, uint64_t Integer) {
142 Form = DIEInteger::BestForm(false, Integer);
143 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
145 Die->addValue(Attribute, *Form, Value);
148 void CompileUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
149 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
152 /// addSInt - Add an signed integer attribute data and value.
154 void CompileUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
155 Optional<dwarf::Form> Form, int64_t Integer) {
157 Form = DIEInteger::BestForm(true, Integer);
158 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
159 Die->addValue(Attribute, *Form, Value);
162 void CompileUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
164 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
167 /// addString - Add a string attribute data and value. We always emit a
168 /// reference to the string pool instead of immediate strings so that DIEs have
169 /// more predictable sizes. In the case of split dwarf we emit an index
170 /// into another table which gets us the static offset into the string
172 void CompileUnit::addString(DIE *Die, dwarf::Attribute Attribute,
176 if (!DD->useSplitDwarf()) {
177 MCSymbol *Symb = DU->getStringPoolEntry(String);
178 if (Asm->needsRelocationsForDwarfStringPool())
179 Value = new (DIEValueAllocator) DIELabel(Symb);
181 MCSymbol *StringPool = DU->getStringPoolSym();
182 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
184 Form = dwarf::DW_FORM_strp;
186 unsigned idx = DU->getStringPoolIndex(String);
187 Value = new (DIEValueAllocator) DIEInteger(idx);
188 Form = dwarf::DW_FORM_GNU_str_index;
190 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
191 Die->addValue(Attribute, Form, Str);
194 /// addLocalString - Add a string attribute data and value. This is guaranteed
195 /// to be in the local string pool instead of indirected.
196 void CompileUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
198 MCSymbol *Symb = DU->getStringPoolEntry(String);
200 if (Asm->needsRelocationsForDwarfStringPool())
201 Value = new (DIEValueAllocator) DIELabel(Symb);
203 MCSymbol *StringPool = DU->getStringPoolSym();
204 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
206 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
209 /// addExpr - Add a Dwarf expression attribute data and value.
211 void CompileUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
212 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
213 Die->addValue((dwarf::Attribute)0, Form, Value);
216 /// addLabel - Add a Dwarf label attribute data and value.
218 void CompileUnit::addLabel(DIE *Die, dwarf::Attribute Attribute,
219 dwarf::Form Form, const MCSymbol *Label) {
220 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
221 Die->addValue(Attribute, Form, Value);
224 void CompileUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
225 const MCSymbol *Label) {
226 addLabel(Die, (dwarf::Attribute)0, Form, Label);
229 /// addLabelAddress - Add a dwarf label attribute data and value using
230 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
232 void CompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
235 DD->addArangeLabel(SymbolCU(this, Label));
237 if (!DD->useSplitDwarf()) {
239 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
240 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
242 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
243 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
246 unsigned idx = DU->getAddrPoolIndex(Label);
247 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
248 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
252 /// addOpAddress - Add a dwarf op address data and value using the
253 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
255 void CompileUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
256 DD->addArangeLabel(SymbolCU(this, Sym));
257 if (!DD->useSplitDwarf()) {
258 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
259 addLabel(Die, dwarf::DW_FORM_udata, Sym);
261 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
262 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
266 /// addDelta - Add a label delta attribute data and value.
268 void CompileUnit::addDelta(DIE *Die, dwarf::Attribute Attribute,
269 dwarf::Form Form, const MCSymbol *Hi,
270 const MCSymbol *Lo) {
271 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
272 Die->addValue(Attribute, Form, Value);
275 /// addDIEEntry - Add a DIE attribute data and value.
277 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
279 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
282 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
284 const DIE *DieCU = Die->getCompileUnitOrNull();
285 const DIE *EntryCU = Entry->getEntry()->getCompileUnitOrNull();
287 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
290 EntryCU = getCUDie();
291 Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
292 : dwarf::DW_FORM_ref_addr,
296 /// Create a DIE with the given Tag, add the DIE to its parent, and
297 /// call insertDIE if MD is not null.
298 DIE *CompileUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
299 DIE *Die = new DIE(Tag);
300 Parent.addChild(Die);
306 /// addBlock - Add block data.
308 void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
310 Block->ComputeSize(Asm);
311 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
312 Die->addValue(Attribute, Block->BestForm(), Block);
315 /// addSourceLine - Add location information to specified debug information
317 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
322 unsigned Line = V.getLineNumber();
326 DD->getOrCreateSourceID(V.getContext().getFilename(),
327 V.getContext().getDirectory(), getUniqueID());
328 assert(FileID && "Invalid file id");
329 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
330 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
333 /// addSourceLine - Add location information to specified debug information
335 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
336 // Verify global variable.
337 if (!G.isGlobalVariable())
340 unsigned Line = G.getLineNumber();
344 DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
345 assert(FileID && "Invalid file id");
346 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
347 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
350 /// addSourceLine - Add location information to specified debug information
352 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
353 // Verify subprogram.
354 if (!SP.isSubprogram())
357 // If the line number is 0, don't add it.
358 unsigned Line = SP.getLineNumber();
362 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
364 assert(FileID && "Invalid file id");
365 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
366 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
369 /// addSourceLine - Add location information to specified debug information
371 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
376 unsigned Line = Ty.getLineNumber();
379 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
381 assert(FileID && "Invalid file id");
382 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
383 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
386 /// addSourceLine - Add location information to specified debug information
388 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
390 if (!Ty.isObjCProperty())
393 unsigned Line = Ty.getLineNumber();
396 DIFile File = Ty.getFile();
397 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
398 File.getDirectory(), getUniqueID());
399 assert(FileID && "Invalid file id");
400 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
401 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
404 /// addSourceLine - Add location information to specified debug information
406 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
411 unsigned Line = NS.getLineNumber();
414 StringRef FN = NS.getFilename();
417 DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
418 assert(FileID && "Invalid file id");
419 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
420 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
423 /// addVariableAddress - Add DW_AT_location attribute for a
424 /// DbgVariable based on provided MachineLocation.
425 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
426 MachineLocation Location) {
427 if (DV.variableHasComplexAddress())
428 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
429 else if (DV.isBlockByrefVariable())
430 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
432 addAddress(Die, dwarf::DW_AT_location, Location,
433 DV.getVariable().isIndirect());
436 /// addRegisterOp - Add register operand.
437 void CompileUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
438 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
439 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
441 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
443 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
444 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
448 /// addRegisterOffset - Add register offset.
449 void CompileUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
451 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
452 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
453 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
454 if (Reg == TRI->getFrameRegister(*Asm->MF))
455 // If variable offset is based in frame register then use fbreg.
456 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
458 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
460 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
461 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
463 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
466 /// addAddress - Add an address attribute to a die based on the location
468 void CompileUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
469 const MachineLocation &Location, bool Indirect) {
470 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
472 if (Location.isReg() && !Indirect)
473 addRegisterOp(Block, Location.getReg());
475 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
476 if (Indirect && !Location.isReg()) {
477 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
481 // Now attach the location information to the DIE.
482 addBlock(Die, Attribute, Block);
485 /// addComplexAddress - Start with the address based on the location provided,
486 /// and generate the DWARF information necessary to find the actual variable
487 /// given the extra address information encoded in the DIVariable, starting from
488 /// the starting location. Add the DWARF information to the die.
490 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
491 dwarf::Attribute Attribute,
492 const MachineLocation &Location) {
493 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
494 unsigned N = DV.getNumAddrElements();
496 if (Location.isReg()) {
497 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
498 // If first address element is OpPlus then emit
499 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
500 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
503 addRegisterOp(Block, Location.getReg());
505 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
508 uint64_t Element = DV.getAddrElement(i);
509 if (Element == DIBuilder::OpPlus) {
510 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
511 addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
512 } else if (Element == DIBuilder::OpDeref) {
513 if (!Location.isReg())
514 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
516 llvm_unreachable("unknown DIBuilder Opcode");
519 // Now attach the location information to the DIE.
520 addBlock(Die, Attribute, Block);
523 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
524 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
525 gives the variable VarName either the struct, or a pointer to the struct, as
526 its type. This is necessary for various behind-the-scenes things the
527 compiler needs to do with by-reference variables in Blocks.
529 However, as far as the original *programmer* is concerned, the variable
530 should still have type 'SomeType', as originally declared.
532 The function getBlockByrefType dives into the __Block_byref_x_VarName
533 struct to find the original type of the variable, which is then assigned to
534 the variable's Debug Information Entry as its real type. So far, so good.
535 However now the debugger will expect the variable VarName to have the type
536 SomeType. So we need the location attribute for the variable to be an
537 expression that explains to the debugger how to navigate through the
538 pointers and struct to find the actual variable of type SomeType.
540 The following function does just that. We start by getting
541 the "normal" location for the variable. This will be the location
542 of either the struct __Block_byref_x_VarName or the pointer to the
543 struct __Block_byref_x_VarName.
545 The struct will look something like:
547 struct __Block_byref_x_VarName {
549 struct __Block_byref_x_VarName *forwarding;
550 ... <various other fields>
552 ... <maybe more fields>
555 If we are given the struct directly (as our starting point) we
556 need to tell the debugger to:
558 1). Add the offset of the forwarding field.
560 2). Follow that pointer to get the real __Block_byref_x_VarName
561 struct to use (the real one may have been copied onto the heap).
563 3). Add the offset for the field VarName, to find the actual variable.
565 If we started with a pointer to the struct, then we need to
566 dereference that pointer first, before the other steps.
567 Translating this into DWARF ops, we will need to append the following
568 to the current location description for the variable:
570 DW_OP_deref -- optional, if we start with a pointer
571 DW_OP_plus_uconst <forward_fld_offset>
573 DW_OP_plus_uconst <varName_fld_offset>
575 That is what this function does. */
577 /// addBlockByrefAddress - Start with the address based on the location
578 /// provided, and generate the DWARF information necessary to find the
579 /// actual Block variable (navigating the Block struct) based on the
580 /// starting location. Add the DWARF information to the die. For
581 /// more information, read large comment just above here.
583 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
584 dwarf::Attribute Attribute,
585 const MachineLocation &Location) {
586 DIType Ty = DV.getType();
588 uint16_t Tag = Ty.getTag();
589 bool isPointer = false;
591 StringRef varName = DV.getName();
593 if (Tag == dwarf::DW_TAG_pointer_type) {
594 DIDerivedType DTy(Ty);
595 TmpTy = resolve(DTy.getTypeDerivedFrom());
599 DICompositeType blockStruct(TmpTy);
601 // Find the __forwarding field and the variable field in the __Block_byref
603 DIArray Fields = blockStruct.getTypeArray();
604 DIDerivedType varField;
605 DIDerivedType forwardingField;
607 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
608 DIDerivedType DT(Fields.getElement(i));
609 StringRef fieldName = DT.getName();
610 if (fieldName == "__forwarding")
611 forwardingField = DT;
612 else if (fieldName == varName)
616 // Get the offsets for the forwarding field and the variable field.
617 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
618 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
620 // Decode the original location, and use that as the start of the byref
621 // variable's location.
622 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
624 if (Location.isReg())
625 addRegisterOp(Block, Location.getReg());
627 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
629 // If we started with a pointer to the __Block_byref... struct, then
630 // the first thing we need to do is dereference the pointer (DW_OP_deref).
632 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
634 // Next add the offset for the '__forwarding' field:
635 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
636 // adding the offset if it's 0.
637 if (forwardingFieldOffset > 0) {
638 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
639 addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
642 // Now dereference the __forwarding field to get to the real __Block_byref
643 // struct: DW_OP_deref.
644 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
646 // Now that we've got the real __Block_byref... struct, add the offset
647 // for the variable's field to get to the location of the actual variable:
648 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
649 if (varFieldOffset > 0) {
650 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
651 addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
654 // Now attach the location information to the DIE.
655 addBlock(Die, Attribute, Block);
658 /// isTypeSigned - Return true if the type is signed.
659 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
660 if (Ty.isDerivedType())
661 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
663 if (Ty.isBasicType())
664 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
665 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
666 *SizeInBits = Ty.getSizeInBits();
672 /// Return true if type encoding is unsigned.
673 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
674 DIDerivedType DTy(Ty);
675 if (DTy.isDerivedType())
676 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
679 if (BTy.isBasicType()) {
680 unsigned Encoding = BTy.getEncoding();
681 if (Encoding == dwarf::DW_ATE_unsigned ||
682 Encoding == dwarf::DW_ATE_unsigned_char ||
683 Encoding == dwarf::DW_ATE_boolean)
689 /// If this type is derived from a base type then return base type size.
690 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
691 unsigned Tag = Ty.getTag();
693 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
694 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
695 Tag != dwarf::DW_TAG_restrict_type)
696 return Ty.getSizeInBits();
698 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
700 // If this type is not derived from any type then take conservative approach.
701 if (!BaseType.isValid())
702 return Ty.getSizeInBits();
704 // If this is a derived type, go ahead and get the base type, unless it's a
705 // reference then it's just the size of the field. Pointer types have no need
706 // of this since they're a different type of qualification on the type.
707 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
708 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
709 return Ty.getSizeInBits();
711 if (BaseType.isDerivedType())
712 return getBaseTypeSize(DD, DIDerivedType(BaseType));
714 return BaseType.getSizeInBits();
717 /// addConstantValue - Add constant value entry in variable DIE.
718 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
720 // FIXME: This is a bit conservative/simple - it emits negative values at
721 // their maximum bit width which is a bit unfortunate (& doesn't prefer
722 // udata/sdata over dataN as suggested by the DWARF spec)
723 assert(MO.isImm() && "Invalid machine operand!");
725 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
728 // If we're a signed constant definitely use sdata.
729 if (SignedConstant) {
730 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
734 // Else use data for now unless it's larger than we can deal with.
735 switch (SizeInBits) {
737 Form = dwarf::DW_FORM_data1;
740 Form = dwarf::DW_FORM_data2;
743 Form = dwarf::DW_FORM_data4;
746 Form = dwarf::DW_FORM_data8;
749 Form = dwarf::DW_FORM_udata;
750 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
753 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
756 /// addConstantFPValue - Add constant value entry in variable DIE.
757 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
758 assert(MO.isFPImm() && "Invalid machine operand!");
759 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
760 APFloat FPImm = MO.getFPImm()->getValueAPF();
762 // Get the raw data form of the floating point.
763 const APInt FltVal = FPImm.bitcastToAPInt();
764 const char *FltPtr = (const char *)FltVal.getRawData();
766 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
767 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
768 int Incr = (LittleEndian ? 1 : -1);
769 int Start = (LittleEndian ? 0 : NumBytes - 1);
770 int Stop = (LittleEndian ? NumBytes : -1);
772 // Output the constant to DWARF one byte at a time.
773 for (; Start != Stop; Start += Incr)
774 addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
776 addBlock(Die, dwarf::DW_AT_const_value, Block);
779 /// addConstantFPValue - Add constant value entry in variable DIE.
780 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
781 // Pass this down to addConstantValue as an unsigned bag of bits.
782 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
785 /// addConstantValue - Add constant value entry in variable DIE.
786 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
788 addConstantValue(Die, CI->getValue(), Unsigned);
791 // addConstantValue - Add constant value entry in variable DIE.
792 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
793 unsigned CIBitWidth = Val.getBitWidth();
794 if (CIBitWidth <= 64) {
795 // If we're a signed constant definitely use sdata.
797 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
802 // Else use data for now unless it's larger than we can deal with.
804 switch (CIBitWidth) {
806 Form = dwarf::DW_FORM_data1;
809 Form = dwarf::DW_FORM_data2;
812 Form = dwarf::DW_FORM_data4;
815 Form = dwarf::DW_FORM_data8;
818 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
822 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
826 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
828 // Get the raw data form of the large APInt.
829 const uint64_t *Ptr64 = Val.getRawData();
831 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
832 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
834 // Output the constant to DWARF one byte at a time.
835 for (int i = 0; i < NumBytes; i++) {
838 c = Ptr64[i / 8] >> (8 * (i & 7));
840 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
841 addUInt(Block, dwarf::DW_FORM_data1, c);
844 addBlock(Die, dwarf::DW_AT_const_value, Block);
847 /// addTemplateParams - Add template parameters into buffer.
848 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
849 // Add template parameters.
850 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
851 DIDescriptor Element = TParams.getElement(i);
852 if (Element.isTemplateTypeParameter())
853 constructTemplateTypeParameterDIE(Buffer,
854 DITemplateTypeParameter(Element));
855 else if (Element.isTemplateValueParameter())
856 constructTemplateValueParameterDIE(Buffer,
857 DITemplateValueParameter(Element));
861 /// getOrCreateContextDIE - Get context owner's DIE.
862 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
863 if (!Context || Context.isFile())
865 if (Context.isType())
866 return getOrCreateTypeDIE(DIType(Context));
867 if (Context.isNameSpace())
868 return getOrCreateNameSpace(DINameSpace(Context));
869 if (Context.isSubprogram())
870 return getOrCreateSubprogramDIE(DISubprogram(Context));
871 return getDIE(Context);
874 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
876 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()));
888 DIE *TyDIE = getDIE(Ty);
893 TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
895 if (Ty.isBasicType())
896 constructTypeDIE(*TyDIE, DIBasicType(Ty));
897 else if (Ty.isCompositeType())
898 constructTypeDIE(*TyDIE, DICompositeType(Ty));
900 assert(Ty.isDerivedType() && "Unknown kind of DIType");
901 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
903 // If this is a named finished type then include it in the list of types
904 // for the accelerator tables.
905 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
906 bool IsImplementation = 0;
907 if (Ty.isCompositeType()) {
908 DICompositeType CT(Ty);
909 // A runtime language of 0 actually means C/C++ and that any
910 // non-negative value is some version of Objective-C/C++.
911 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
913 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
914 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
920 /// addType - Add a new type attribute to the specified entity.
921 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
922 assert(Ty && "Trying to add a type that doesn't exist?");
924 // Check for pre-existence.
925 DIEEntry *Entry = getDIEEntry(Ty);
926 // If it exists then use the existing value.
928 addDIEEntry(Entity, Attribute, Entry);
933 DIE *Buffer = getOrCreateTypeDIE(Ty);
936 Entry = createDIEEntry(Buffer);
937 insertDIEEntry(Ty, Entry);
938 addDIEEntry(Entity, Attribute, Entry);
940 // If this is a complete composite type then include it in the
941 // list of global types.
945 // Accelerator table mutators - add each name along with its companion
946 // DIE to the proper table while ensuring that the name that we're going
947 // to reference is in the string table. We do this since the names we
948 // add may not only be identical to the names in the DIE.
949 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
950 DU->getStringPoolEntry(Name);
951 std::vector<DIE *> &DIEs = AccelNames[Name];
955 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
956 DU->getStringPoolEntry(Name);
957 std::vector<DIE *> &DIEs = AccelObjC[Name];
961 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
962 DU->getStringPoolEntry(Name);
963 std::vector<DIE *> &DIEs = AccelNamespace[Name];
967 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
968 DU->getStringPoolEntry(Name);
969 std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
973 /// addGlobalName - Add a new global name to the compile unit.
974 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
975 std::string FullName = getParentContextString(Context) + Name.str();
976 GlobalNames[FullName] = Die;
979 /// addGlobalType - Add a new global type to the compile unit.
981 void CompileUnit::addGlobalType(DIType Ty) {
982 DIScope Context = resolve(Ty.getContext());
983 if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
984 (!Context || Context.isCompileUnit() || Context.isFile() ||
985 Context.isNameSpace()))
986 if (DIEEntry *Entry = getDIEEntry(Ty)) {
987 std::string FullName =
988 getParentContextString(Context) + Ty.getName().str();
989 GlobalTypes[FullName] = Entry->getEntry();
993 /// getParentContextString - Walks the metadata parent chain in a language
994 /// specific manner (using the compile unit language) and returns
995 /// it as a string. This is done at the metadata level because DIEs may
996 /// not currently have been added to the parent context and walking the
997 /// DIEs looking for names is more expensive than walking the metadata.
998 std::string CompileUnit::getParentContextString(DIScope Context) const {
1002 // FIXME: Decide whether to implement this for non-C++ languages.
1003 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
1007 SmallVector<DIScope, 1> Parents;
1008 while (!Context.isCompileUnit()) {
1009 Parents.push_back(Context);
1010 if (Context.getContext())
1011 Context = resolve(Context.getContext());
1013 // Structure, etc types will have a NULL context if they're at the top
1018 // Reverse iterate over our list to go from the outermost construct to the
1020 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
1024 StringRef Name = Ctx.getName();
1025 if (!Name.empty()) {
1033 /// addPubTypes - Add subprogram argument types for pubtypes section.
1034 void CompileUnit::addPubTypes(DISubprogram SP) {
1035 DICompositeType SPTy = SP.getType();
1036 uint16_t SPTag = SPTy.getTag();
1037 if (SPTag != dwarf::DW_TAG_subroutine_type)
1040 DIArray Args = SPTy.getTypeArray();
1041 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1042 DIType ATy(Args.getElement(i));
1049 /// constructTypeDIE - Construct basic type die from DIBasicType.
1050 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1051 // Get core information.
1052 StringRef Name = BTy.getName();
1053 // Add name if not anonymous or intermediate type.
1055 addString(&Buffer, dwarf::DW_AT_name, Name);
1057 // An unspecified type only has a name attribute.
1058 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1061 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1064 uint64_t Size = BTy.getSizeInBits() >> 3;
1065 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1068 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1069 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1070 // Get core information.
1071 StringRef Name = DTy.getName();
1072 uint64_t Size = DTy.getSizeInBits() >> 3;
1073 uint16_t Tag = Buffer.getTag();
1075 // Map to main type, void will not have a type.
1076 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1078 addType(&Buffer, FromTy);
1080 // Add name if not anonymous or intermediate type.
1082 addString(&Buffer, dwarf::DW_AT_name, Name);
1084 // Add size if non-zero (derived types might be zero-sized.)
1085 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1086 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1088 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1089 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1090 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1091 // Add source line info if available and TyDesc is not a forward declaration.
1092 if (!DTy.isForwardDecl())
1093 addSourceLine(&Buffer, DTy);
1096 /// Return true if the type is appropriately scoped to be contained inside
1097 /// its own type unit.
1098 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1099 DIScope Parent = DD->resolve(Ty.getContext());
1101 // Don't generate a hash for anything scoped inside a function.
1102 if (Parent.isSubprogram())
1104 Parent = DD->resolve(Parent.getContext());
1109 /// Return true if the type should be split out into a type unit.
1110 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1111 uint16_t Tag = CTy.getTag();
1114 case dwarf::DW_TAG_structure_type:
1115 case dwarf::DW_TAG_union_type:
1116 case dwarf::DW_TAG_enumeration_type:
1117 case dwarf::DW_TAG_class_type:
1118 // If this is a class, structure, union, or enumeration type
1119 // that is a definition (not a declaration), and not scoped
1120 // inside a function then separate this out as a type unit.
1121 return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1127 /// constructTypeDIE - Construct type DIE from DICompositeType.
1128 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1129 // Get core information.
1130 StringRef Name = CTy.getName();
1132 uint64_t Size = CTy.getSizeInBits() >> 3;
1133 uint16_t Tag = Buffer.getTag();
1136 case dwarf::DW_TAG_array_type:
1137 constructArrayTypeDIE(Buffer, CTy);
1139 case dwarf::DW_TAG_enumeration_type:
1140 constructEnumTypeDIE(Buffer, CTy);
1142 case dwarf::DW_TAG_subroutine_type: {
1143 // Add return type. A void return won't have a type.
1144 DIArray Elements = CTy.getTypeArray();
1145 DIType RTy(Elements.getElement(0));
1147 addType(&Buffer, RTy);
1149 bool isPrototyped = true;
1151 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1152 DIDescriptor Ty = Elements.getElement(i);
1153 if (Ty.isUnspecifiedParameter()) {
1154 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
1155 isPrototyped = false;
1157 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
1158 addType(Arg, DIType(Ty));
1159 if (DIType(Ty).isArtificial())
1160 addFlag(Arg, dwarf::DW_AT_artificial);
1163 // Add prototype flag if we're dealing with a C language and the
1164 // function has been prototyped.
1165 uint16_t Language = getLanguage();
1167 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1168 Language == dwarf::DW_LANG_ObjC))
1169 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1171 case dwarf::DW_TAG_structure_type:
1172 case dwarf::DW_TAG_union_type:
1173 case dwarf::DW_TAG_class_type: {
1174 // Add elements to structure type.
1175 DIArray Elements = CTy.getTypeArray();
1176 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1177 DIDescriptor Element = Elements.getElement(i);
1178 DIE *ElemDie = NULL;
1179 if (Element.isSubprogram()) {
1180 DISubprogram SP(Element);
1181 ElemDie = getOrCreateSubprogramDIE(SP);
1182 if (SP.isProtected())
1183 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1184 dwarf::DW_ACCESS_protected);
1185 else if (SP.isPrivate())
1186 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1187 dwarf::DW_ACCESS_private);
1189 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1190 dwarf::DW_ACCESS_public);
1191 if (SP.isExplicit())
1192 addFlag(ElemDie, dwarf::DW_AT_explicit);
1193 } else if (Element.isDerivedType()) {
1194 DIDerivedType DDTy(Element);
1195 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1196 ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1197 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1198 dwarf::DW_AT_friend);
1199 } else if (DDTy.isStaticMember()) {
1200 getOrCreateStaticMemberDIE(DDTy);
1202 constructMemberDIE(Buffer, DDTy);
1204 } else if (Element.isObjCProperty()) {
1205 DIObjCProperty Property(Element);
1206 ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1207 StringRef PropertyName = Property.getObjCPropertyName();
1208 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1209 addType(ElemDie, Property.getType());
1210 addSourceLine(ElemDie, Property);
1211 StringRef GetterName = Property.getObjCPropertyGetterName();
1212 if (!GetterName.empty())
1213 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1214 StringRef SetterName = Property.getObjCPropertySetterName();
1215 if (!SetterName.empty())
1216 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1217 unsigned PropertyAttributes = 0;
1218 if (Property.isReadOnlyObjCProperty())
1219 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1220 if (Property.isReadWriteObjCProperty())
1221 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1222 if (Property.isAssignObjCProperty())
1223 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1224 if (Property.isRetainObjCProperty())
1225 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1226 if (Property.isCopyObjCProperty())
1227 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1228 if (Property.isNonAtomicObjCProperty())
1229 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1230 if (PropertyAttributes)
1231 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1232 PropertyAttributes);
1234 DIEEntry *Entry = getDIEEntry(Element);
1236 Entry = createDIEEntry(ElemDie);
1237 insertDIEEntry(Element, Entry);
1243 if (CTy.isAppleBlockExtension())
1244 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1246 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1248 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1249 getOrCreateTypeDIE(ContainingType));
1251 if (CTy.isObjcClassComplete())
1252 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1254 // Add template parameters to a class, structure or union types.
1255 // FIXME: The support isn't in the metadata for this yet.
1256 if (Tag == dwarf::DW_TAG_class_type ||
1257 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1258 addTemplateParams(Buffer, CTy.getTemplateParams());
1266 // Add name if not anonymous or intermediate type.
1268 addString(&Buffer, dwarf::DW_AT_name, Name);
1270 if (Tag == dwarf::DW_TAG_enumeration_type ||
1271 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1272 Tag == dwarf::DW_TAG_union_type) {
1273 // Add size if non-zero (derived types might be zero-sized.)
1274 // TODO: Do we care about size for enum forward declarations?
1276 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1277 else if (!CTy.isForwardDecl())
1278 // Add zero size if it is not a forward declaration.
1279 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1281 // If we're a forward decl, say so.
1282 if (CTy.isForwardDecl())
1283 addFlag(&Buffer, dwarf::DW_AT_declaration);
1285 // Add source line info if available.
1286 if (!CTy.isForwardDecl())
1287 addSourceLine(&Buffer, CTy);
1289 // No harm in adding the runtime language to the declaration.
1290 unsigned RLang = CTy.getRunTimeLang();
1292 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1295 // If this is a type applicable to a type unit it then add it to the
1296 // list of types we'll compute a hash for later.
1297 if (shouldCreateTypeUnit(CTy, DD))
1298 DD->addTypeUnitType(&Buffer);
1301 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1302 /// DITemplateTypeParameter.
1304 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1305 DITemplateTypeParameter TP) {
1307 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1308 // Add the type if it exists, it could be void and therefore no type.
1310 addType(ParamDIE, resolve(TP.getType()));
1311 if (!TP.getName().empty())
1312 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1315 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1316 /// DITemplateValueParameter.
1318 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1319 DITemplateValueParameter VP) {
1320 DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1322 // Add the type if there is one, template template and template parameter
1323 // packs will not have a type.
1324 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1325 addType(ParamDIE, resolve(VP.getType()));
1326 if (!VP.getName().empty())
1327 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1328 if (Value *Val = VP.getValue()) {
1329 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1330 addConstantValue(ParamDIE, CI,
1331 isUnsignedDIType(DD, resolve(VP.getType())));
1332 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1333 // For declaration non-type template parameters (such as global values and
1335 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1336 addOpAddress(Block, Asm->getSymbol(GV));
1337 // Emit DW_OP_stack_value to use the address as the immediate value of the
1338 // parameter, rather than a pointer to it.
1339 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1340 addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1341 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1342 assert(isa<MDString>(Val));
1343 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1344 cast<MDString>(Val)->getString());
1345 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1346 assert(isa<MDNode>(Val));
1347 DIArray A(cast<MDNode>(Val));
1348 addTemplateParams(*ParamDIE, A);
1353 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1354 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1355 // Construct the context before querying for the existence of the DIE in case
1356 // such construction creates the DIE.
1357 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1359 DIE *NDie = getDIE(NS);
1362 NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1364 if (!NS.getName().empty()) {
1365 addString(NDie, dwarf::DW_AT_name, NS.getName());
1366 addAccelNamespace(NS.getName(), NDie);
1367 addGlobalName(NS.getName(), NDie, NS.getContext());
1369 addAccelNamespace("(anonymous namespace)", NDie);
1370 addSourceLine(NDie, NS);
1374 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1375 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1376 // Construct the context before querying for the existence of the DIE in case
1377 // such construction creates the DIE (as is the case for member function
1379 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1381 DIE *SPDie = getDIE(SP);
1385 DISubprogram SPDecl = SP.getFunctionDeclaration();
1386 if (SPDecl.isSubprogram())
1387 // Add subprogram definitions to the CU die directly.
1388 ContextDIE = CUDie.get();
1390 // DW_TAG_inlined_subroutine may refer to this DIE.
1391 SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1393 DIE *DeclDie = NULL;
1394 if (SPDecl.isSubprogram())
1395 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1397 // Add function template parameters.
1398 addTemplateParams(*SPDie, SP.getTemplateParams());
1400 // If this DIE is going to refer declaration info using AT_specification
1401 // then there is no need to add other attributes.
1403 // Refer function declaration directly.
1404 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1409 // Add the linkage name if we have one.
1410 StringRef LinkageName = SP.getLinkageName();
1411 if (!LinkageName.empty())
1412 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1413 GlobalValue::getRealLinkageName(LinkageName));
1415 // Constructors and operators for anonymous aggregates do not have names.
1416 if (!SP.getName().empty())
1417 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1419 addSourceLine(SPDie, SP);
1421 // Add the prototype if we have a prototype and we have a C like
1423 uint16_t Language = getLanguage();
1424 if (SP.isPrototyped() &&
1425 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1426 Language == dwarf::DW_LANG_ObjC))
1427 addFlag(SPDie, dwarf::DW_AT_prototyped);
1429 DICompositeType SPTy = SP.getType();
1430 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1431 "the type of a subprogram should be a subroutine");
1433 DIArray Args = SPTy.getTypeArray();
1434 // Add a return type. If this is a type like a C/C++ void type we don't add a
1436 if (Args.getElement(0))
1437 addType(SPDie, DIType(Args.getElement(0)));
1439 unsigned VK = SP.getVirtuality();
1441 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1442 DIEBlock *Block = getDIEBlock();
1443 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1444 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1445 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1446 ContainingTypeMap.insert(
1447 std::make_pair(SPDie, resolve(SP.getContainingType())));
1450 if (!SP.isDefinition()) {
1451 addFlag(SPDie, dwarf::DW_AT_declaration);
1453 // Add arguments. Do not add arguments for subprogram definition. They will
1454 // be handled while processing variables.
1455 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1456 DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
1457 DIType ATy(Args.getElement(i));
1459 if (ATy.isArtificial())
1460 addFlag(Arg, dwarf::DW_AT_artificial);
1464 if (SP.isArtificial())
1465 addFlag(SPDie, dwarf::DW_AT_artificial);
1467 if (!SP.isLocalToUnit())
1468 addFlag(SPDie, dwarf::DW_AT_external);
1470 if (SP.isOptimized())
1471 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1473 if (unsigned isa = Asm->getISAEncoding()) {
1474 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1480 // Return const expression if value is a GEP to access merged global
1482 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1483 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1484 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1485 if (!CE || CE->getNumOperands() != 3 ||
1486 CE->getOpcode() != Instruction::GetElementPtr)
1489 // First operand points to a global struct.
1490 Value *Ptr = CE->getOperand(0);
1491 if (!isa<GlobalValue>(Ptr) ||
1492 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1495 // Second operand is zero.
1496 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1497 if (!CI || !CI->isZero())
1500 // Third operand is offset.
1501 if (!isa<ConstantInt>(CE->getOperand(2)))
1507 /// createGlobalVariableDIE - create global variable DIE.
1508 void CompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
1510 // Check for pre-existence.
1514 if (!GV.isGlobalVariable())
1517 DIScope GVContext = GV.getContext();
1518 DIType GTy = GV.getType();
1520 // If this is a static data member definition, some attributes belong
1521 // to the declaration DIE.
1522 DIE *VariableDIE = NULL;
1523 bool IsStaticMember = false;
1524 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1525 if (SDMDecl.Verify()) {
1526 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1527 // We need the declaration DIE that is in the static member's class.
1528 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1529 IsStaticMember = true;
1532 // If this is not a static data member definition, create the variable
1533 // DIE and add the initial set of attributes to it.
1535 // Construct the context before querying for the existence of the DIE in
1536 // case such construction creates the DIE.
1537 DIE *ContextDIE = getOrCreateContextDIE(GVContext);
1540 VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
1542 // Add name and type.
1543 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1544 addType(VariableDIE, GTy);
1546 // Add scoping info.
1547 if (!GV.isLocalToUnit())
1548 addFlag(VariableDIE, dwarf::DW_AT_external);
1550 // Add line number info.
1551 addSourceLine(VariableDIE, GV);
1555 bool addToAccelTable = false;
1556 DIE *VariableSpecDIE = NULL;
1557 bool isGlobalVariable = GV.getGlobal() != NULL;
1558 if (isGlobalVariable) {
1559 addToAccelTable = true;
1560 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1561 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
1562 if (GV.getGlobal()->isThreadLocal()) {
1563 // FIXME: Make this work with -gsplit-dwarf.
1564 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1565 assert((PointerSize == 4 || PointerSize == 8) &&
1566 "Add support for other sizes if necessary");
1567 const MCExpr *Expr =
1568 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1569 // Based on GCC's support for TLS:
1570 if (!DD->useSplitDwarf()) {
1571 // 1) Start with a constNu of the appropriate pointer size
1572 addUInt(Block, dwarf::DW_FORM_data1,
1573 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1574 // 2) containing the (relocated) offset of the TLS variable
1575 // within the module's TLS block.
1576 addExpr(Block, dwarf::DW_FORM_udata, Expr);
1578 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1579 addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1581 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1582 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1584 addOpAddress(Block, Sym);
1585 // Do not create specification DIE if context is either compile unit
1587 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1588 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1589 // Create specification DIE.
1590 VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie);
1591 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1592 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1593 // A static member's declaration is already flagged as such.
1594 if (!SDMDecl.Verify())
1595 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1597 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1599 // Add the linkage name.
1600 StringRef LinkageName = GV.getLinkageName();
1601 if (!LinkageName.empty())
1602 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1603 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1605 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1607 dwarf::DW_AT_MIPS_linkage_name,
1608 GlobalValue::getRealLinkageName(LinkageName));
1609 } else if (const ConstantInt *CI =
1610 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1611 // AT_const_value was added when the static member was created. To avoid
1612 // emitting AT_const_value multiple times, we only add AT_const_value when
1613 // it is not a static member.
1614 if (!IsStaticMember)
1615 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1616 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
1617 addToAccelTable = true;
1618 // GV is a merged global.
1619 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1620 Value *Ptr = CE->getOperand(0);
1621 addOpAddress(Block, Asm->getSymbol(cast<GlobalValue>(Ptr)));
1622 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1623 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1624 addUInt(Block, dwarf::DW_FORM_udata,
1625 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1626 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1627 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1630 if (addToAccelTable) {
1631 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1632 addAccelName(GV.getName(), AddrDIE);
1634 // If the linkage name is different than the name, go ahead and output
1635 // that as well into the name table.
1636 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1637 addAccelName(GV.getLinkageName(), AddrDIE);
1640 if (!GV.isLocalToUnit())
1641 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1645 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1646 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1648 DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1649 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1651 // The LowerBound value defines the lower bounds which is typically zero for
1652 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1653 // Count == -1 then the array is unbounded and we do not emit
1654 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1655 // Count == 0, then the array has zero elements in which case we do not emit
1657 int64_t LowerBound = SR.getLo();
1658 int64_t DefaultLowerBound = getDefaultLowerBound();
1659 int64_t Count = SR.getCount();
1661 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1662 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1664 if (Count != -1 && Count != 0)
1665 // FIXME: An unbounded array should reference the expression that defines
1667 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
1668 LowerBound + Count - 1);
1671 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1672 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1674 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1676 // Emit the element type.
1677 addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
1679 // Get an anonymous type for index type.
1680 // FIXME: This type should be passed down from the front end
1681 // as different languages may have different sizes for indexes.
1682 DIE *IdxTy = getIndexTyDie();
1684 // Construct an anonymous type for index type.
1685 IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
1686 addString(IdxTy, dwarf::DW_AT_name, "int");
1687 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1688 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1689 dwarf::DW_ATE_signed);
1690 setIndexTyDie(IdxTy);
1693 // Add subranges to array type.
1694 DIArray Elements = CTy.getTypeArray();
1695 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1696 DIDescriptor Element = Elements.getElement(i);
1697 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1698 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1702 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
1703 void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1704 DIArray Elements = CTy.getTypeArray();
1706 // Add enumerators to enumeration type.
1707 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1708 DIEnumerator Enum(Elements.getElement(i));
1709 if (Enum.isEnumerator()) {
1710 DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1711 StringRef Name = Enum.getName();
1712 addString(Enumerator, dwarf::DW_AT_name, Name);
1713 int64_t Value = Enum.getEnumValue();
1714 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1718 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1720 addType(&Buffer, DTy);
1721 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1725 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1727 void CompileUnit::constructContainingTypeDIEs() {
1728 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1729 CE = ContainingTypeMap.end();
1731 DIE *SPDie = CI->first;
1732 DIDescriptor D(CI->second);
1735 DIE *NDie = getDIE(D);
1738 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1742 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1743 DIE *CompileUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
1744 StringRef Name = DV.getName();
1746 // Define variable debug information entry.
1747 DIE *VariableDie = new DIE(DV.getTag());
1748 DbgVariable *AbsVar = DV.getAbstractVariable();
1749 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1751 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1754 addString(VariableDie, dwarf::DW_AT_name, Name);
1755 addSourceLine(VariableDie, DV.getVariable());
1756 addType(VariableDie, DV.getType());
1759 if (DV.isArtificial())
1760 addFlag(VariableDie, dwarf::DW_AT_artificial);
1762 if (isScopeAbstract) {
1763 DV.setDIE(VariableDie);
1767 // Add variable address.
1769 unsigned Offset = DV.getDotDebugLocOffset();
1770 if (Offset != ~0U) {
1771 addLabel(VariableDie, dwarf::DW_AT_location,
1772 DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
1773 : dwarf::DW_FORM_data4,
1774 Asm->GetTempSymbol("debug_loc", Offset));
1775 DV.setDIE(VariableDie);
1779 // Check if variable is described by a DBG_VALUE instruction.
1780 if (const MachineInstr *DVInsn = DV.getMInsn()) {
1781 assert(DVInsn->getNumOperands() == 3);
1782 if (DVInsn->getOperand(0).isReg()) {
1783 const MachineOperand RegOp = DVInsn->getOperand(0);
1784 // If the second operand is an immediate, this is an indirect value.
1785 if (DVInsn->getOperand(1).isImm()) {
1786 MachineLocation Location(RegOp.getReg(),
1787 DVInsn->getOperand(1).getImm());
1788 addVariableAddress(DV, VariableDie, Location);
1789 } else if (RegOp.getReg())
1790 addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
1791 } else if (DVInsn->getOperand(0).isImm())
1792 addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
1793 else if (DVInsn->getOperand(0).isFPImm())
1794 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1795 else if (DVInsn->getOperand(0).isCImm())
1796 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1797 isUnsignedDIType(DD, DV.getType()));
1799 DV.setDIE(VariableDie);
1802 // .. else use frame index.
1803 int FI = DV.getFrameIndex();
1805 unsigned FrameReg = 0;
1806 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1807 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1808 MachineLocation Location(FrameReg, Offset);
1809 addVariableAddress(DV, VariableDie, Location);
1813 DV.setDIE(VariableDie);
1817 /// constructMemberDIE - Construct member DIE from DIDerivedType.
1818 void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1819 DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1820 StringRef Name = DT.getName();
1822 addString(MemberDie, dwarf::DW_AT_name, Name);
1824 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1826 addSourceLine(MemberDie, DT);
1828 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1829 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1831 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1833 // For C++, virtual base classes are not at fixed offset. Use following
1834 // expression to extract appropriate offset from vtable.
1835 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1837 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1838 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1839 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1840 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1841 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1842 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1843 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1844 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1846 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1848 uint64_t Size = DT.getSizeInBits();
1849 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1850 uint64_t OffsetInBytes;
1852 if (Size != FieldSize) {
1854 addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1855 getBaseTypeSize(DD, DT) >> 3);
1856 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1858 uint64_t Offset = DT.getOffsetInBits();
1859 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1860 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1861 uint64_t FieldOffset = (HiMark - FieldSize);
1862 Offset -= FieldOffset;
1864 // Maybe we need to work from the other end.
1865 if (Asm->getDataLayout().isLittleEndian())
1866 Offset = FieldSize - (Offset + Size);
1867 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1869 // Here WD_AT_data_member_location points to the anonymous
1870 // field that includes this bit field.
1871 OffsetInBytes = FieldOffset >> 3;
1873 // This is not a bitfield.
1874 OffsetInBytes = DT.getOffsetInBits() >> 3;
1875 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
1878 if (DT.isProtected())
1879 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1880 dwarf::DW_ACCESS_protected);
1881 else if (DT.isPrivate())
1882 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1883 dwarf::DW_ACCESS_private);
1884 // Otherwise C++ member and base classes are considered public.
1886 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1887 dwarf::DW_ACCESS_public);
1889 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1890 dwarf::DW_VIRTUALITY_virtual);
1892 // Objective-C properties.
1893 if (MDNode *PNode = DT.getObjCProperty())
1894 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1895 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1898 if (DT.isArtificial())
1899 addFlag(MemberDie, dwarf::DW_AT_artificial);
1902 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1903 DIE *CompileUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1907 // Construct the context before querying for the existence of the DIE in case
1908 // such construction creates the DIE.
1909 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1910 assert(dwarf::isType(ContextDIE->getTag()) &&
1911 "Static member should belong to a type.");
1913 DIE *StaticMemberDIE = getDIE(DT);
1914 if (StaticMemberDIE)
1915 return StaticMemberDIE;
1917 StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1919 DIType Ty = resolve(DT.getTypeDerivedFrom());
1921 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1922 addType(StaticMemberDIE, Ty);
1923 addSourceLine(StaticMemberDIE, DT);
1924 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1925 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1927 // FIXME: We could omit private if the parent is a class_type, and
1928 // public if the parent is something else.
1929 if (DT.isProtected())
1930 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1931 dwarf::DW_ACCESS_protected);
1932 else if (DT.isPrivate())
1933 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1934 dwarf::DW_ACCESS_private);
1936 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1937 dwarf::DW_ACCESS_public);
1939 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1940 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1941 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1942 addConstantFPValue(StaticMemberDIE, CFP);
1944 return StaticMemberDIE;
1947 void CompileUnit::emitHeader(const MCSection *ASection,
1948 const MCSymbol *ASectionSym) {
1949 Asm->OutStreamer.AddComment("DWARF version number");
1950 Asm->EmitInt16(DD->getDwarfVersion());
1951 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1952 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1954 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1955 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());