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/Support/Debug.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
35 /// CompileUnit - Compile unit constructor.
36 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
37 DwarfDebug *DW, DwarfUnits *DWU)
38 : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0),
40 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
44 /// ~CompileUnit - Destructor for compile unit.
45 CompileUnit::~CompileUnit() {
46 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
47 DIEBlocks[j]->~DIEBlock();
50 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
51 /// information entry.
52 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
53 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
57 /// getDefaultLowerBound - Return the default lower bound for an array. If the
58 /// DWARF version doesn't handle the language, return -1.
59 int64_t CompileUnit::getDefaultLowerBound() const {
60 switch (DICompileUnit(Node).getLanguage()) {
64 case dwarf::DW_LANG_C89:
65 case dwarf::DW_LANG_C99:
66 case dwarf::DW_LANG_C:
67 case dwarf::DW_LANG_C_plus_plus:
68 case dwarf::DW_LANG_ObjC:
69 case dwarf::DW_LANG_ObjC_plus_plus:
72 case dwarf::DW_LANG_Fortran77:
73 case dwarf::DW_LANG_Fortran90:
74 case dwarf::DW_LANG_Fortran95:
77 // The languages below have valid values only if the DWARF version >= 4.
78 case dwarf::DW_LANG_Java:
79 case dwarf::DW_LANG_Python:
80 case dwarf::DW_LANG_UPC:
81 case dwarf::DW_LANG_D:
82 if (dwarf::DWARF_VERSION >= 4)
86 case dwarf::DW_LANG_Ada83:
87 case dwarf::DW_LANG_Ada95:
88 case dwarf::DW_LANG_Cobol74:
89 case dwarf::DW_LANG_Cobol85:
90 case dwarf::DW_LANG_Modula2:
91 case dwarf::DW_LANG_Pascal83:
92 case dwarf::DW_LANG_PLI:
93 if (dwarf::DWARF_VERSION >= 4)
101 /// addFlag - Add a flag that is true.
102 void CompileUnit::addFlag(DIE *Die, uint16_t Attribute) {
103 if (DD->getDwarfVersion() >= 4)
104 Die->addValue(Attribute, dwarf::DW_FORM_flag_present,
107 addUInt(Die, Attribute, dwarf::DW_FORM_flag, 1);
110 /// addUInt - Add an unsigned integer attribute data and value.
112 void CompileUnit::addUInt(DIE *Die, uint16_t Attribute,
113 uint16_t Form, uint64_t Integer) {
114 if (!Form) Form = DIEInteger::BestForm(false, Integer);
115 DIEValue *Value = Integer == 1 ?
116 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
117 Die->addValue(Attribute, Form, Value);
120 /// addSInt - Add an signed integer attribute data and value.
122 void CompileUnit::addSInt(DIE *Die, uint16_t Attribute,
123 uint16_t Form, int64_t Integer) {
124 if (!Form) Form = DIEInteger::BestForm(true, Integer);
125 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
126 Die->addValue(Attribute, Form, Value);
129 /// addString - Add a string attribute data and value. We always emit a
130 /// reference to the string pool instead of immediate strings so that DIEs have
131 /// more predictable sizes. In the case of split dwarf we emit an index
132 /// into another table which gets us the static offset into the string
134 void CompileUnit::addString(DIE *Die, uint16_t Attribute, StringRef String) {
137 if (!DD->useSplitDwarf()) {
138 MCSymbol *Symb = DU->getStringPoolEntry(String);
139 if (Asm->needsRelocationsForDwarfStringPool())
140 Value = new (DIEValueAllocator) DIELabel(Symb);
142 MCSymbol *StringPool = DU->getStringPoolSym();
143 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
145 Form = dwarf::DW_FORM_strp;
147 unsigned idx = DU->getStringPoolIndex(String);
148 Value = new (DIEValueAllocator) DIEInteger(idx);
149 Form = dwarf::DW_FORM_GNU_str_index;
151 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
152 Die->addValue(Attribute, Form, Str);
155 /// addLocalString - Add a string attribute data and value. This is guaranteed
156 /// to be in the local string pool instead of indirected.
157 void CompileUnit::addLocalString(DIE *Die, uint16_t Attribute,
159 MCSymbol *Symb = DU->getStringPoolEntry(String);
161 if (Asm->needsRelocationsForDwarfStringPool())
162 Value = new (DIEValueAllocator) DIELabel(Symb);
164 MCSymbol *StringPool = DU->getStringPoolSym();
165 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
167 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
170 /// addExpr - Add a Dwarf expression attribute data and value.
172 void CompileUnit::addExpr(DIE *Die, uint16_t Attribute, uint16_t Form,
173 const MCExpr *Expr) {
174 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
175 Die->addValue(Attribute, Form, Value);
178 /// addLabel - Add a Dwarf label attribute data and value.
180 void CompileUnit::addLabel(DIE *Die, uint16_t Attribute, uint16_t Form,
181 const MCSymbol *Label) {
182 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
183 Die->addValue(Attribute, Form, Value);
192 /// addLabelAddress - Add a dwarf label attribute data and value using
193 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
195 void CompileUnit::addLabelAddress(DIE *Die, uint16_t Attribute,
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(DIE *Die, const MCSymbol *Sym) {
224 if (!DD->useSplitDwarf()) {
225 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
226 addLabel(Die, 0, dwarf::DW_FORM_udata, Sym);
228 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
229 addUInt(Die, 0, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
233 /// addDelta - Add a label delta attribute data and value.
235 void CompileUnit::addDelta(DIE *Die, uint16_t Attribute, uint16_t Form,
236 const MCSymbol *Hi, const MCSymbol *Lo) {
237 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
238 Die->addValue(Attribute, Form, Value);
241 /// addDIEEntry - Add a DIE attribute data and value.
243 void CompileUnit::addDIEEntry(DIE *Die, uint16_t Attribute, uint16_t Form,
245 Die->addValue(Attribute, Form, createDIEEntry(Entry));
248 /// addBlock - Add block data.
250 void CompileUnit::addBlock(DIE *Die, uint16_t Attribute, uint16_t Form,
252 Block->ComputeSize(Asm);
253 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
254 Die->addValue(Attribute, Block->BestForm(), Block);
257 /// addSourceLine - Add location information to specified debug information
259 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
264 unsigned Line = V.getLineNumber();
267 unsigned FileID = DD->getOrCreateSourceID(V.getContext().getFilename(),
268 V.getContext().getDirectory(),
270 assert(FileID && "Invalid file id");
271 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
272 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
275 /// addSourceLine - Add location information to specified debug information
277 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
278 // Verify global variable.
279 if (!G.isGlobalVariable())
282 unsigned Line = G.getLineNumber();
285 unsigned FileID = DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(),
287 assert(FileID && "Invalid file id");
288 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
289 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
292 /// addSourceLine - Add location information to specified debug information
294 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
295 // Verify subprogram.
296 if (!SP.isSubprogram())
299 // If the line number is 0, don't add it.
300 unsigned Line = SP.getLineNumber();
304 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(),
305 SP.getDirectory(), getUniqueID());
306 assert(FileID && "Invalid file id");
307 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
308 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
311 /// addSourceLine - Add location information to specified debug information
313 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
318 unsigned Line = Ty.getLineNumber();
321 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(),
322 Ty.getDirectory(), getUniqueID());
323 assert(FileID && "Invalid file id");
324 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
325 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
328 /// addSourceLine - Add location information to specified debug information
330 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
332 if (!Ty.isObjCProperty())
335 unsigned Line = Ty.getLineNumber();
338 DIFile File = Ty.getFile();
339 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
340 File.getDirectory(), getUniqueID());
341 assert(FileID && "Invalid file id");
342 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
343 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
346 /// addSourceLine - Add location information to specified debug information
348 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
353 unsigned Line = NS.getLineNumber();
356 StringRef FN = NS.getFilename();
358 unsigned FileID = DD->getOrCreateSourceID(FN, NS.getDirectory(),
360 assert(FileID && "Invalid file id");
361 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
362 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
365 /// addVariableAddress - Add DW_AT_location attribute for a
366 /// DbgVariable based on provided MachineLocation.
367 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
368 MachineLocation Location) {
369 if (DV.variableHasComplexAddress())
370 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
371 else if (DV.isBlockByrefVariable())
372 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
374 addAddress(Die, dwarf::DW_AT_location, Location,
375 DV.getVariable().isIndirect());
378 /// addRegisterOp - Add register operand.
379 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
380 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
381 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
383 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
385 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
386 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
390 /// addRegisterOffset - Add register offset.
391 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
393 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
394 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
395 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
396 if (Reg == TRI->getFrameRegister(*Asm->MF))
397 // If variable offset is based in frame register then use fbreg.
398 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
400 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
402 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
403 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
405 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
408 /// addAddress - Add an address attribute to a die based on the location
410 void CompileUnit::addAddress(DIE *Die, uint16_t Attribute,
411 const MachineLocation &Location, bool Indirect) {
412 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
414 if (Location.isReg() && !Indirect)
415 addRegisterOp(Block, Location.getReg());
417 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
418 if (Indirect && !Location.isReg()) {
419 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
423 // Now attach the location information to the DIE.
424 addBlock(Die, Attribute, 0, Block);
427 /// addComplexAddress - Start with the address based on the location provided,
428 /// and generate the DWARF information necessary to find the actual variable
429 /// given the extra address information encoded in the DIVariable, starting from
430 /// the starting location. Add the DWARF information to the die.
432 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
434 const MachineLocation &Location) {
435 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
436 unsigned N = DV.getNumAddrElements();
438 if (Location.isReg()) {
439 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
440 // If first address element is OpPlus then emit
441 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
442 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
445 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, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
454 addUInt(Block, 0, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
455 } else if (Element == DIBuilder::OpDeref) {
456 if (!Location.isReg())
457 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
458 } else llvm_unreachable("unknown DIBuilder Opcode");
461 // Now attach the location information to the DIE.
462 addBlock(Die, Attribute, 0, Block);
465 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
466 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
467 gives the variable VarName either the struct, or a pointer to the struct, as
468 its type. This is necessary for various behind-the-scenes things the
469 compiler needs to do with by-reference variables in Blocks.
471 However, as far as the original *programmer* is concerned, the variable
472 should still have type 'SomeType', as originally declared.
474 The function getBlockByrefType dives into the __Block_byref_x_VarName
475 struct to find the original type of the variable, which is then assigned to
476 the variable's Debug Information Entry as its real type. So far, so good.
477 However now the debugger will expect the variable VarName to have the type
478 SomeType. So we need the location attribute for the variable to be an
479 expression that explains to the debugger how to navigate through the
480 pointers and struct to find the actual variable of type SomeType.
482 The following function does just that. We start by getting
483 the "normal" location for the variable. This will be the location
484 of either the struct __Block_byref_x_VarName or the pointer to the
485 struct __Block_byref_x_VarName.
487 The struct will look something like:
489 struct __Block_byref_x_VarName {
491 struct __Block_byref_x_VarName *forwarding;
492 ... <various other fields>
494 ... <maybe more fields>
497 If we are given the struct directly (as our starting point) we
498 need to tell the debugger to:
500 1). Add the offset of the forwarding field.
502 2). Follow that pointer to get the real __Block_byref_x_VarName
503 struct to use (the real one may have been copied onto the heap).
505 3). Add the offset for the field VarName, to find the actual variable.
507 If we started with a pointer to the struct, then we need to
508 dereference that pointer first, before the other steps.
509 Translating this into DWARF ops, we will need to append the following
510 to the current location description for the variable:
512 DW_OP_deref -- optional, if we start with a pointer
513 DW_OP_plus_uconst <forward_fld_offset>
515 DW_OP_plus_uconst <varName_fld_offset>
517 That is what this function does. */
519 /// addBlockByrefAddress - Start with the address based on the location
520 /// provided, and generate the DWARF information necessary to find the
521 /// actual Block variable (navigating the Block struct) based on the
522 /// starting location. Add the DWARF information to the die. For
523 /// more information, read large comment just above here.
525 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
527 const MachineLocation &Location) {
528 DIType Ty = DV.getType();
530 uint16_t Tag = Ty.getTag();
531 bool isPointer = false;
533 StringRef varName = DV.getName();
535 if (Tag == dwarf::DW_TAG_pointer_type) {
536 DIDerivedType DTy = DIDerivedType(Ty);
537 TmpTy = DTy.getTypeDerivedFrom();
541 DICompositeType blockStruct = DICompositeType(TmpTy);
543 // Find the __forwarding field and the variable field in the __Block_byref
545 DIArray Fields = blockStruct.getTypeArray();
546 DIDescriptor varField = DIDescriptor();
547 DIDescriptor forwardingField = DIDescriptor();
549 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
550 DIDescriptor Element = Fields.getElement(i);
551 DIDerivedType DT = DIDerivedType(Element);
552 StringRef fieldName = DT.getName();
553 if (fieldName == "__forwarding")
554 forwardingField = Element;
555 else if (fieldName == varName)
559 // Get the offsets for the forwarding field and the variable field.
560 unsigned forwardingFieldOffset =
561 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
562 unsigned varFieldOffset =
563 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, 0, 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, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
584 addUInt(Block, 0, 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, 0, 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, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
596 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
599 // Now attach the location information to the DIE.
600 addBlock(Die, Attribute, 0, Block);
603 /// isTypeSigned - Return true if the type is signed.
604 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
605 if (Ty.isDerivedType())
606 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
607 if (Ty.isBasicType())
608 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
609 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
610 *SizeInBits = Ty.getSizeInBits();
616 /// addConstantValue - Add constant value entry in variable DIE.
617 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
619 // FIXME: This is a bit conservative/simple - it emits negative values at
620 // their maximum bit width which is a bit unfortunate (& doesn't prefer
621 // udata/sdata over dataN as suggested by the DWARF spec)
622 assert(MO.isImm() && "Invalid machine operand!");
624 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
627 // If we're a signed constant definitely use sdata.
628 if (SignedConstant) {
629 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
633 // Else use data for now unless it's larger than we can deal with.
634 switch (SizeInBits) {
636 Form = dwarf::DW_FORM_data1;
639 Form = dwarf::DW_FORM_data2;
642 Form = dwarf::DW_FORM_data4;
645 Form = dwarf::DW_FORM_data8;
648 Form = dwarf::DW_FORM_udata;
649 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
652 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
655 /// addConstantFPValue - Add constant value entry in variable DIE.
656 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
657 assert (MO.isFPImm() && "Invalid machine operand!");
658 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
659 APFloat FPImm = MO.getFPImm()->getValueAPF();
661 // Get the raw data form of the floating point.
662 const APInt FltVal = FPImm.bitcastToAPInt();
663 const char *FltPtr = (const char*)FltVal.getRawData();
665 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
666 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
667 int Incr = (LittleEndian ? 1 : -1);
668 int Start = (LittleEndian ? 0 : NumBytes - 1);
669 int Stop = (LittleEndian ? NumBytes : -1);
671 // Output the constant to DWARF one byte at a time.
672 for (; Start != Stop; Start += Incr)
673 addUInt(Block, 0, dwarf::DW_FORM_data1,
674 (unsigned char)0xFF & FltPtr[Start]);
676 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
679 /// addConstantFPValue - Add constant value entry in variable DIE.
680 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
681 // Pass this down to addConstantValue as an unsigned bag of bits.
682 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
685 /// addConstantValue - Add constant value entry in variable DIE.
686 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
688 addConstantValue(Die, CI->getValue(), Unsigned);
691 // addConstantValue - Add constant value entry in variable DIE.
692 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
693 unsigned CIBitWidth = Val.getBitWidth();
694 if (CIBitWidth <= 64) {
695 // If we're a signed constant definitely use sdata.
697 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
702 // Else use data for now unless it's larger than we can deal with.
704 switch (CIBitWidth) {
706 Form = dwarf::DW_FORM_data1;
709 Form = dwarf::DW_FORM_data2;
712 Form = dwarf::DW_FORM_data4;
715 Form = dwarf::DW_FORM_data8;
718 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
722 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
728 // Get the raw data form of the large APInt.
729 const uint64_t *Ptr64 = Val.getRawData();
731 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
732 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
734 // Output the constant to DWARF one byte at a time.
735 for (int i = 0; i < NumBytes; i++) {
738 c = Ptr64[i / 8] >> (8 * (i & 7));
740 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
741 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
744 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
747 /// addTemplateParams - Add template parameters into buffer.
748 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
749 // Add template parameters.
750 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
751 DIDescriptor Element = TParams.getElement(i);
752 if (Element.isTemplateTypeParameter())
753 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
754 DITemplateTypeParameter(Element)));
755 else if (Element.isTemplateValueParameter())
756 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
757 DITemplateValueParameter(Element)));
761 /// getOrCreateContextDIE - Get context owner's DIE.
762 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) {
763 if (Context.isType())
764 return getOrCreateTypeDIE(DIType(Context));
765 else if (Context.isNameSpace())
766 return getOrCreateNameSpace(DINameSpace(Context));
767 else if (Context.isSubprogram())
768 return getOrCreateSubprogramDIE(DISubprogram(Context));
770 return getDIE(Context);
773 /// addToContextOwner - Add Die into the list of its context owner's children.
774 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
775 if (DIE *ContextDIE = getOrCreateContextDIE(Context))
776 ContextDIE->addChild(Die);
781 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
783 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
787 DIE *TyDIE = getDIE(Ty);
792 TyDIE = new DIE(dwarf::DW_TAG_base_type);
793 insertDIE(Ty, TyDIE);
794 if (Ty.isBasicType())
795 constructTypeDIE(*TyDIE, DIBasicType(Ty));
796 else if (Ty.isCompositeType())
797 constructTypeDIE(*TyDIE, DICompositeType(Ty));
799 assert(Ty.isDerivedType() && "Unknown kind of DIType");
800 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
802 // If this is a named finished type then include it in the list of types
803 // for the accelerator tables.
804 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
805 bool IsImplementation = 0;
806 if (Ty.isCompositeType()) {
807 DICompositeType CT(Ty);
808 // A runtime language of 0 actually means C/C++ and that any
809 // non-negative value is some version of Objective-C/C++.
810 IsImplementation = (CT.getRunTimeLang() == 0) ||
811 CT.isObjcClassComplete();
813 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
814 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
817 addToContextOwner(TyDIE, DD->resolve(Ty.getContext()));
821 /// addType - Add a new type attribute to the specified entity.
822 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
823 assert(Ty && "Trying to add a type that doesn't exist?");
825 // Check for pre-existence.
826 DIEEntry *Entry = getDIEEntry(Ty);
827 // If it exists then use the existing value.
829 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
834 DIE *Buffer = getOrCreateTypeDIE(Ty);
837 Entry = createDIEEntry(Buffer);
838 insertDIEEntry(Ty, Entry);
839 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
841 // If this is a complete composite type then include it in the
842 // list of global types.
846 /// addGlobalName - Add a new global name to the compile unit.
847 void CompileUnit::addGlobalName(StringRef Name, DIE *Die) {
848 GlobalNames[Name] = Die;
851 /// addGlobalType - Add a new global type to the compile unit.
853 void CompileUnit::addGlobalType(DIType Ty) {
854 DIDescriptor Context = DD->resolve(Ty.getContext());
855 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
856 && (!Context || Context.isCompileUnit() || Context.isFile()
857 || Context.isNameSpace()))
858 if (DIEEntry *Entry = getDIEEntry(Ty))
859 GlobalTypes[Ty.getName()] = Entry->getEntry();
862 /// addPubTypes - Add type for pubtypes section.
863 void CompileUnit::addPubTypes(DISubprogram SP) {
864 DICompositeType SPTy = SP.getType();
865 uint16_t SPTag = SPTy.getTag();
866 if (SPTag != dwarf::DW_TAG_subroutine_type)
869 DIArray Args = SPTy.getTypeArray();
870 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
871 DIType ATy(Args.getElement(i));
878 /// constructTypeDIE - Construct basic type die from DIBasicType.
879 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
880 // Get core information.
881 StringRef Name = BTy.getName();
882 // Add name if not anonymous or intermediate type.
884 addString(&Buffer, dwarf::DW_AT_name, Name);
886 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
887 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
888 // An unspecified type only has a name attribute.
892 Buffer.setTag(dwarf::DW_TAG_base_type);
893 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
896 uint64_t Size = BTy.getSizeInBits() >> 3;
897 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
900 /// constructTypeDIE - Construct derived type die from DIDerivedType.
901 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
902 // Get core information.
903 StringRef Name = DTy.getName();
904 uint64_t Size = DTy.getSizeInBits() >> 3;
905 uint16_t Tag = DTy.getTag();
907 // FIXME - Workaround for templates.
908 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
912 // Map to main type, void will not have a type.
913 DIType FromTy = DTy.getTypeDerivedFrom();
915 addType(&Buffer, FromTy);
917 // Add name if not anonymous or intermediate type.
919 addString(&Buffer, dwarf::DW_AT_name, Name);
921 // Add size if non-zero (derived types might be zero-sized.)
922 if (Size && Tag != dwarf::DW_TAG_pointer_type)
923 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
925 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
926 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
927 getOrCreateTypeDIE(DD->resolve(DTy.getClassType())));
928 // Add source line info if available and TyDesc is not a forward declaration.
929 if (!DTy.isForwardDecl())
930 addSourceLine(&Buffer, DTy);
933 /// Return true if the type is appropriately scoped to be contained inside
934 /// its own type unit.
935 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
936 DIScope Parent = DD->resolve(Ty.getContext());
938 // Don't generate a hash for anything scoped inside a function.
939 if (Parent.isSubprogram())
941 Parent = DD->resolve(Parent.getContext());
946 /// Return true if the type should be split out into a type unit.
947 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
948 uint16_t Tag = CTy.getTag();
951 case dwarf::DW_TAG_structure_type:
952 case dwarf::DW_TAG_union_type:
953 case dwarf::DW_TAG_enumeration_type:
954 case dwarf::DW_TAG_class_type:
955 // If this is a class, structure, union, or enumeration type
956 // that is not a declaration, is a type definition, and not scoped
957 // inside a function then separate this out as a type unit.
958 if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy, DD))
966 /// constructTypeDIE - Construct type DIE from DICompositeType.
967 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
968 // Get core information.
969 StringRef Name = CTy.getName();
971 uint64_t Size = CTy.getSizeInBits() >> 3;
972 uint16_t Tag = CTy.getTag();
976 case dwarf::DW_TAG_array_type:
977 constructArrayTypeDIE(Buffer, &CTy);
979 case dwarf::DW_TAG_enumeration_type: {
980 DIArray Elements = CTy.getTypeArray();
982 // Add enumerators to enumeration type.
983 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
985 DIDescriptor Enum(Elements.getElement(i));
986 if (Enum.isEnumerator()) {
987 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
988 Buffer.addChild(ElemDie);
991 DIType DTy = CTy.getTypeDerivedFrom();
993 addType(&Buffer, DTy);
994 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
998 case dwarf::DW_TAG_subroutine_type: {
999 // Add return type. A void return won't have a type.
1000 DIArray Elements = CTy.getTypeArray();
1001 DIDescriptor RTy = Elements.getElement(0);
1003 addType(&Buffer, DIType(RTy));
1005 bool isPrototyped = true;
1007 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1008 DIDescriptor Ty = Elements.getElement(i);
1009 if (Ty.isUnspecifiedParameter()) {
1010 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1011 Buffer.addChild(Arg);
1012 isPrototyped = false;
1014 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1015 addType(Arg, DIType(Ty));
1016 if (DIType(Ty).isArtificial())
1017 addFlag(Arg, dwarf::DW_AT_artificial);
1018 Buffer.addChild(Arg);
1021 // Add prototype flag if we're dealing with a C language and the
1022 // function has been prototyped.
1023 uint16_t Language = DICompileUnit(Node).getLanguage();
1025 (Language == dwarf::DW_LANG_C89 ||
1026 Language == dwarf::DW_LANG_C99 ||
1027 Language == dwarf::DW_LANG_ObjC))
1028 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1031 case dwarf::DW_TAG_structure_type:
1032 case dwarf::DW_TAG_union_type:
1033 case dwarf::DW_TAG_class_type: {
1034 // Add elements to structure type.
1035 DIArray Elements = CTy.getTypeArray();
1036 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1037 DIDescriptor Element = Elements.getElement(i);
1038 DIE *ElemDie = NULL;
1039 if (Element.isSubprogram()) {
1040 DISubprogram SP(Element);
1041 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1042 if (SP.isProtected())
1043 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1044 dwarf::DW_ACCESS_protected);
1045 else if (SP.isPrivate())
1046 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1047 dwarf::DW_ACCESS_private);
1049 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1050 dwarf::DW_ACCESS_public);
1051 if (SP.isExplicit())
1052 addFlag(ElemDie, dwarf::DW_AT_explicit);
1053 } else if (Element.isDerivedType()) {
1054 DIDerivedType DDTy(Element);
1055 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1056 ElemDie = new DIE(dwarf::DW_TAG_friend);
1057 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1058 } else if (DDTy.isStaticMember())
1059 ElemDie = createStaticMemberDIE(DDTy);
1061 ElemDie = createMemberDIE(DDTy);
1062 } else if (Element.isObjCProperty()) {
1063 DIObjCProperty Property(Element);
1064 ElemDie = new DIE(Property.getTag());
1065 StringRef PropertyName = Property.getObjCPropertyName();
1066 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1067 addType(ElemDie, Property.getType());
1068 addSourceLine(ElemDie, Property);
1069 StringRef GetterName = Property.getObjCPropertyGetterName();
1070 if (!GetterName.empty())
1071 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1072 StringRef SetterName = Property.getObjCPropertySetterName();
1073 if (!SetterName.empty())
1074 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1075 unsigned PropertyAttributes = 0;
1076 if (Property.isReadOnlyObjCProperty())
1077 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1078 if (Property.isReadWriteObjCProperty())
1079 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1080 if (Property.isAssignObjCProperty())
1081 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1082 if (Property.isRetainObjCProperty())
1083 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1084 if (Property.isCopyObjCProperty())
1085 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1086 if (Property.isNonAtomicObjCProperty())
1087 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1088 if (PropertyAttributes)
1089 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1090 PropertyAttributes);
1092 DIEEntry *Entry = getDIEEntry(Element);
1094 Entry = createDIEEntry(ElemDie);
1095 insertDIEEntry(Element, Entry);
1099 Buffer.addChild(ElemDie);
1102 if (CTy.isAppleBlockExtension())
1103 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1105 DICompositeType ContainingType(DD->resolve(CTy.getContainingType()));
1106 if (DIDescriptor(ContainingType).isCompositeType())
1107 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1108 getOrCreateTypeDIE(DIType(ContainingType)));
1110 addToContextOwner(&Buffer, DD->resolve(CTy.getContext()));
1112 if (CTy.isObjcClassComplete())
1113 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1115 // Add template parameters to a class, structure or union types.
1116 // FIXME: The support isn't in the metadata for this yet.
1117 if (Tag == dwarf::DW_TAG_class_type ||
1118 Tag == dwarf::DW_TAG_structure_type ||
1119 Tag == dwarf::DW_TAG_union_type)
1120 addTemplateParams(Buffer, CTy.getTemplateParams());
1128 // Add name if not anonymous or intermediate type.
1130 addString(&Buffer, dwarf::DW_AT_name, Name);
1132 if (Tag == dwarf::DW_TAG_enumeration_type ||
1133 Tag == dwarf::DW_TAG_class_type ||
1134 Tag == dwarf::DW_TAG_structure_type ||
1135 Tag == dwarf::DW_TAG_union_type) {
1136 // Add size if non-zero (derived types might be zero-sized.)
1137 // TODO: Do we care about size for enum forward declarations?
1139 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1140 else if (!CTy.isForwardDecl())
1141 // Add zero size if it is not a forward declaration.
1142 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1144 // If we're a forward decl, say so.
1145 if (CTy.isForwardDecl())
1146 addFlag(&Buffer, dwarf::DW_AT_declaration);
1148 // Add source line info if available.
1149 if (!CTy.isForwardDecl())
1150 addSourceLine(&Buffer, CTy);
1152 // No harm in adding the runtime language to the declaration.
1153 unsigned RLang = CTy.getRunTimeLang();
1155 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1156 dwarf::DW_FORM_data1, RLang);
1158 // If this is a type applicable to a type unit it then add it to the
1159 // list of types we'll compute a hash for later.
1160 if (shouldCreateTypeUnit(CTy, DD))
1161 DD->addTypeUnitType(&Buffer);
1164 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1165 /// for the given DITemplateTypeParameter.
1167 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1168 DIE *ParamDIE = getDIE(TP);
1172 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1173 // Add the type if it exists, it could be void and therefore no type.
1175 addType(ParamDIE, TP.getType());
1176 if (!TP.getName().empty())
1177 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1181 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1182 /// for the given DITemplateValueParameter.
1184 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1185 DIE *ParamDIE = getDIE(VP);
1189 ParamDIE = new DIE(VP.getTag());
1191 // Add the type if there is one, template template and template parameter
1192 // packs will not have a type.
1194 addType(ParamDIE, VP.getType());
1195 if (!VP.getName().empty())
1196 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1197 if (Value *Val = VP.getValue()) {
1198 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1199 addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1200 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1201 // For declaration non-type template parameters (such as global values and
1203 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1204 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1205 // Emit DW_OP_stack_value to use the address as the immediate value of the
1206 // parameter, rather than a pointer to it.
1207 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1208 addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1209 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1210 assert(isa<MDString>(Val));
1211 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1212 cast<MDString>(Val)->getString());
1213 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1214 assert(isa<MDNode>(Val));
1215 DIArray A(cast<MDNode>(Val));
1216 addTemplateParams(*ParamDIE, A);
1223 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1224 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1225 DIE *NDie = getDIE(NS);
1228 NDie = new DIE(dwarf::DW_TAG_namespace);
1229 insertDIE(NS, NDie);
1230 if (!NS.getName().empty()) {
1231 addString(NDie, dwarf::DW_AT_name, NS.getName());
1232 addAccelNamespace(NS.getName(), NDie);
1234 addAccelNamespace("(anonymous namespace)", NDie);
1235 addSourceLine(NDie, NS);
1236 addToContextOwner(NDie, NS.getContext());
1240 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1241 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1242 DIE *SPDie = getDIE(SP);
1246 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1248 // DW_TAG_inlined_subroutine may refer to this DIE.
1249 insertDIE(SP, SPDie);
1251 DISubprogram SPDecl = SP.getFunctionDeclaration();
1252 DIE *DeclDie = NULL;
1253 if (SPDecl.isSubprogram()) {
1254 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1257 // Add to context owner.
1258 addToContextOwner(SPDie, SP.getContext());
1260 // Add function template parameters.
1261 addTemplateParams(*SPDie, SP.getTemplateParams());
1263 // If this DIE is going to refer declaration info using AT_specification
1264 // then there is no need to add other attributes.
1266 // Refer function declaration directly.
1267 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1273 // Add the linkage name if we have one.
1274 StringRef LinkageName = SP.getLinkageName();
1275 if (!LinkageName.empty())
1276 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1277 GlobalValue::getRealLinkageName(LinkageName));
1279 // Constructors and operators for anonymous aggregates do not have names.
1280 if (!SP.getName().empty())
1281 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1283 addSourceLine(SPDie, SP);
1285 // Add the prototype if we have a prototype and we have a C like
1287 uint16_t Language = DICompileUnit(Node).getLanguage();
1288 if (SP.isPrototyped() &&
1289 (Language == dwarf::DW_LANG_C89 ||
1290 Language == dwarf::DW_LANG_C99 ||
1291 Language == dwarf::DW_LANG_ObjC))
1292 addFlag(SPDie, dwarf::DW_AT_prototyped);
1294 // Add Return Type. A void return type will not have a type.
1295 DICompositeType SPTy = SP.getType();
1296 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1297 "the type of a subprogram should be a subroutine");
1299 DIArray Args = SPTy.getTypeArray();
1300 if (Args.getElement(0))
1301 addType(SPDie, DIType(Args.getElement(0)));
1303 unsigned VK = SP.getVirtuality();
1305 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1306 DIEBlock *Block = getDIEBlock();
1307 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1308 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1309 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1310 ContainingTypeMap.insert(std::make_pair(SPDie,
1311 DD->resolve(SP.getContainingType())));
1314 if (!SP.isDefinition()) {
1315 addFlag(SPDie, dwarf::DW_AT_declaration);
1317 // Add arguments. Do not add arguments for subprogram definition. They will
1318 // be handled while processing variables.
1319 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1320 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1321 DIType ATy = DIType(Args.getElement(i));
1323 if (ATy.isArtificial())
1324 addFlag(Arg, dwarf::DW_AT_artificial);
1325 SPDie->addChild(Arg);
1329 if (SP.isArtificial())
1330 addFlag(SPDie, dwarf::DW_AT_artificial);
1332 if (!SP.isLocalToUnit())
1333 addFlag(SPDie, dwarf::DW_AT_external);
1335 if (SP.isOptimized())
1336 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1338 if (unsigned isa = Asm->getISAEncoding()) {
1339 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1345 // Return const expression if value is a GEP to access merged global
1347 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1348 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1349 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1350 if (!CE || CE->getNumOperands() != 3 ||
1351 CE->getOpcode() != Instruction::GetElementPtr)
1354 // First operand points to a global struct.
1355 Value *Ptr = CE->getOperand(0);
1356 if (!isa<GlobalValue>(Ptr) ||
1357 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1360 // Second operand is zero.
1361 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1362 if (!CI || !CI->isZero())
1365 // Third operand is offset.
1366 if (!isa<ConstantInt>(CE->getOperand(2)))
1372 /// createGlobalVariableDIE - create global variable DIE.
1373 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1374 // Check for pre-existence.
1378 DIGlobalVariable GV(N);
1379 if (!GV.isGlobalVariable())
1382 DIDescriptor GVContext = GV.getContext();
1383 DIType GTy = GV.getType();
1385 // If this is a static data member definition, some attributes belong
1386 // to the declaration DIE.
1387 DIE *VariableDIE = NULL;
1388 bool IsStaticMember = false;
1389 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1390 if (SDMDecl.Verify()) {
1391 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1392 // We need the declaration DIE that is in the static member's class.
1393 // But that class might not exist in the DWARF yet.
1394 // Creating the class will create the static member decl DIE.
1395 getOrCreateContextDIE(DD->resolve(SDMDecl.getContext()));
1396 VariableDIE = getDIE(SDMDecl);
1397 assert(VariableDIE && "Static member decl has no context?");
1398 IsStaticMember = true;
1401 // If this is not a static data member definition, create the variable
1402 // DIE and add the initial set of attributes to it.
1404 VariableDIE = new DIE(GV.getTag());
1406 insertDIE(N, VariableDIE);
1408 // Add name and type.
1409 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1410 addType(VariableDIE, GTy);
1412 // Add scoping info.
1413 if (!GV.isLocalToUnit()) {
1414 addFlag(VariableDIE, dwarf::DW_AT_external);
1415 addGlobalName(GV.getName(), VariableDIE);
1418 // Add line number info.
1419 addSourceLine(VariableDIE, GV);
1420 // Add to context owner.
1421 addToContextOwner(VariableDIE, GVContext);
1425 bool addToAccelTable = false;
1426 DIE *VariableSpecDIE = NULL;
1427 bool isGlobalVariable = GV.getGlobal() != NULL;
1428 if (isGlobalVariable) {
1429 addToAccelTable = true;
1430 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1431 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1432 if (GV.getGlobal()->isThreadLocal()) {
1433 // FIXME: Make this work with -gsplit-dwarf.
1434 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1435 assert((PointerSize == 4 || PointerSize == 8) &&
1436 "Add support for other sizes if necessary");
1437 const MCExpr *Expr =
1438 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1439 // Based on GCC's support for TLS:
1440 if (!DD->useSplitDwarf()) {
1441 // 1) Start with a constNu of the appropriate pointer size
1442 addUInt(Block, 0, dwarf::DW_FORM_data1,
1443 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1444 // 2) containing the (relocated) address of the TLS variable
1445 addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1447 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1448 addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1450 // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1451 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1453 addOpAddress(Block, Sym);
1454 // Do not create specification DIE if context is either compile unit
1456 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1457 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1458 // Create specification DIE.
1459 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1460 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1461 dwarf::DW_FORM_ref4, VariableDIE);
1462 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1463 // A static member's declaration is already flagged as such.
1464 if (!SDMDecl.Verify())
1465 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1466 addDie(VariableSpecDIE);
1468 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1470 // Add the linkage name.
1471 StringRef LinkageName = GV.getLinkageName();
1472 if (!LinkageName.empty())
1473 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1474 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1476 addString(IsStaticMember && VariableSpecDIE ?
1477 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1478 GlobalValue::getRealLinkageName(LinkageName));
1479 } else if (const ConstantInt *CI =
1480 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1481 // AT_const_value was added when the static member was created. To avoid
1482 // emitting AT_const_value multiple times, we only add AT_const_value when
1483 // it is not a static member.
1484 if (!IsStaticMember)
1485 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1486 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1487 addToAccelTable = true;
1488 // GV is a merged global.
1489 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1490 Value *Ptr = CE->getOperand(0);
1491 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1492 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1493 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1494 addUInt(Block, 0, dwarf::DW_FORM_udata,
1495 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1496 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1497 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1500 if (addToAccelTable) {
1501 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1502 addAccelName(GV.getName(), AddrDIE);
1504 // If the linkage name is different than the name, go ahead and output
1505 // that as well into the name table.
1506 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1507 addAccelName(GV.getLinkageName(), AddrDIE);
1511 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1512 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1514 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1515 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1517 // The LowerBound value defines the lower bounds which is typically zero for
1518 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1519 // Count == -1 then the array is unbounded and we do not emit
1520 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1521 // Count == 0, then the array has zero elements in which case we do not emit
1523 int64_t LowerBound = SR.getLo();
1524 int64_t DefaultLowerBound = getDefaultLowerBound();
1525 int64_t Count = SR.getCount();
1527 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1528 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1530 if (Count != -1 && Count != 0)
1531 // FIXME: An unbounded array should reference the expression that defines
1533 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1535 Buffer.addChild(DW_Subrange);
1538 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1539 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1540 DICompositeType *CTy) {
1541 Buffer.setTag(dwarf::DW_TAG_array_type);
1542 if (CTy->isVector())
1543 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1545 // Emit the element type.
1546 addType(&Buffer, CTy->getTypeDerivedFrom());
1548 // Get an anonymous type for index type.
1549 // FIXME: This type should be passed down from the front end
1550 // as different languages may have different sizes for indexes.
1551 DIE *IdxTy = getIndexTyDie();
1553 // Construct an anonymous type for index type.
1554 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1555 addString(IdxTy, dwarf::DW_AT_name, "int");
1556 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1557 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1558 dwarf::DW_ATE_signed);
1560 setIndexTyDie(IdxTy);
1563 // Add subranges to array type.
1564 DIArray Elements = CTy->getTypeArray();
1565 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1566 DIDescriptor Element = Elements.getElement(i);
1567 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1568 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1572 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1573 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1574 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1575 StringRef Name = ETy.getName();
1576 addString(Enumerator, dwarf::DW_AT_name, Name);
1577 int64_t Value = ETy.getEnumValue();
1578 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1582 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1584 void CompileUnit::constructContainingTypeDIEs() {
1585 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1586 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1587 DIE *SPDie = CI->first;
1588 const MDNode *N = CI->second;
1590 DIE *NDie = getDIE(N);
1591 if (!NDie) continue;
1592 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1596 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1597 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1598 bool isScopeAbstract) {
1599 StringRef Name = DV->getName();
1601 // Translate tag to proper Dwarf tag.
1602 uint16_t Tag = DV->getTag();
1604 // Define variable debug information entry.
1605 DIE *VariableDie = new DIE(Tag);
1606 DbgVariable *AbsVar = DV->getAbstractVariable();
1607 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1609 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1610 dwarf::DW_FORM_ref4, AbsDIE);
1613 addString(VariableDie, dwarf::DW_AT_name, Name);
1614 addSourceLine(VariableDie, DV->getVariable());
1615 addType(VariableDie, DV->getType());
1618 if (DV->isArtificial())
1619 addFlag(VariableDie, dwarf::DW_AT_artificial);
1621 if (isScopeAbstract) {
1622 DV->setDIE(VariableDie);
1626 // Add variable address.
1628 unsigned Offset = DV->getDotDebugLocOffset();
1629 if (Offset != ~0U) {
1630 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1631 Asm->GetTempSymbol("debug_loc", Offset));
1632 DV->setDIE(VariableDie);
1636 // Check if variable is described by a DBG_VALUE instruction.
1637 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1638 assert(DVInsn->getNumOperands() == 3);
1639 if (DVInsn->getOperand(0).isReg()) {
1640 const MachineOperand RegOp = DVInsn->getOperand(0);
1641 // If the second operand is an immediate, this is an indirect value.
1642 if (DVInsn->getOperand(1).isImm()) {
1643 MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1644 addVariableAddress(*DV, VariableDie, Location);
1645 } else if (RegOp.getReg())
1646 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1647 } else if (DVInsn->getOperand(0).isImm())
1648 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1649 else if (DVInsn->getOperand(0).isFPImm())
1650 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1651 else if (DVInsn->getOperand(0).isCImm())
1652 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1653 DV->getType().isUnsignedDIType());
1655 DV->setDIE(VariableDie);
1658 // .. else use frame index.
1659 int FI = DV->getFrameIndex();
1661 unsigned FrameReg = 0;
1662 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1664 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1665 MachineLocation Location(FrameReg, Offset);
1666 addVariableAddress(*DV, VariableDie, Location);
1670 DV->setDIE(VariableDie);
1674 /// createMemberDIE - Create new member DIE.
1675 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1676 DIE *MemberDie = new DIE(DT.getTag());
1677 StringRef Name = DT.getName();
1679 addString(MemberDie, dwarf::DW_AT_name, Name);
1681 addType(MemberDie, DT.getTypeDerivedFrom());
1683 addSourceLine(MemberDie, DT);
1685 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1686 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1688 uint64_t Size = DT.getSizeInBits();
1689 uint64_t FieldSize = DT.getOriginalTypeSize();
1691 if (Size != FieldSize) {
1693 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1694 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1696 uint64_t Offset = DT.getOffsetInBits();
1697 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1698 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1699 uint64_t FieldOffset = (HiMark - FieldSize);
1700 Offset -= FieldOffset;
1702 // Maybe we need to work from the other end.
1703 if (Asm->getDataLayout().isLittleEndian())
1704 Offset = FieldSize - (Offset + Size);
1705 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1707 // Here WD_AT_data_member_location points to the anonymous
1708 // field that includes this bit field.
1709 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1712 // This is not a bitfield.
1713 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1715 if (DT.getTag() == dwarf::DW_TAG_inheritance
1716 && DT.isVirtual()) {
1718 // For C++, virtual base classes are not at fixed offset. Use following
1719 // expression to extract appropriate offset from vtable.
1720 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1722 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1723 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1724 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1725 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1726 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1727 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1728 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1729 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1731 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1734 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1736 if (DT.isProtected())
1737 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1738 dwarf::DW_ACCESS_protected);
1739 else if (DT.isPrivate())
1740 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1741 dwarf::DW_ACCESS_private);
1742 // Otherwise C++ member and base classes are considered public.
1744 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1745 dwarf::DW_ACCESS_public);
1747 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1748 dwarf::DW_VIRTUALITY_virtual);
1750 // Objective-C properties.
1751 if (MDNode *PNode = DT.getObjCProperty())
1752 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1753 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1756 if (DT.isArtificial())
1757 addFlag(MemberDie, dwarf::DW_AT_artificial);
1762 /// createStaticMemberDIE - Create new DIE for C++ static member.
1763 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1767 DIE *StaticMemberDIE = new DIE(DT.getTag());
1768 DIType Ty = DT.getTypeDerivedFrom();
1770 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1771 addType(StaticMemberDIE, Ty);
1772 addSourceLine(StaticMemberDIE, DT);
1773 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1774 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1776 // FIXME: We could omit private if the parent is a class_type, and
1777 // public if the parent is something else.
1778 if (DT.isProtected())
1779 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1780 dwarf::DW_ACCESS_protected);
1781 else if (DT.isPrivate())
1782 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1783 dwarf::DW_ACCESS_private);
1785 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1786 dwarf::DW_ACCESS_public);
1788 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1789 addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1790 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1791 addConstantFPValue(StaticMemberDIE, CFP);
1793 insertDIE(DT, StaticMemberDIE);
1794 return StaticMemberDIE;