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/Target/Mangler.h"
26 #include "llvm/Target/TargetFrameLowering.h"
27 #include "llvm/Target/TargetMachine.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetRegisterInfo.h"
33 /// CompileUnit - Compile unit constructor.
34 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
35 DwarfDebug *DW, DwarfUnits *DWU)
36 : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0) {
37 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
41 /// ~CompileUnit - Destructor for compile unit.
42 CompileUnit::~CompileUnit() {
43 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
44 DIEBlocks[j]->~DIEBlock();
47 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
48 /// information entry.
49 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
50 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
54 /// getDefaultLowerBound - Return the default lower bound for an array. If the
55 /// DWARF version doesn't handle the language, return -1.
56 int64_t CompileUnit::getDefaultLowerBound() const {
57 switch (DICompileUnit(Node).getLanguage()) {
61 case dwarf::DW_LANG_C89:
62 case dwarf::DW_LANG_C99:
63 case dwarf::DW_LANG_C:
64 case dwarf::DW_LANG_C_plus_plus:
65 case dwarf::DW_LANG_ObjC:
66 case dwarf::DW_LANG_ObjC_plus_plus:
69 case dwarf::DW_LANG_Fortran77:
70 case dwarf::DW_LANG_Fortran90:
71 case dwarf::DW_LANG_Fortran95:
74 // The languages below have valid values only if the DWARF version >= 4.
75 case dwarf::DW_LANG_Java:
76 case dwarf::DW_LANG_Python:
77 case dwarf::DW_LANG_UPC:
78 case dwarf::DW_LANG_D:
79 if (dwarf::DWARF_VERSION >= 4)
83 case dwarf::DW_LANG_Ada83:
84 case dwarf::DW_LANG_Ada95:
85 case dwarf::DW_LANG_Cobol74:
86 case dwarf::DW_LANG_Cobol85:
87 case dwarf::DW_LANG_Modula2:
88 case dwarf::DW_LANG_Pascal83:
89 case dwarf::DW_LANG_PLI:
90 if (dwarf::DWARF_VERSION >= 4)
98 /// addFlag - Add a flag that is true.
99 void CompileUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
100 if (DD->getDwarfVersion() >= 4)
101 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
103 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
106 /// addUInt - Add an unsigned integer attribute data and value.
108 void CompileUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
109 Optional<dwarf::Form> Form, uint64_t Integer) {
111 Form = DIEInteger::BestForm(false, Integer);
112 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
114 Die->addValue(Attribute, *Form, Value);
117 void CompileUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
118 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
121 /// addSInt - Add an signed integer attribute data and value.
123 void CompileUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
124 Optional<dwarf::Form> Form, int64_t Integer) {
126 Form = DIEInteger::BestForm(true, Integer);
127 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
128 Die->addValue(Attribute, *Form, Value);
131 void CompileUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
133 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
136 /// addString - Add a string attribute data and value. We always emit a
137 /// reference to the string pool instead of immediate strings so that DIEs have
138 /// more predictable sizes. In the case of split dwarf we emit an index
139 /// into another table which gets us the static offset into the string
141 void CompileUnit::addString(DIE *Die, dwarf::Attribute Attribute, StringRef String) {
144 if (!DD->useSplitDwarf()) {
145 MCSymbol *Symb = DU->getStringPoolEntry(String);
146 if (Asm->needsRelocationsForDwarfStringPool())
147 Value = new (DIEValueAllocator) DIELabel(Symb);
149 MCSymbol *StringPool = DU->getStringPoolSym();
150 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
152 Form = dwarf::DW_FORM_strp;
154 unsigned idx = DU->getStringPoolIndex(String);
155 Value = new (DIEValueAllocator) DIEInteger(idx);
156 Form = dwarf::DW_FORM_GNU_str_index;
158 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
159 Die->addValue(Attribute, Form, Str);
162 /// addLocalString - Add a string attribute data and value. This is guaranteed
163 /// to be in the local string pool instead of indirected.
164 void CompileUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
166 MCSymbol *Symb = DU->getStringPoolEntry(String);
168 if (Asm->needsRelocationsForDwarfStringPool())
169 Value = new (DIEValueAllocator) DIELabel(Symb);
171 MCSymbol *StringPool = DU->getStringPoolSym();
172 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
174 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
177 /// addExpr - Add a Dwarf expression attribute data and value.
179 void CompileUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
180 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
181 Die->addValue((dwarf::Attribute)0, Form, Value);
184 /// addLabel - Add a Dwarf label attribute data and value.
186 void CompileUnit::addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
187 const MCSymbol *Label) {
188 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
189 Die->addValue(Attribute, Form, Value);
192 void CompileUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
193 const MCSymbol *Label) {
194 addLabel(Die, (dwarf::Attribute)0, Form, Label);
197 /// addLabelAddress - Add a dwarf label attribute data and value using
198 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
200 void CompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
203 DD->addArangeLabel(SymbolCU(this, Label));
205 if (!DD->useSplitDwarf()) {
207 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
208 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
210 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
211 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
214 unsigned idx = DU->getAddrPoolIndex(Label);
215 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
216 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
220 /// addOpAddress - Add a dwarf op address data and value using the
221 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
223 void CompileUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
224 DD->addArangeLabel(SymbolCU(this, Sym));
225 if (!DD->useSplitDwarf()) {
226 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
227 addLabel(Die, dwarf::DW_FORM_udata, Sym);
229 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
230 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
234 /// addDelta - Add a label delta attribute data and value.
236 void CompileUnit::addDelta(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
237 const MCSymbol *Hi, const MCSymbol *Lo) {
238 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
239 Die->addValue(Attribute, Form, Value);
242 /// addDIEEntry - Add a DIE attribute data and value.
244 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry) {
245 // We currently only use ref4.
246 Die->addValue(Attribute, dwarf::DW_FORM_ref4, createDIEEntry(Entry));
249 /// addBlock - Add block data.
251 void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
253 Block->ComputeSize(Asm);
254 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
255 Die->addValue(Attribute, Block->BestForm(), Block);
258 /// addSourceLine - Add location information to specified debug information
260 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
265 unsigned Line = V.getLineNumber();
269 DD->getOrCreateSourceID(V.getContext().getFilename(),
270 V.getContext().getDirectory(), getUniqueID());
271 assert(FileID && "Invalid file id");
272 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
273 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
276 /// addSourceLine - Add location information to specified debug information
278 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
279 // Verify global variable.
280 if (!G.isGlobalVariable())
283 unsigned Line = G.getLineNumber();
287 DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
288 assert(FileID && "Invalid file id");
289 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
290 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
293 /// addSourceLine - Add location information to specified debug information
295 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
296 // Verify subprogram.
297 if (!SP.isSubprogram())
300 // If the line number is 0, don't add it.
301 unsigned Line = SP.getLineNumber();
305 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
307 assert(FileID && "Invalid file id");
308 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
309 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
312 /// addSourceLine - Add location information to specified debug information
314 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
319 unsigned Line = Ty.getLineNumber();
322 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
324 assert(FileID && "Invalid file id");
325 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
326 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
329 /// addSourceLine - Add location information to specified debug information
331 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
333 if (!Ty.isObjCProperty())
336 unsigned Line = Ty.getLineNumber();
339 DIFile File = Ty.getFile();
340 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
341 File.getDirectory(), getUniqueID());
342 assert(FileID && "Invalid file id");
343 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
344 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
347 /// addSourceLine - Add location information to specified debug information
349 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
354 unsigned Line = NS.getLineNumber();
357 StringRef FN = NS.getFilename();
360 DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
361 assert(FileID && "Invalid file id");
362 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
363 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
366 /// addVariableAddress - Add DW_AT_location attribute for a
367 /// DbgVariable based on provided MachineLocation.
368 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
369 MachineLocation Location) {
370 if (DV.variableHasComplexAddress())
371 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
372 else if (DV.isBlockByrefVariable())
373 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
375 addAddress(Die, dwarf::DW_AT_location, Location,
376 DV.getVariable().isIndirect());
379 /// addRegisterOp - Add register operand.
380 void CompileUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
381 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
382 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
384 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
386 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
387 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
391 /// addRegisterOffset - Add register offset.
392 void CompileUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
394 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
395 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
396 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
397 if (Reg == TRI->getFrameRegister(*Asm->MF))
398 // If variable offset is based in frame register then use fbreg.
399 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
401 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
403 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
404 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
406 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
409 /// addAddress - Add an address attribute to a die based on the location
411 void CompileUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
412 const MachineLocation &Location, bool Indirect) {
413 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
415 if (Location.isReg() && !Indirect)
416 addRegisterOp(Block, Location.getReg());
418 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
419 if (Indirect && !Location.isReg()) {
420 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
424 // Now attach the location information to the DIE.
425 addBlock(Die, Attribute, Block);
428 /// addComplexAddress - Start with the address based on the location provided,
429 /// and generate the DWARF information necessary to find the actual variable
430 /// given the extra address information encoded in the DIVariable, starting from
431 /// the starting location. Add the DWARF information to the die.
433 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
434 dwarf::Attribute Attribute,
435 const MachineLocation &Location) {
436 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
437 unsigned N = DV.getNumAddrElements();
439 if (Location.isReg()) {
440 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
441 // If first address element is OpPlus then emit
442 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
443 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
446 addRegisterOp(Block, Location.getReg());
448 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
451 uint64_t Element = DV.getAddrElement(i);
452 if (Element == DIBuilder::OpPlus) {
453 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
454 addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
455 } else if (Element == DIBuilder::OpDeref) {
456 if (!Location.isReg())
457 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
459 llvm_unreachable("unknown DIBuilder Opcode");
462 // Now attach the location information to the DIE.
463 addBlock(Die, Attribute, Block);
466 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
467 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
468 gives the variable VarName either the struct, or a pointer to the struct, as
469 its type. This is necessary for various behind-the-scenes things the
470 compiler needs to do with by-reference variables in Blocks.
472 However, as far as the original *programmer* is concerned, the variable
473 should still have type 'SomeType', as originally declared.
475 The function getBlockByrefType dives into the __Block_byref_x_VarName
476 struct to find the original type of the variable, which is then assigned to
477 the variable's Debug Information Entry as its real type. So far, so good.
478 However now the debugger will expect the variable VarName to have the type
479 SomeType. So we need the location attribute for the variable to be an
480 expression that explains to the debugger how to navigate through the
481 pointers and struct to find the actual variable of type SomeType.
483 The following function does just that. We start by getting
484 the "normal" location for the variable. This will be the location
485 of either the struct __Block_byref_x_VarName or the pointer to the
486 struct __Block_byref_x_VarName.
488 The struct will look something like:
490 struct __Block_byref_x_VarName {
492 struct __Block_byref_x_VarName *forwarding;
493 ... <various other fields>
495 ... <maybe more fields>
498 If we are given the struct directly (as our starting point) we
499 need to tell the debugger to:
501 1). Add the offset of the forwarding field.
503 2). Follow that pointer to get the real __Block_byref_x_VarName
504 struct to use (the real one may have been copied onto the heap).
506 3). Add the offset for the field VarName, to find the actual variable.
508 If we started with a pointer to the struct, then we need to
509 dereference that pointer first, before the other steps.
510 Translating this into DWARF ops, we will need to append the following
511 to the current location description for the variable:
513 DW_OP_deref -- optional, if we start with a pointer
514 DW_OP_plus_uconst <forward_fld_offset>
516 DW_OP_plus_uconst <varName_fld_offset>
518 That is what this function does. */
520 /// addBlockByrefAddress - Start with the address based on the location
521 /// provided, and generate the DWARF information necessary to find the
522 /// actual Block variable (navigating the Block struct) based on the
523 /// starting location. Add the DWARF information to the die. For
524 /// more information, read large comment just above here.
526 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
527 dwarf::Attribute Attribute,
528 const MachineLocation &Location) {
529 DIType Ty = DV.getType();
531 uint16_t Tag = Ty.getTag();
532 bool isPointer = false;
534 StringRef varName = DV.getName();
536 if (Tag == dwarf::DW_TAG_pointer_type) {
537 DIDerivedType DTy = DIDerivedType(Ty);
538 TmpTy = resolve(DTy.getTypeDerivedFrom());
542 DICompositeType blockStruct = DICompositeType(TmpTy);
544 // Find the __forwarding field and the variable field in the __Block_byref
546 DIArray Fields = blockStruct.getTypeArray();
547 DIDescriptor varField = DIDescriptor();
548 DIDescriptor forwardingField = DIDescriptor();
550 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
551 DIDescriptor Element = Fields.getElement(i);
552 DIDerivedType DT = DIDerivedType(Element);
553 StringRef fieldName = DT.getName();
554 if (fieldName == "__forwarding")
555 forwardingField = Element;
556 else if (fieldName == varName)
560 // Get the offsets for the forwarding field and the variable field.
561 unsigned forwardingFieldOffset =
562 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
563 unsigned varFieldOffset = DIDerivedType(varField).getOffsetInBits() >> 3;
565 // Decode the original location, and use that as the start of the byref
566 // variable's location.
567 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
569 if (Location.isReg())
570 addRegisterOp(Block, Location.getReg());
572 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
574 // If we started with a pointer to the __Block_byref... struct, then
575 // the first thing we need to do is dereference the pointer (DW_OP_deref).
577 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
579 // Next add the offset for the '__forwarding' field:
580 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
581 // adding the offset if it's 0.
582 if (forwardingFieldOffset > 0) {
583 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
584 addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
587 // Now dereference the __forwarding field to get to the real __Block_byref
588 // struct: DW_OP_deref.
589 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
591 // Now that we've got the real __Block_byref... struct, add the offset
592 // for the variable's field to get to the location of the actual variable:
593 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
594 if (varFieldOffset > 0) {
595 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
596 addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
599 // Now attach the location information to the DIE.
600 addBlock(Die, Attribute, Block);
603 /// isTypeSigned - Return true if the type is signed.
604 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
605 if (Ty.isDerivedType())
606 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
608 if (Ty.isBasicType())
609 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
610 DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
611 *SizeInBits = Ty.getSizeInBits();
617 /// Return true if type encoding is unsigned.
618 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
619 DIDerivedType DTy(Ty);
620 if (DTy.isDerivedType())
621 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
624 if (BTy.isBasicType()) {
625 unsigned Encoding = BTy.getEncoding();
626 if (Encoding == dwarf::DW_ATE_unsigned ||
627 Encoding == dwarf::DW_ATE_unsigned_char ||
628 Encoding == dwarf::DW_ATE_boolean)
634 /// If this type is derived from a base type then return base type size.
635 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
636 unsigned Tag = Ty.getTag();
638 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
639 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
640 Tag != dwarf::DW_TAG_restrict_type)
641 return Ty.getSizeInBits();
643 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
645 // If this type is not derived from any type then take conservative approach.
646 if (!BaseType.isValid())
647 return Ty.getSizeInBits();
649 // If this is a derived type, go ahead and get the base type, unless it's a
650 // reference then it's just the size of the field. Pointer types have no need
651 // of this since they're a different type of qualification on the type.
652 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
653 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
654 return Ty.getSizeInBits();
656 if (BaseType.isDerivedType())
657 return getBaseTypeSize(DD, DIDerivedType(BaseType));
659 return BaseType.getSizeInBits();
662 /// addConstantValue - Add constant value entry in variable DIE.
663 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
665 // FIXME: This is a bit conservative/simple - it emits negative values at
666 // their maximum bit width which is a bit unfortunate (& doesn't prefer
667 // udata/sdata over dataN as suggested by the DWARF spec)
668 assert(MO.isImm() && "Invalid machine operand!");
670 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
673 // If we're a signed constant definitely use sdata.
674 if (SignedConstant) {
675 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
679 // Else use data for now unless it's larger than we can deal with.
680 switch (SizeInBits) {
682 Form = dwarf::DW_FORM_data1;
685 Form = dwarf::DW_FORM_data2;
688 Form = dwarf::DW_FORM_data4;
691 Form = dwarf::DW_FORM_data8;
694 Form = dwarf::DW_FORM_udata;
695 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
698 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
701 /// addConstantFPValue - Add constant value entry in variable DIE.
702 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
703 assert(MO.isFPImm() && "Invalid machine operand!");
704 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
705 APFloat FPImm = MO.getFPImm()->getValueAPF();
707 // Get the raw data form of the floating point.
708 const APInt FltVal = FPImm.bitcastToAPInt();
709 const char *FltPtr = (const char *)FltVal.getRawData();
711 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
712 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
713 int Incr = (LittleEndian ? 1 : -1);
714 int Start = (LittleEndian ? 0 : NumBytes - 1);
715 int Stop = (LittleEndian ? NumBytes : -1);
717 // Output the constant to DWARF one byte at a time.
718 for (; Start != Stop; Start += Incr)
719 addUInt(Block, dwarf::DW_FORM_data1,
720 (unsigned char)0xFF & FltPtr[Start]);
722 addBlock(Die, dwarf::DW_AT_const_value, Block);
725 /// addConstantFPValue - Add constant value entry in variable DIE.
726 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
727 // Pass this down to addConstantValue as an unsigned bag of bits.
728 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
731 /// addConstantValue - Add constant value entry in variable DIE.
732 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
734 addConstantValue(Die, CI->getValue(), Unsigned);
737 // addConstantValue - Add constant value entry in variable DIE.
738 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
739 unsigned CIBitWidth = Val.getBitWidth();
740 if (CIBitWidth <= 64) {
741 // If we're a signed constant definitely use sdata.
743 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
748 // Else use data for now unless it's larger than we can deal with.
750 switch (CIBitWidth) {
752 Form = dwarf::DW_FORM_data1;
755 Form = dwarf::DW_FORM_data2;
758 Form = dwarf::DW_FORM_data4;
761 Form = dwarf::DW_FORM_data8;
764 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
768 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
772 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
774 // Get the raw data form of the large APInt.
775 const uint64_t *Ptr64 = Val.getRawData();
777 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
778 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
780 // Output the constant to DWARF one byte at a time.
781 for (int i = 0; i < NumBytes; i++) {
784 c = Ptr64[i / 8] >> (8 * (i & 7));
786 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
787 addUInt(Block, dwarf::DW_FORM_data1, c);
790 addBlock(Die, dwarf::DW_AT_const_value, Block);
793 /// addTemplateParams - Add template parameters into buffer.
794 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
795 // Add template parameters.
796 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
797 DIDescriptor Element = TParams.getElement(i);
798 if (Element.isTemplateTypeParameter())
799 getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter(Element),
801 else if (Element.isTemplateValueParameter())
802 getOrCreateTemplateValueParameterDIE(DITemplateValueParameter(Element),
807 /// getOrCreateContextDIE - Get context owner's DIE.
808 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
809 if (Context.isType())
810 return getOrCreateTypeDIE(DIType(Context));
811 else if (Context.isNameSpace())
812 return getOrCreateNameSpace(DINameSpace(Context));
813 else if (Context.isSubprogram())
814 return getOrCreateSubprogramDIE(DISubprogram(Context));
816 return getDIE(Context);
819 /// addToContextOwner - Add Die into the list of its context owner's children.
820 void CompileUnit::addToContextOwner(DIE *Die, DIScope Context) {
821 assert(!Die->getParent());
822 if (DIE *ContextDIE = getOrCreateContextDIE(Context)) {
823 if (Die->getParent()) {
824 // While creating the context, if this is a type member, we will have
825 // added the child to the context already.
826 assert(Die->getParent() == ContextDIE);
829 ContextDIE->addChild(Die);
834 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
836 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
840 DIE *TyDIE = getDIE(Ty);
845 TyDIE = new DIE(Ty.getTag());
846 insertDIE(Ty, TyDIE);
847 if (Ty.isBasicType())
848 constructTypeDIE(*TyDIE, DIBasicType(Ty));
849 else if (Ty.isCompositeType())
850 constructTypeDIE(*TyDIE, DICompositeType(Ty));
852 assert(Ty.isDerivedType() && "Unknown kind of DIType");
853 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
855 // If this is a named finished type then include it in the list of types
856 // for the accelerator tables.
857 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
858 bool IsImplementation = 0;
859 if (Ty.isCompositeType()) {
860 DICompositeType CT(Ty);
861 // A runtime language of 0 actually means C/C++ and that any
862 // non-negative value is some version of Objective-C/C++.
863 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
865 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
866 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
869 addToContextOwner(TyDIE, resolve(Ty.getContext()));
873 /// addType - Add a new type attribute to the specified entity.
874 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
875 assert(Ty && "Trying to add a type that doesn't exist?");
877 // Check for pre-existence.
878 DIEEntry *Entry = getDIEEntry(Ty);
879 // If it exists then use the existing value.
881 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
886 DIE *Buffer = getOrCreateTypeDIE(Ty);
889 Entry = createDIEEntry(Buffer);
890 insertDIEEntry(Ty, Entry);
891 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
893 // If this is a complete composite type then include it in the
894 // list of global types.
898 // Accelerator table mutators - add each name along with its companion
899 // DIE to the proper table while ensuring that the name that we're going
900 // to reference is in the string table. We do this since the names we
901 // add may not only be identical to the names in the DIE.
902 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
903 DU->getStringPoolEntry(Name);
904 std::vector<DIE *> &DIEs = AccelNames[Name];
908 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
909 DU->getStringPoolEntry(Name);
910 std::vector<DIE *> &DIEs = AccelObjC[Name];
914 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
915 DU->getStringPoolEntry(Name);
916 std::vector<DIE *> &DIEs = AccelNamespace[Name];
920 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
921 DU->getStringPoolEntry(Name);
922 std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
926 /// addGlobalName - Add a new global name to the compile unit.
927 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
928 std::string FullName = getParentContextString(Context) + Name.str();
929 GlobalNames[FullName] = Die;
932 /// addGlobalType - Add a new global type to the compile unit.
934 void CompileUnit::addGlobalType(DIType Ty) {
935 DIScope Context = resolve(Ty.getContext());
936 if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
937 (!Context || Context.isCompileUnit() || Context.isFile() ||
938 Context.isNameSpace()))
939 if (DIEEntry *Entry = getDIEEntry(Ty)) {
940 std::string FullName =
941 getParentContextString(Context) + Ty.getName().str();
942 GlobalTypes[FullName] = Entry->getEntry();
946 /// getParentContextString - Walks the metadata parent chain in a language
947 /// specific manner (using the compile unit language) and returns
948 /// it as a string. This is done at the metadata level because DIEs may
949 /// not currently have been added to the parent context and walking the
950 /// DIEs looking for names is more expensive than walking the metadata.
951 std::string CompileUnit::getParentContextString(DIScope Context) const {
955 // FIXME: Decide whether to implement this for non-C++ languages.
956 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
960 SmallVector<DIScope, 1> Parents;
961 while (!Context.isCompileUnit()) {
962 Parents.push_back(Context);
963 if (Context.getContext())
964 Context = resolve(Context.getContext());
966 // Structure, etc types will have a NULL context if they're at the top
971 // Reverse iterate over our list to go from the outermost construct to the
973 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
977 StringRef Name = Ctx.getName();
986 /// addPubTypes - Add subprogram argument types for pubtypes section.
987 void CompileUnit::addPubTypes(DISubprogram SP) {
988 DICompositeType SPTy = SP.getType();
989 uint16_t SPTag = SPTy.getTag();
990 if (SPTag != dwarf::DW_TAG_subroutine_type)
993 DIArray Args = SPTy.getTypeArray();
994 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
995 DIType ATy(Args.getElement(i));
1002 /// constructTypeDIE - Construct basic type die from DIBasicType.
1003 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1004 // Get core information.
1005 StringRef Name = BTy.getName();
1006 // Add name if not anonymous or intermediate type.
1008 addString(&Buffer, dwarf::DW_AT_name, Name);
1010 // An unspecified type only has a name attribute.
1011 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1014 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1017 uint64_t Size = BTy.getSizeInBits() >> 3;
1018 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1021 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1022 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1023 // Get core information.
1024 StringRef Name = DTy.getName();
1025 uint64_t Size = DTy.getSizeInBits() >> 3;
1026 uint16_t Tag = Buffer.getTag();
1028 // Map to main type, void will not have a type.
1029 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1031 addType(&Buffer, FromTy);
1033 // Add name if not anonymous or intermediate type.
1035 addString(&Buffer, dwarf::DW_AT_name, Name);
1037 // Add size if non-zero (derived types might be zero-sized.)
1038 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1039 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1041 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1042 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1043 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1044 // Add source line info if available and TyDesc is not a forward declaration.
1045 if (!DTy.isForwardDecl())
1046 addSourceLine(&Buffer, DTy);
1049 /// Return true if the type is appropriately scoped to be contained inside
1050 /// its own type unit.
1051 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1052 DIScope Parent = DD->resolve(Ty.getContext());
1054 // Don't generate a hash for anything scoped inside a function.
1055 if (Parent.isSubprogram())
1057 Parent = DD->resolve(Parent.getContext());
1062 /// Return true if the type should be split out into a type unit.
1063 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1064 uint16_t Tag = CTy.getTag();
1067 case dwarf::DW_TAG_structure_type:
1068 case dwarf::DW_TAG_union_type:
1069 case dwarf::DW_TAG_enumeration_type:
1070 case dwarf::DW_TAG_class_type:
1071 // If this is a class, structure, union, or enumeration type
1072 // that is a definition (not a declaration), and not scoped
1073 // inside a function then separate this out as a type unit.
1074 return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1080 /// constructTypeDIE - Construct type DIE from DICompositeType.
1081 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1082 // Get core information.
1083 StringRef Name = CTy.getName();
1085 uint64_t Size = CTy.getSizeInBits() >> 3;
1086 uint16_t Tag = Buffer.getTag();
1089 case dwarf::DW_TAG_array_type:
1090 constructArrayTypeDIE(Buffer, &CTy);
1092 case dwarf::DW_TAG_enumeration_type: {
1093 DIArray Elements = CTy.getTypeArray();
1095 // Add enumerators to enumeration type.
1096 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1097 DIDescriptor Enum(Elements.getElement(i));
1098 if (Enum.isEnumerator())
1099 constructEnumTypeDIE(DIEnumerator(Enum), Buffer);
1101 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1103 addType(&Buffer, DTy);
1104 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1107 case dwarf::DW_TAG_subroutine_type: {
1108 // Add return type. A void return won't have a type.
1109 DIArray Elements = CTy.getTypeArray();
1110 DIDescriptor RTy = Elements.getElement(0);
1112 addType(&Buffer, DIType(RTy));
1114 bool isPrototyped = true;
1116 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1117 DIDescriptor Ty = Elements.getElement(i);
1118 if (Ty.isUnspecifiedParameter()) {
1119 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1120 Buffer.addChild(Arg);
1121 isPrototyped = false;
1123 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1124 addType(Arg, DIType(Ty));
1125 if (DIType(Ty).isArtificial())
1126 addFlag(Arg, dwarf::DW_AT_artificial);
1127 Buffer.addChild(Arg);
1130 // Add prototype flag if we're dealing with a C language and the
1131 // function has been prototyped.
1132 uint16_t Language = DICompileUnit(Node).getLanguage();
1134 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1135 Language == dwarf::DW_LANG_ObjC))
1136 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1138 case dwarf::DW_TAG_structure_type:
1139 case dwarf::DW_TAG_union_type:
1140 case dwarf::DW_TAG_class_type: {
1141 // Add elements to structure type.
1142 DIArray Elements = CTy.getTypeArray();
1143 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1144 DIDescriptor Element = Elements.getElement(i);
1145 DIE *ElemDie = NULL;
1146 if (Element.isSubprogram()) {
1147 DISubprogram SP(Element);
1148 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1149 if (SP.isProtected())
1150 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1151 dwarf::DW_ACCESS_protected);
1152 else if (SP.isPrivate())
1153 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1154 dwarf::DW_ACCESS_private);
1156 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1157 dwarf::DW_ACCESS_public);
1158 if (SP.isExplicit())
1159 addFlag(ElemDie, dwarf::DW_AT_explicit);
1160 } else if (Element.isDerivedType()) {
1161 DIDerivedType DDTy(Element);
1162 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1163 ElemDie = new DIE(dwarf::DW_TAG_friend);
1164 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1165 dwarf::DW_AT_friend);
1166 Buffer.addChild(ElemDie);
1167 } else if (DDTy.isStaticMember()) {
1168 ElemDie = getOrCreateStaticMemberDIE(DDTy);
1170 ElemDie = createMemberDIE(DDTy, Buffer);
1172 } else if (Element.isObjCProperty()) {
1173 DIObjCProperty Property(Element);
1174 ElemDie = new DIE(Property.getTag());
1175 StringRef PropertyName = Property.getObjCPropertyName();
1176 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1177 addType(ElemDie, Property.getType());
1178 addSourceLine(ElemDie, Property);
1179 StringRef GetterName = Property.getObjCPropertyGetterName();
1180 if (!GetterName.empty())
1181 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1182 StringRef SetterName = Property.getObjCPropertySetterName();
1183 if (!SetterName.empty())
1184 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1185 unsigned PropertyAttributes = 0;
1186 if (Property.isReadOnlyObjCProperty())
1187 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1188 if (Property.isReadWriteObjCProperty())
1189 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1190 if (Property.isAssignObjCProperty())
1191 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1192 if (Property.isRetainObjCProperty())
1193 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1194 if (Property.isCopyObjCProperty())
1195 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1196 if (Property.isNonAtomicObjCProperty())
1197 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1198 if (PropertyAttributes)
1199 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1200 PropertyAttributes);
1202 DIEEntry *Entry = getDIEEntry(Element);
1204 Entry = createDIEEntry(ElemDie);
1205 insertDIEEntry(Element, Entry);
1207 Buffer.addChild(ElemDie);
1212 if (CTy.isAppleBlockExtension())
1213 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1215 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1216 if (DIDescriptor(ContainingType).isCompositeType())
1217 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1218 getOrCreateTypeDIE(DIType(ContainingType)));
1220 if (CTy.isObjcClassComplete())
1221 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1223 // Add template parameters to a class, structure or union types.
1224 // FIXME: The support isn't in the metadata for this yet.
1225 if (Tag == dwarf::DW_TAG_class_type ||
1226 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1227 addTemplateParams(Buffer, CTy.getTemplateParams());
1235 // Add name if not anonymous or intermediate type.
1237 addString(&Buffer, dwarf::DW_AT_name, Name);
1239 if (Tag == dwarf::DW_TAG_enumeration_type ||
1240 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1241 Tag == dwarf::DW_TAG_union_type) {
1242 // Add size if non-zero (derived types might be zero-sized.)
1243 // TODO: Do we care about size for enum forward declarations?
1245 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
1246 else if (!CTy.isForwardDecl())
1247 // Add zero size if it is not a forward declaration.
1248 addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
1250 // If we're a forward decl, say so.
1251 if (CTy.isForwardDecl())
1252 addFlag(&Buffer, dwarf::DW_AT_declaration);
1254 // Add source line info if available.
1255 if (!CTy.isForwardDecl())
1256 addSourceLine(&Buffer, CTy);
1258 // No harm in adding the runtime language to the declaration.
1259 unsigned RLang = CTy.getRunTimeLang();
1261 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1264 // If this is a type applicable to a type unit it then add it to the
1265 // list of types we'll compute a hash for later.
1266 if (shouldCreateTypeUnit(CTy, DD))
1267 DD->addTypeUnitType(&Buffer);
1270 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1271 /// for the given DITemplateTypeParameter.
1273 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP,
1275 DIE *ParamDIE = getDIE(TP);
1279 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1280 Buffer.addChild(ParamDIE);
1281 // Add the type if it exists, it could be void and therefore no type.
1283 addType(ParamDIE, resolve(TP.getType()));
1284 if (!TP.getName().empty())
1285 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1289 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1290 /// for the given DITemplateValueParameter.
1292 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP,
1294 DIE *ParamDIE = getDIE(VP);
1298 ParamDIE = new DIE(VP.getTag());
1299 Buffer.addChild(ParamDIE);
1301 // Add the type if there is one, template template and template parameter
1302 // packs will not have a type.
1303 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1304 addType(ParamDIE, resolve(VP.getType()));
1305 if (!VP.getName().empty())
1306 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1307 if (Value *Val = VP.getValue()) {
1308 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1309 addConstantValue(ParamDIE, CI,
1310 isUnsignedDIType(DD, resolve(VP.getType())));
1311 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1312 // For declaration non-type template parameters (such as global values and
1314 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1315 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1316 // Emit DW_OP_stack_value to use the address as the immediate value of the
1317 // parameter, rather than a pointer to it.
1318 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1319 addBlock(ParamDIE, dwarf::DW_AT_location, Block);
1320 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1321 assert(isa<MDString>(Val));
1322 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1323 cast<MDString>(Val)->getString());
1324 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1325 assert(isa<MDNode>(Val));
1326 DIArray A(cast<MDNode>(Val));
1327 addTemplateParams(*ParamDIE, A);
1334 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1335 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1336 DIE *NDie = getDIE(NS);
1339 NDie = new DIE(dwarf::DW_TAG_namespace);
1340 insertDIE(NS, NDie);
1341 if (!NS.getName().empty()) {
1342 addString(NDie, dwarf::DW_AT_name, NS.getName());
1343 addAccelNamespace(NS.getName(), NDie);
1344 addGlobalName(NS.getName(), NDie, NS.getContext());
1346 addAccelNamespace("(anonymous namespace)", NDie);
1347 addSourceLine(NDie, NS);
1348 addToContextOwner(NDie, NS.getContext());
1352 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1353 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1354 // Construct the context before querying for the existence of the DIE in case
1355 // such construction creates the DIE (as is the case for member function
1357 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1359 ContextDIE = CUDie.get();
1361 DIE *SPDie = getDIE(SP);
1365 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1367 // DW_TAG_inlined_subroutine may refer to this DIE.
1368 insertDIE(SP, SPDie);
1370 DISubprogram SPDecl = SP.getFunctionDeclaration();
1371 DIE *DeclDie = NULL;
1372 if (SPDecl.isSubprogram())
1373 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1375 // Add function template parameters.
1376 addTemplateParams(*SPDie, SP.getTemplateParams());
1378 // If this DIE is going to refer declaration info using AT_specification
1379 // then there is no need to add other attributes.
1381 // Refer function declaration directly.
1382 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1384 // Add subprogram definitions to the CU die directly.
1390 // Add to context owner.
1391 ContextDIE->addChild(SPDie);
1393 // Add the linkage name if we have one.
1394 StringRef LinkageName = SP.getLinkageName();
1395 if (!LinkageName.empty())
1396 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1397 GlobalValue::getRealLinkageName(LinkageName));
1399 // Constructors and operators for anonymous aggregates do not have names.
1400 if (!SP.getName().empty())
1401 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1403 addSourceLine(SPDie, SP);
1405 // Add the prototype if we have a prototype and we have a C like
1407 uint16_t Language = DICompileUnit(Node).getLanguage();
1408 if (SP.isPrototyped() &&
1409 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1410 Language == dwarf::DW_LANG_ObjC))
1411 addFlag(SPDie, dwarf::DW_AT_prototyped);
1413 DICompositeType SPTy = SP.getType();
1414 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1415 "the type of a subprogram should be a subroutine");
1417 DIArray Args = SPTy.getTypeArray();
1418 // Add a return type. If this is a type like a C/C++ void type we don't add a
1420 if (Args.getElement(0))
1421 addType(SPDie, DIType(Args.getElement(0)));
1423 unsigned VK = SP.getVirtuality();
1425 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1426 DIEBlock *Block = getDIEBlock();
1427 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1428 addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1429 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1430 ContainingTypeMap.insert(std::make_pair(SPDie,
1431 resolve(SP.getContainingType())));
1434 if (!SP.isDefinition()) {
1435 addFlag(SPDie, dwarf::DW_AT_declaration);
1437 // Add arguments. Do not add arguments for subprogram definition. They will
1438 // be handled while processing variables.
1439 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1440 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1441 DIType ATy = DIType(Args.getElement(i));
1443 if (ATy.isArtificial())
1444 addFlag(Arg, dwarf::DW_AT_artificial);
1445 SPDie->addChild(Arg);
1449 if (SP.isArtificial())
1450 addFlag(SPDie, dwarf::DW_AT_artificial);
1452 if (!SP.isLocalToUnit())
1453 addFlag(SPDie, dwarf::DW_AT_external);
1455 if (SP.isOptimized())
1456 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1458 if (unsigned isa = Asm->getISAEncoding()) {
1459 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1465 // Return const expression if value is a GEP to access merged global
1467 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1468 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1469 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1470 if (!CE || CE->getNumOperands() != 3 ||
1471 CE->getOpcode() != Instruction::GetElementPtr)
1474 // First operand points to a global struct.
1475 Value *Ptr = CE->getOperand(0);
1476 if (!isa<GlobalValue>(Ptr) ||
1477 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1480 // Second operand is zero.
1481 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1482 if (!CI || !CI->isZero())
1485 // Third operand is offset.
1486 if (!isa<ConstantInt>(CE->getOperand(2)))
1492 /// createGlobalVariableDIE - create global variable DIE.
1493 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1494 // Check for pre-existence.
1498 DIGlobalVariable GV(N);
1499 if (!GV.isGlobalVariable())
1502 DIScope GVContext = GV.getContext();
1503 DIType GTy = GV.getType();
1505 // If this is a static data member definition, some attributes belong
1506 // to the declaration DIE.
1507 DIE *VariableDIE = NULL;
1508 bool IsStaticMember = false;
1509 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1510 if (SDMDecl.Verify()) {
1511 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1512 // We need the declaration DIE that is in the static member's class.
1513 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1514 IsStaticMember = true;
1517 // If this is not a static data member definition, create the variable
1518 // DIE and add the initial set of attributes to it.
1520 VariableDIE = new DIE(GV.getTag());
1522 insertDIE(N, VariableDIE);
1524 // Add name and type.
1525 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1526 addType(VariableDIE, GTy);
1528 // Add scoping info.
1529 if (!GV.isLocalToUnit())
1530 addFlag(VariableDIE, dwarf::DW_AT_external);
1532 // Add line number info.
1533 addSourceLine(VariableDIE, GV);
1534 // Add to context owner.
1535 addToContextOwner(VariableDIE, GVContext);
1539 bool addToAccelTable = false;
1540 DIE *VariableSpecDIE = NULL;
1541 bool isGlobalVariable = GV.getGlobal() != NULL;
1542 if (isGlobalVariable) {
1543 addToAccelTable = true;
1544 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1545 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1546 if (GV.getGlobal()->isThreadLocal()) {
1547 // FIXME: Make this work with -gsplit-dwarf.
1548 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1549 assert((PointerSize == 4 || PointerSize == 8) &&
1550 "Add support for other sizes if necessary");
1551 const MCExpr *Expr =
1552 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1553 // Based on GCC's support for TLS:
1554 if (!DD->useSplitDwarf()) {
1555 // 1) Start with a constNu of the appropriate pointer size
1556 addUInt(Block, dwarf::DW_FORM_data1,
1557 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1558 // 2) containing the (relocated) offset of the TLS variable
1559 // within the module's TLS block.
1560 addExpr(Block, dwarf::DW_FORM_udata, Expr);
1562 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1563 addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1565 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1566 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1568 addOpAddress(Block, Sym);
1569 // Do not create specification DIE if context is either compile unit
1571 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1572 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1573 // Create specification DIE.
1574 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1575 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1576 addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
1577 // A static member's declaration is already flagged as such.
1578 if (!SDMDecl.Verify())
1579 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1580 addDie(VariableSpecDIE);
1582 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1584 // Add the linkage name.
1585 StringRef LinkageName = GV.getLinkageName();
1586 if (!LinkageName.empty())
1587 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1588 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1590 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1592 dwarf::DW_AT_MIPS_linkage_name,
1593 GlobalValue::getRealLinkageName(LinkageName));
1594 } else if (const ConstantInt *CI =
1595 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1596 // AT_const_value was added when the static member was created. To avoid
1597 // emitting AT_const_value multiple times, we only add AT_const_value when
1598 // it is not a static member.
1599 if (!IsStaticMember)
1600 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1601 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1602 addToAccelTable = true;
1603 // GV is a merged global.
1604 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1605 Value *Ptr = CE->getOperand(0);
1606 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1607 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1608 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1609 addUInt(Block, dwarf::DW_FORM_udata,
1610 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1611 addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1612 addBlock(VariableDIE, dwarf::DW_AT_location, Block);
1615 if (addToAccelTable) {
1616 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1617 addAccelName(GV.getName(), AddrDIE);
1619 // If the linkage name is different than the name, go ahead and output
1620 // that as well into the name table.
1621 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1622 addAccelName(GV.getLinkageName(), AddrDIE);
1625 if (!GV.isLocalToUnit())
1626 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1630 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1631 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1633 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1634 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1636 // The LowerBound value defines the lower bounds which is typically zero for
1637 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1638 // Count == -1 then the array is unbounded and we do not emit
1639 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1640 // Count == 0, then the array has zero elements in which case we do not emit
1642 int64_t LowerBound = SR.getLo();
1643 int64_t DefaultLowerBound = getDefaultLowerBound();
1644 int64_t Count = SR.getCount();
1646 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1647 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1649 if (Count != -1 && Count != 0)
1650 // FIXME: An unbounded array should reference the expression that defines
1652 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None, LowerBound + Count - 1);
1654 Buffer.addChild(DW_Subrange);
1657 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1658 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType *CTy) {
1659 if (CTy->isVector())
1660 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1662 // Emit the element type.
1663 addType(&Buffer, resolve(CTy->getTypeDerivedFrom()));
1665 // Get an anonymous type for index type.
1666 // FIXME: This type should be passed down from the front end
1667 // as different languages may have different sizes for indexes.
1668 DIE *IdxTy = getIndexTyDie();
1670 // Construct an anonymous type for index type.
1671 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1672 addString(IdxTy, dwarf::DW_AT_name, "int");
1673 addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
1674 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1675 dwarf::DW_ATE_signed);
1677 setIndexTyDie(IdxTy);
1680 // Add subranges to array type.
1681 DIArray Elements = CTy->getTypeArray();
1682 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1683 DIDescriptor Element = Elements.getElement(i);
1684 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1685 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1689 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1690 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy, DIE &Buffer) {
1691 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1692 Buffer.addChild(Enumerator);
1693 StringRef Name = ETy.getName();
1694 addString(Enumerator, dwarf::DW_AT_name, Name);
1695 int64_t Value = ETy.getEnumValue();
1696 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1700 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1702 void CompileUnit::constructContainingTypeDIEs() {
1703 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1704 CE = ContainingTypeMap.end();
1706 DIE *SPDie = CI->first;
1707 const MDNode *N = CI->second;
1710 DIE *NDie = getDIE(N);
1713 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1717 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1718 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1719 StringRef Name = DV->getName();
1721 // Define variable debug information entry.
1722 DIE *VariableDie = new DIE(DV->getTag());
1723 DbgVariable *AbsVar = DV->getAbstractVariable();
1724 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1726 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1729 addString(VariableDie, dwarf::DW_AT_name, Name);
1730 addSourceLine(VariableDie, DV->getVariable());
1731 addType(VariableDie, DV->getType());
1734 if (DV->isArtificial())
1735 addFlag(VariableDie, dwarf::DW_AT_artificial);
1737 if (isScopeAbstract) {
1738 DV->setDIE(VariableDie);
1742 // Add variable address.
1744 unsigned Offset = DV->getDotDebugLocOffset();
1745 if (Offset != ~0U) {
1746 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1747 Asm->GetTempSymbol("debug_loc", Offset));
1748 DV->setDIE(VariableDie);
1752 // Check if variable is described by a DBG_VALUE instruction.
1753 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1754 assert(DVInsn->getNumOperands() == 3);
1755 if (DVInsn->getOperand(0).isReg()) {
1756 const MachineOperand RegOp = DVInsn->getOperand(0);
1757 // If the second operand is an immediate, this is an indirect value.
1758 if (DVInsn->getOperand(1).isImm()) {
1759 MachineLocation Location(RegOp.getReg(),
1760 DVInsn->getOperand(1).getImm());
1761 addVariableAddress(*DV, VariableDie, Location);
1762 } else if (RegOp.getReg())
1763 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1764 } else if (DVInsn->getOperand(0).isImm())
1765 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1766 else if (DVInsn->getOperand(0).isFPImm())
1767 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1768 else if (DVInsn->getOperand(0).isCImm())
1769 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1770 isUnsignedDIType(DD, DV->getType()));
1772 DV->setDIE(VariableDie);
1775 // .. else use frame index.
1776 int FI = DV->getFrameIndex();
1778 unsigned FrameReg = 0;
1779 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1780 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1781 MachineLocation Location(FrameReg, Offset);
1782 addVariableAddress(*DV, VariableDie, Location);
1786 DV->setDIE(VariableDie);
1790 /// createMemberDIE - Create new member DIE.
1791 DIE *CompileUnit::createMemberDIE(DIDerivedType DT, DIE &Buffer) {
1792 DIE *MemberDie = new DIE(DT.getTag());
1793 Buffer.addChild(MemberDie);
1794 StringRef Name = DT.getName();
1796 addString(MemberDie, dwarf::DW_AT_name, Name);
1798 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1800 addSourceLine(MemberDie, DT);
1802 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1803 addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1805 uint64_t Size = DT.getSizeInBits();
1806 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1808 if (Size != FieldSize) {
1810 addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
1811 getBaseTypeSize(DD, DT) >> 3);
1812 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
1814 uint64_t Offset = DT.getOffsetInBits();
1815 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1816 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1817 uint64_t FieldOffset = (HiMark - FieldSize);
1818 Offset -= FieldOffset;
1820 // Maybe we need to work from the other end.
1821 if (Asm->getDataLayout().isLittleEndian())
1822 Offset = FieldSize - (Offset + Size);
1823 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1825 // Here WD_AT_data_member_location points to the anonymous
1826 // field that includes this bit field.
1827 addUInt(MemLocationDie, dwarf::DW_FORM_udata, FieldOffset >> 3);
1830 // This is not a bitfield.
1831 addUInt(MemLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1833 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1835 // For C++, virtual base classes are not at fixed offset. Use following
1836 // expression to extract appropriate offset from vtable.
1837 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1839 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1840 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1841 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1842 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1843 addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1844 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1845 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1846 addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1848 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1850 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1852 if (DT.isProtected())
1853 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1854 dwarf::DW_ACCESS_protected);
1855 else if (DT.isPrivate())
1856 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1857 dwarf::DW_ACCESS_private);
1858 // Otherwise C++ member and base classes are considered public.
1860 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1861 dwarf::DW_ACCESS_public);
1863 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1864 dwarf::DW_VIRTUALITY_virtual);
1866 // Objective-C properties.
1867 if (MDNode *PNode = DT.getObjCProperty())
1868 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1869 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1872 if (DT.isArtificial())
1873 addFlag(MemberDie, dwarf::DW_AT_artificial);
1878 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1879 DIE *CompileUnit::getOrCreateStaticMemberDIE(const DIDerivedType DT) {
1883 // Construct the context before querying for the existence of the DIE in case
1884 // such construction creates the DIE.
1885 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1886 assert(ContextDIE && "Static member should belong to a non-CU context.");
1888 DIE *StaticMemberDIE = getDIE(DT);
1889 if (StaticMemberDIE)
1890 return StaticMemberDIE;
1892 StaticMemberDIE = new DIE(DT.getTag());
1893 // Add to context owner.
1894 ContextDIE->addChild(StaticMemberDIE);
1896 DIType Ty = resolve(DT.getTypeDerivedFrom());
1898 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1899 addType(StaticMemberDIE, Ty);
1900 addSourceLine(StaticMemberDIE, DT);
1901 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1902 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1904 // FIXME: We could omit private if the parent is a class_type, and
1905 // public if the parent is something else.
1906 if (DT.isProtected())
1907 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1908 dwarf::DW_ACCESS_protected);
1909 else if (DT.isPrivate())
1910 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1911 dwarf::DW_ACCESS_private);
1913 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1914 dwarf::DW_ACCESS_public);
1916 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1917 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1918 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1919 addConstantFPValue(StaticMemberDIE, CFP);
1921 insertDIE(DT, StaticMemberDIE);
1922 return StaticMemberDIE;