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->useDarwinGDBCompat())
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);
186 /// addLabelAddress - Add a dwarf label attribute data and value using
187 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
189 void CompileUnit::addLabelAddress(DIE *Die, uint16_t Attribute,
191 if (!DD->useSplitDwarf()) {
193 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
194 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
196 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
197 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
200 unsigned idx = DU->getAddrPoolIndex(Label);
201 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
202 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
206 /// addOpAddress - Add a dwarf op address data and value using the
207 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
209 void CompileUnit::addOpAddress(DIE *Die, const MCSymbol *Sym) {
210 if (!DD->useSplitDwarf()) {
211 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
212 addLabel(Die, 0, dwarf::DW_FORM_udata, Sym);
214 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
215 addUInt(Die, 0, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
219 /// addDelta - Add a label delta attribute data and value.
221 void CompileUnit::addDelta(DIE *Die, uint16_t Attribute, uint16_t Form,
222 const MCSymbol *Hi, const MCSymbol *Lo) {
223 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
224 Die->addValue(Attribute, Form, Value);
227 /// addDIEEntry - Add a DIE attribute data and value.
229 void CompileUnit::addDIEEntry(DIE *Die, uint16_t Attribute, uint16_t Form,
231 Die->addValue(Attribute, Form, createDIEEntry(Entry));
234 /// addBlock - Add block data.
236 void CompileUnit::addBlock(DIE *Die, uint16_t Attribute, uint16_t Form,
238 Block->ComputeSize(Asm);
239 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
240 Die->addValue(Attribute, Block->BestForm(), Block);
243 /// addSourceLine - Add location information to specified debug information
245 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
250 unsigned Line = V.getLineNumber();
253 unsigned FileID = DD->getOrCreateSourceID(V.getContext().getFilename(),
254 V.getContext().getDirectory(),
256 assert(FileID && "Invalid file id");
257 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
258 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
261 /// addSourceLine - Add location information to specified debug information
263 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
264 // Verify global variable.
265 if (!G.isGlobalVariable())
268 unsigned Line = G.getLineNumber();
271 unsigned FileID = DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(),
273 assert(FileID && "Invalid file id");
274 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
275 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
278 /// addSourceLine - Add location information to specified debug information
280 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
281 // Verify subprogram.
282 if (!SP.isSubprogram())
285 // If the line number is 0, don't add it.
286 unsigned Line = SP.getLineNumber();
290 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(),
291 SP.getDirectory(), getUniqueID());
292 assert(FileID && "Invalid file id");
293 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
294 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
297 /// addSourceLine - Add location information to specified debug information
299 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
304 unsigned Line = Ty.getLineNumber();
307 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(),
308 Ty.getDirectory(), getUniqueID());
309 assert(FileID && "Invalid file id");
310 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
311 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
314 /// addSourceLine - Add location information to specified debug information
316 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
318 if (!Ty.isObjCProperty())
321 unsigned Line = Ty.getLineNumber();
324 DIFile File = Ty.getFile();
325 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
326 File.getDirectory(), getUniqueID());
327 assert(FileID && "Invalid file id");
328 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
329 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
332 /// addSourceLine - Add location information to specified debug information
334 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
339 unsigned Line = NS.getLineNumber();
342 StringRef FN = NS.getFilename();
344 unsigned FileID = DD->getOrCreateSourceID(FN, NS.getDirectory(),
346 assert(FileID && "Invalid file id");
347 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
348 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
351 /// addVariableAddress - Add DW_AT_location attribute for a
352 /// DbgVariable based on provided MachineLocation.
353 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
354 MachineLocation Location) {
355 if (DV.variableHasComplexAddress())
356 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
357 else if (DV.isBlockByrefVariable())
358 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
360 addAddress(Die, dwarf::DW_AT_location, Location,
361 DV.getVariable().isIndirect());
364 /// addRegisterOp - Add register operand.
365 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
366 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
367 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
369 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
371 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
372 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
376 /// addRegisterOffset - Add register offset.
377 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
379 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
380 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
381 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
382 if (Reg == TRI->getFrameRegister(*Asm->MF))
383 // If variable offset is based in frame register then use fbreg.
384 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
386 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
388 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
389 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
391 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
394 /// addAddress - Add an address attribute to a die based on the location
396 void CompileUnit::addAddress(DIE *Die, uint16_t Attribute,
397 const MachineLocation &Location, bool Indirect) {
398 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
400 if (Location.isReg() && !Indirect)
401 addRegisterOp(Block, Location.getReg());
403 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
404 if (Indirect && !Location.isReg()) {
405 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
409 // Now attach the location information to the DIE.
410 addBlock(Die, Attribute, 0, Block);
413 /// addComplexAddress - Start with the address based on the location provided,
414 /// and generate the DWARF information necessary to find the actual variable
415 /// given the extra address information encoded in the DIVariable, starting from
416 /// the starting location. Add the DWARF information to the die.
418 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
420 const MachineLocation &Location) {
421 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
422 unsigned N = DV.getNumAddrElements();
424 if (Location.isReg()) {
425 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
426 // If first address element is OpPlus then emit
427 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
428 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
431 addRegisterOp(Block, Location.getReg());
434 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
437 uint64_t Element = DV.getAddrElement(i);
438 if (Element == DIBuilder::OpPlus) {
439 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
440 addUInt(Block, 0, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
441 } else if (Element == DIBuilder::OpDeref) {
442 if (!Location.isReg())
443 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
444 } else llvm_unreachable("unknown DIBuilder Opcode");
447 // Now attach the location information to the DIE.
448 addBlock(Die, Attribute, 0, Block);
451 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
452 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
453 gives the variable VarName either the struct, or a pointer to the struct, as
454 its type. This is necessary for various behind-the-scenes things the
455 compiler needs to do with by-reference variables in Blocks.
457 However, as far as the original *programmer* is concerned, the variable
458 should still have type 'SomeType', as originally declared.
460 The function getBlockByrefType dives into the __Block_byref_x_VarName
461 struct to find the original type of the variable, which is then assigned to
462 the variable's Debug Information Entry as its real type. So far, so good.
463 However now the debugger will expect the variable VarName to have the type
464 SomeType. So we need the location attribute for the variable to be an
465 expression that explains to the debugger how to navigate through the
466 pointers and struct to find the actual variable of type SomeType.
468 The following function does just that. We start by getting
469 the "normal" location for the variable. This will be the location
470 of either the struct __Block_byref_x_VarName or the pointer to the
471 struct __Block_byref_x_VarName.
473 The struct will look something like:
475 struct __Block_byref_x_VarName {
477 struct __Block_byref_x_VarName *forwarding;
478 ... <various other fields>
480 ... <maybe more fields>
483 If we are given the struct directly (as our starting point) we
484 need to tell the debugger to:
486 1). Add the offset of the forwarding field.
488 2). Follow that pointer to get the real __Block_byref_x_VarName
489 struct to use (the real one may have been copied onto the heap).
491 3). Add the offset for the field VarName, to find the actual variable.
493 If we started with a pointer to the struct, then we need to
494 dereference that pointer first, before the other steps.
495 Translating this into DWARF ops, we will need to append the following
496 to the current location description for the variable:
498 DW_OP_deref -- optional, if we start with a pointer
499 DW_OP_plus_uconst <forward_fld_offset>
501 DW_OP_plus_uconst <varName_fld_offset>
503 That is what this function does. */
505 /// addBlockByrefAddress - Start with the address based on the location
506 /// provided, and generate the DWARF information necessary to find the
507 /// actual Block variable (navigating the Block struct) based on the
508 /// starting location. Add the DWARF information to the die. For
509 /// more information, read large comment just above here.
511 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
513 const MachineLocation &Location) {
514 DIType Ty = DV.getType();
516 uint16_t Tag = Ty.getTag();
517 bool isPointer = false;
519 StringRef varName = DV.getName();
521 if (Tag == dwarf::DW_TAG_pointer_type) {
522 DIDerivedType DTy = DIDerivedType(Ty);
523 TmpTy = DTy.getTypeDerivedFrom();
527 DICompositeType blockStruct = DICompositeType(TmpTy);
529 // Find the __forwarding field and the variable field in the __Block_byref
531 DIArray Fields = blockStruct.getTypeArray();
532 DIDescriptor varField = DIDescriptor();
533 DIDescriptor forwardingField = DIDescriptor();
535 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
536 DIDescriptor Element = Fields.getElement(i);
537 DIDerivedType DT = DIDerivedType(Element);
538 StringRef fieldName = DT.getName();
539 if (fieldName == "__forwarding")
540 forwardingField = Element;
541 else if (fieldName == varName)
545 // Get the offsets for the forwarding field and the variable field.
546 unsigned forwardingFieldOffset =
547 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
548 unsigned varFieldOffset =
549 DIDerivedType(varField).getOffsetInBits() >> 3;
551 // Decode the original location, and use that as the start of the byref
552 // variable's location.
553 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
555 if (Location.isReg())
556 addRegisterOp(Block, Location.getReg());
558 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
560 // If we started with a pointer to the __Block_byref... struct, then
561 // the first thing we need to do is dereference the pointer (DW_OP_deref).
563 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
565 // Next add the offset for the '__forwarding' field:
566 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
567 // adding the offset if it's 0.
568 if (forwardingFieldOffset > 0) {
569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
570 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
573 // Now dereference the __forwarding field to get to the real __Block_byref
574 // struct: DW_OP_deref.
575 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
577 // Now that we've got the real __Block_byref... struct, add the offset
578 // for the variable's field to get to the location of the actual variable:
579 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
580 if (varFieldOffset > 0) {
581 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
582 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
585 // Now attach the location information to the DIE.
586 addBlock(Die, Attribute, 0, Block);
589 /// isTypeSigned - Return true if the type is signed.
590 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
591 if (Ty.isDerivedType())
592 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
593 if (Ty.isBasicType())
594 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
595 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
596 *SizeInBits = Ty.getSizeInBits();
602 /// addConstantValue - Add constant value entry in variable DIE.
603 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
605 // FIXME: This is a bit conservative/simple - it emits negative values at
606 // their maximum bit width which is a bit unfortunate (& doesn't prefer
607 // udata/sdata over dataN as suggested by the DWARF spec)
608 assert(MO.isImm() && "Invalid machine operand!");
609 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
611 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
612 uint16_t Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
613 switch (SizeInBits) {
614 case 8: Form = dwarf::DW_FORM_data1; break;
615 case 16: Form = dwarf::DW_FORM_data2; break;
616 case 32: Form = dwarf::DW_FORM_data4; break;
617 case 64: Form = dwarf::DW_FORM_data8; break;
620 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
621 : addUInt(Block, 0, Form, MO.getImm());
623 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
626 /// addConstantFPValue - Add constant value entry in variable DIE.
627 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
628 assert (MO.isFPImm() && "Invalid machine operand!");
629 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
630 APFloat FPImm = MO.getFPImm()->getValueAPF();
632 // Get the raw data form of the floating point.
633 const APInt FltVal = FPImm.bitcastToAPInt();
634 const char *FltPtr = (const char*)FltVal.getRawData();
636 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
637 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
638 int Incr = (LittleEndian ? 1 : -1);
639 int Start = (LittleEndian ? 0 : NumBytes - 1);
640 int Stop = (LittleEndian ? NumBytes : -1);
642 // Output the constant to DWARF one byte at a time.
643 for (; Start != Stop; Start += Incr)
644 addUInt(Block, 0, dwarf::DW_FORM_data1,
645 (unsigned char)0xFF & FltPtr[Start]);
647 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
650 /// addConstantFPValue - Add constant value entry in variable DIE.
651 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
652 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), false);
655 /// addConstantValue - Add constant value entry in variable DIE.
656 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
658 addConstantValue(Die, CI->getValue(), Unsigned);
661 // addConstantValue - Add constant value entry in variable DIE.
662 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
663 unsigned CIBitWidth = Val.getBitWidth();
664 if (CIBitWidth <= 64) {
666 switch (CIBitWidth) {
667 case 8: form = dwarf::DW_FORM_data1; break;
668 case 16: form = dwarf::DW_FORM_data2; break;
669 case 32: form = dwarf::DW_FORM_data4; break;
670 case 64: form = dwarf::DW_FORM_data8; break;
672 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
675 addUInt(Die, dwarf::DW_AT_const_value, form, Val.getZExtValue());
677 addSInt(Die, dwarf::DW_AT_const_value, form, Val.getSExtValue());
681 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
683 // Get the raw data form of the large APInt.
684 const uint64_t *Ptr64 = Val.getRawData();
686 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
687 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
689 // Output the constant to DWARF one byte at a time.
690 for (int i = 0; i < NumBytes; i++) {
693 c = Ptr64[i / 8] >> (8 * (i & 7));
695 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
696 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
699 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
702 /// addTemplateParams - Add template parameters into buffer.
703 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
704 // Add template parameters.
705 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
706 DIDescriptor Element = TParams.getElement(i);
707 if (Element.isTemplateTypeParameter())
708 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
709 DITemplateTypeParameter(Element)));
710 else if (Element.isTemplateValueParameter())
711 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
712 DITemplateValueParameter(Element)));
716 /// getOrCreateContextDIE - Get context owner's DIE.
717 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) {
718 if (Context.isType())
719 return getOrCreateTypeDIE(DIType(Context));
720 else if (Context.isNameSpace())
721 return getOrCreateNameSpace(DINameSpace(Context));
722 else if (Context.isSubprogram())
723 return getOrCreateSubprogramDIE(DISubprogram(Context));
725 return getDIE(Context);
728 /// addToContextOwner - Add Die into the list of its context owner's children.
729 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
730 if (DIE *ContextDIE = getOrCreateContextDIE(Context))
731 ContextDIE->addChild(Die);
736 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
738 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
742 DIE *TyDIE = getDIE(Ty);
747 TyDIE = new DIE(dwarf::DW_TAG_base_type);
748 insertDIE(Ty, TyDIE);
749 if (Ty.isBasicType())
750 constructTypeDIE(*TyDIE, DIBasicType(Ty));
751 else if (Ty.isCompositeType())
752 constructTypeDIE(*TyDIE, DICompositeType(Ty));
754 assert(Ty.isDerivedType() && "Unknown kind of DIType");
755 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
757 // If this is a named finished type then include it in the list of types
758 // for the accelerator tables.
759 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
760 bool IsImplementation = 0;
761 if (Ty.isCompositeType()) {
762 DICompositeType CT(Ty);
763 // A runtime language of 0 actually means C/C++ and that any
764 // non-negative value is some version of Objective-C/C++.
765 IsImplementation = (CT.getRunTimeLang() == 0) ||
766 CT.isObjcClassComplete();
768 unsigned Flags = IsImplementation ?
769 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
770 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
773 addToContextOwner(TyDIE, Ty.getContext());
777 /// addType - Add a new type attribute to the specified entity.
778 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
779 assert(Ty && "Trying to add a type that doesn't exist?");
781 // Check for pre-existence.
782 DIEEntry *Entry = getDIEEntry(Ty);
783 // If it exists then use the existing value.
785 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
790 DIE *Buffer = getOrCreateTypeDIE(Ty);
793 Entry = createDIEEntry(Buffer);
794 insertDIEEntry(Ty, Entry);
795 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
797 // If this is a complete composite type then include it in the
798 // list of global types.
802 /// addGlobalType - Add a new global type to the compile unit.
804 void CompileUnit::addGlobalType(DIType Ty) {
805 DIDescriptor Context = Ty.getContext();
806 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
807 && (!Context || Context.isCompileUnit() || Context.isFile()
808 || Context.isNameSpace()))
809 if (DIEEntry *Entry = getDIEEntry(Ty))
810 GlobalTypes[Ty.getName()] = Entry->getEntry();
813 /// addPubTypes - Add type for pubtypes section.
814 void CompileUnit::addPubTypes(DISubprogram SP) {
815 DICompositeType SPTy = SP.getType();
816 uint16_t SPTag = SPTy.getTag();
817 if (SPTag != dwarf::DW_TAG_subroutine_type)
820 DIArray Args = SPTy.getTypeArray();
821 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
822 DIType ATy(Args.getElement(i));
829 /// constructTypeDIE - Construct basic type die from DIBasicType.
830 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
831 // Get core information.
832 StringRef Name = BTy.getName();
833 // Add name if not anonymous or intermediate type.
835 addString(&Buffer, dwarf::DW_AT_name, Name);
837 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
838 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
839 // An unspecified type only has a name attribute.
843 Buffer.setTag(dwarf::DW_TAG_base_type);
844 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
847 uint64_t Size = BTy.getSizeInBits() >> 3;
848 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
851 /// constructTypeDIE - Construct derived type die from DIDerivedType.
852 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
853 // Get core information.
854 StringRef Name = DTy.getName();
855 uint64_t Size = DTy.getSizeInBits() >> 3;
856 uint16_t Tag = DTy.getTag();
858 // FIXME - Workaround for templates.
859 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
863 // Map to main type, void will not have a type.
864 DIType FromTy = DTy.getTypeDerivedFrom();
866 addType(&Buffer, FromTy);
868 // Add name if not anonymous or intermediate type.
870 addString(&Buffer, dwarf::DW_AT_name, Name);
872 // Add size if non-zero (derived types might be zero-sized.)
873 if (Size && Tag != dwarf::DW_TAG_pointer_type)
874 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
876 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
877 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
878 getOrCreateTypeDIE(DTy.getClassType()));
879 // Add source line info if available and TyDesc is not a forward declaration.
880 if (!DTy.isForwardDecl())
881 addSourceLine(&Buffer, DTy);
884 /// Return true if the type is appropriately scoped to be contained inside
885 /// its own type unit.
886 static bool isTypeUnitScoped(DIType Ty) {
887 DIScope Parent = Ty.getContext();
889 // Don't generate a hash for anything scoped inside a function.
890 if (Parent.isSubprogram())
892 Parent = Parent.getContext();
897 /// Return true if the type should be split out into a type unit.
898 static bool shouldCreateTypeUnit(DICompositeType CTy) {
899 uint16_t Tag = CTy.getTag();
902 case dwarf::DW_TAG_structure_type:
903 case dwarf::DW_TAG_union_type:
904 case dwarf::DW_TAG_enumeration_type:
905 case dwarf::DW_TAG_class_type:
906 // If this is a class, structure, union, or enumeration type
907 // that is not a declaration, is a type definition, and not scoped
908 // inside a function then separate this out as a type unit.
909 if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy))
917 /// constructTypeDIE - Construct type DIE from DICompositeType.
918 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
919 // Get core information.
920 StringRef Name = CTy.getName();
922 uint64_t Size = CTy.getSizeInBits() >> 3;
923 uint16_t Tag = CTy.getTag();
927 case dwarf::DW_TAG_array_type:
928 constructArrayTypeDIE(Buffer, &CTy);
930 case dwarf::DW_TAG_enumeration_type: {
931 DIArray Elements = CTy.getTypeArray();
933 // Add enumerators to enumeration type.
934 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
936 DIDescriptor Enum(Elements.getElement(i));
937 if (Enum.isEnumerator()) {
938 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
939 Buffer.addChild(ElemDie);
942 DIType DTy = CTy.getTypeDerivedFrom();
944 addType(&Buffer, DTy);
945 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
949 case dwarf::DW_TAG_subroutine_type: {
950 // Add return type. A void return won't have a type.
951 DIArray Elements = CTy.getTypeArray();
952 DIDescriptor RTy = Elements.getElement(0);
954 addType(&Buffer, DIType(RTy));
956 bool isPrototyped = true;
958 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
959 DIDescriptor Ty = Elements.getElement(i);
960 if (Ty.isUnspecifiedParameter()) {
961 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
962 Buffer.addChild(Arg);
963 isPrototyped = false;
965 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
966 addType(Arg, DIType(Ty));
967 if (DIType(Ty).isArtificial())
968 addFlag(Arg, dwarf::DW_AT_artificial);
969 Buffer.addChild(Arg);
972 // Add prototype flag if we're dealing with a C language and the
973 // function has been prototyped.
974 uint16_t Language = DICompileUnit(Node).getLanguage();
976 (Language == dwarf::DW_LANG_C89 ||
977 Language == dwarf::DW_LANG_C99 ||
978 Language == dwarf::DW_LANG_ObjC))
979 addFlag(&Buffer, dwarf::DW_AT_prototyped);
982 case dwarf::DW_TAG_structure_type:
983 case dwarf::DW_TAG_union_type:
984 case dwarf::DW_TAG_class_type: {
985 // Add elements to structure type.
986 DIArray Elements = CTy.getTypeArray();
987 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
988 DIDescriptor Element = Elements.getElement(i);
990 if (Element.isSubprogram()) {
991 DISubprogram SP(Element);
992 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
993 if (SP.isProtected())
994 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
995 dwarf::DW_ACCESS_protected);
996 else if (SP.isPrivate())
997 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
998 dwarf::DW_ACCESS_private);
1000 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1001 dwarf::DW_ACCESS_public);
1002 if (SP.isExplicit())
1003 addFlag(ElemDie, dwarf::DW_AT_explicit);
1004 } else if (Element.isDerivedType()) {
1005 DIDerivedType DDTy(Element);
1006 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1007 ElemDie = new DIE(dwarf::DW_TAG_friend);
1008 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1009 } else if (DDTy.isStaticMember())
1010 ElemDie = createStaticMemberDIE(DDTy);
1012 ElemDie = createMemberDIE(DDTy);
1013 } else if (Element.isObjCProperty()) {
1014 DIObjCProperty Property(Element);
1015 ElemDie = new DIE(Property.getTag());
1016 StringRef PropertyName = Property.getObjCPropertyName();
1017 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1018 addType(ElemDie, Property.getType());
1019 addSourceLine(ElemDie, Property);
1020 StringRef GetterName = Property.getObjCPropertyGetterName();
1021 if (!GetterName.empty())
1022 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1023 StringRef SetterName = Property.getObjCPropertySetterName();
1024 if (!SetterName.empty())
1025 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1026 unsigned PropertyAttributes = 0;
1027 if (Property.isReadOnlyObjCProperty())
1028 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1029 if (Property.isReadWriteObjCProperty())
1030 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1031 if (Property.isAssignObjCProperty())
1032 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1033 if (Property.isRetainObjCProperty())
1034 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1035 if (Property.isCopyObjCProperty())
1036 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1037 if (Property.isNonAtomicObjCProperty())
1038 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1039 if (PropertyAttributes)
1040 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1041 PropertyAttributes);
1043 DIEEntry *Entry = getDIEEntry(Element);
1045 Entry = createDIEEntry(ElemDie);
1046 insertDIEEntry(Element, Entry);
1050 Buffer.addChild(ElemDie);
1053 if (CTy.isAppleBlockExtension())
1054 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1056 DICompositeType ContainingType = CTy.getContainingType();
1057 if (DIDescriptor(ContainingType).isCompositeType())
1058 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1059 getOrCreateTypeDIE(DIType(ContainingType)));
1061 addToContextOwner(&Buffer, CTy.getContext());
1063 if (CTy.isObjcClassComplete())
1064 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1066 // Add template parameters to a class, structure or union types.
1067 // FIXME: The support isn't in the metadata for this yet.
1068 if (Tag == dwarf::DW_TAG_class_type ||
1069 Tag == dwarf::DW_TAG_structure_type ||
1070 Tag == dwarf::DW_TAG_union_type)
1071 addTemplateParams(Buffer, CTy.getTemplateParams());
1079 // Add name if not anonymous or intermediate type.
1081 addString(&Buffer, dwarf::DW_AT_name, Name);
1083 if (Tag == dwarf::DW_TAG_enumeration_type ||
1084 Tag == dwarf::DW_TAG_class_type ||
1085 Tag == dwarf::DW_TAG_structure_type ||
1086 Tag == dwarf::DW_TAG_union_type) {
1087 // Add size if non-zero (derived types might be zero-sized.)
1088 // TODO: Do we care about size for enum forward declarations?
1090 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1091 else if (!CTy.isForwardDecl())
1092 // Add zero size if it is not a forward declaration.
1093 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1095 // If we're a forward decl, say so.
1096 if (CTy.isForwardDecl())
1097 addFlag(&Buffer, dwarf::DW_AT_declaration);
1099 // Add source line info if available.
1100 if (!CTy.isForwardDecl())
1101 addSourceLine(&Buffer, CTy);
1103 // No harm in adding the runtime language to the declaration.
1104 unsigned RLang = CTy.getRunTimeLang();
1106 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1107 dwarf::DW_FORM_data1, RLang);
1109 // If this is a type applicable to a type unit it then add it to the
1110 // list of types we'll compute a hash for later.
1111 if (shouldCreateTypeUnit(CTy))
1112 DD->addTypeUnitType(&Buffer);
1115 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1116 /// for the given DITemplateTypeParameter.
1118 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1119 DIE *ParamDIE = getDIE(TP);
1123 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1124 // Add the type if it exists, it could be void and therefore no type.
1126 addType(ParamDIE, TP.getType());
1127 if (!TP.getName().empty())
1128 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1132 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1133 /// for the given DITemplateValueParameter.
1135 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1136 DIE *ParamDIE = getDIE(VP);
1140 ParamDIE = new DIE(VP.getTag());
1142 // Add the type if there is one, template template and template parameter
1143 // packs will not have a type.
1145 addType(ParamDIE, VP.getType());
1146 if (!VP.getName().empty())
1147 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1148 if (Value *Val = VP.getValue()) {
1149 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1150 addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1151 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1152 // For declaration non-type template parameters (such as global values and
1154 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1155 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1156 // Emit DW_OP_stack_value to use the address as the immediate value of the
1157 // parameter, rather than a pointer to it.
1158 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1159 addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1160 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1161 assert(isa<MDString>(Val));
1162 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1163 cast<MDString>(Val)->getString());
1164 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1165 assert(isa<MDNode>(Val));
1166 DIArray A(cast<MDNode>(Val));
1167 addTemplateParams(*ParamDIE, A);
1174 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1175 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1176 DIE *NDie = getDIE(NS);
1179 NDie = new DIE(dwarf::DW_TAG_namespace);
1180 insertDIE(NS, NDie);
1181 if (!NS.getName().empty()) {
1182 addString(NDie, dwarf::DW_AT_name, NS.getName());
1183 addAccelNamespace(NS.getName(), NDie);
1185 addAccelNamespace("(anonymous namespace)", NDie);
1186 addSourceLine(NDie, NS);
1187 addToContextOwner(NDie, NS.getContext());
1191 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1192 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1193 DIE *SPDie = getDIE(SP);
1197 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1199 // DW_TAG_inlined_subroutine may refer to this DIE.
1200 insertDIE(SP, SPDie);
1202 DISubprogram SPDecl = SP.getFunctionDeclaration();
1203 DIE *DeclDie = NULL;
1204 if (SPDecl.isSubprogram()) {
1205 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1208 // Add to context owner.
1209 addToContextOwner(SPDie, SP.getContext());
1211 // Add function template parameters.
1212 addTemplateParams(*SPDie, SP.getTemplateParams());
1214 // Unfortunately this code needs to stay here instead of below the
1215 // AT_specification code in order to work around a bug in older
1216 // gdbs that requires the linkage name to resolve multiple template
1218 // TODO: Remove this set of code when we get rid of the old gdb
1220 StringRef LinkageName = SP.getLinkageName();
1221 if (!LinkageName.empty() && DD->useDarwinGDBCompat())
1222 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1223 GlobalValue::getRealLinkageName(LinkageName));
1225 // If this DIE is going to refer declaration info using AT_specification
1226 // then there is no need to add other attributes.
1228 // Refer function declaration directly.
1229 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1235 // Add the linkage name if we have one.
1236 if (!LinkageName.empty() && !DD->useDarwinGDBCompat())
1237 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1238 GlobalValue::getRealLinkageName(LinkageName));
1240 // Constructors and operators for anonymous aggregates do not have names.
1241 if (!SP.getName().empty())
1242 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1244 addSourceLine(SPDie, SP);
1246 // Add the prototype if we have a prototype and we have a C like
1248 uint16_t Language = DICompileUnit(Node).getLanguage();
1249 if (SP.isPrototyped() &&
1250 (Language == dwarf::DW_LANG_C89 ||
1251 Language == dwarf::DW_LANG_C99 ||
1252 Language == dwarf::DW_LANG_ObjC))
1253 addFlag(SPDie, dwarf::DW_AT_prototyped);
1255 // Add Return Type. A void return type will not have a type.
1256 DICompositeType SPTy = SP.getType();
1257 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1258 "the type of a subprogram should be a subroutine");
1260 DIArray Args = SPTy.getTypeArray();
1261 if (Args.getElement(0))
1262 addType(SPDie, DIType(Args.getElement(0)));
1264 unsigned VK = SP.getVirtuality();
1266 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1267 DIEBlock *Block = getDIEBlock();
1268 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1269 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1270 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1271 ContainingTypeMap.insert(std::make_pair(SPDie,
1272 SP.getContainingType()));
1275 if (!SP.isDefinition()) {
1276 addFlag(SPDie, dwarf::DW_AT_declaration);
1278 // Add arguments. Do not add arguments for subprogram definition. They will
1279 // be handled while processing variables.
1280 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1281 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1282 DIType ATy = DIType(Args.getElement(i));
1284 if (ATy.isArtificial())
1285 addFlag(Arg, dwarf::DW_AT_artificial);
1286 SPDie->addChild(Arg);
1290 if (SP.isArtificial())
1291 addFlag(SPDie, dwarf::DW_AT_artificial);
1293 if (!SP.isLocalToUnit())
1294 addFlag(SPDie, dwarf::DW_AT_external);
1296 if (SP.isOptimized())
1297 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1299 if (unsigned isa = Asm->getISAEncoding()) {
1300 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1306 // Return const expression if value is a GEP to access merged global
1308 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1309 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1310 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1311 if (!CE || CE->getNumOperands() != 3 ||
1312 CE->getOpcode() != Instruction::GetElementPtr)
1315 // First operand points to a global struct.
1316 Value *Ptr = CE->getOperand(0);
1317 if (!isa<GlobalValue>(Ptr) ||
1318 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1321 // Second operand is zero.
1322 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1323 if (!CI || !CI->isZero())
1326 // Third operand is offset.
1327 if (!isa<ConstantInt>(CE->getOperand(2)))
1333 /// createGlobalVariableDIE - create global variable DIE.
1334 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1335 // Check for pre-existence.
1339 DIGlobalVariable GV(N);
1340 if (!GV.isGlobalVariable())
1343 DIDescriptor GVContext = GV.getContext();
1344 DIType GTy = GV.getType();
1346 // If this is a static data member definition, some attributes belong
1347 // to the declaration DIE.
1348 DIE *VariableDIE = NULL;
1349 bool IsStaticMember = false;
1350 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1351 if (SDMDecl.Verify()) {
1352 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1353 // We need the declaration DIE that is in the static member's class.
1354 // But that class might not exist in the DWARF yet.
1355 // Creating the class will create the static member decl DIE.
1356 getOrCreateContextDIE(SDMDecl.getContext());
1357 VariableDIE = getDIE(SDMDecl);
1358 assert(VariableDIE && "Static member decl has no context?");
1359 IsStaticMember = true;
1362 // If this is not a static data member definition, create the variable
1363 // DIE and add the initial set of attributes to it.
1365 VariableDIE = new DIE(GV.getTag());
1367 insertDIE(N, VariableDIE);
1369 // Add name and type.
1370 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1371 addType(VariableDIE, GTy);
1373 // Add scoping info.
1374 if (!GV.isLocalToUnit()) {
1375 addFlag(VariableDIE, dwarf::DW_AT_external);
1376 addGlobalName(GV.getName(), VariableDIE);
1379 // Add line number info.
1380 addSourceLine(VariableDIE, GV);
1381 // Add to context owner.
1382 addToContextOwner(VariableDIE, GVContext);
1386 bool addToAccelTable = false;
1387 DIE *VariableSpecDIE = NULL;
1388 bool isGlobalVariable = GV.getGlobal() != NULL;
1389 if (isGlobalVariable) {
1390 addToAccelTable = true;
1391 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1392 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1393 if (GV.getGlobal()->isThreadLocal()) {
1394 // FIXME: Make this work with -gsplit-dwarf.
1395 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1396 assert((PointerSize == 4 || PointerSize == 8) &&
1397 "Add support for other sizes if necessary");
1398 const MCExpr *Expr =
1399 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1400 // Based on GCC's support for TLS:
1401 if (!DD->useSplitDwarf()) {
1402 // 1) Start with a constNu of the appropriate pointer size
1403 addUInt(Block, 0, dwarf::DW_FORM_data1,
1404 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1405 // 2) containing the (relocated) address of the TLS variable
1406 addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1408 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1409 addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1411 // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1412 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1414 addOpAddress(Block, Sym);
1415 // Do not create specification DIE if context is either compile unit
1417 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1418 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1419 // Create specification DIE.
1420 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1421 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1422 dwarf::DW_FORM_ref4, VariableDIE);
1423 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1424 // A static member's declaration is already flagged as such.
1425 if (!SDMDecl.Verify())
1426 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1427 addDie(VariableSpecDIE);
1429 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1431 // Add linkage name.
1432 StringRef LinkageName = GV.getLinkageName();
1433 if (!LinkageName.empty()) {
1434 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1435 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1437 addString(IsStaticMember && VariableSpecDIE ?
1438 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1439 GlobalValue::getRealLinkageName(LinkageName));
1440 // In compatibility mode with older gdbs we put the linkage name on both
1441 // the TAG_variable DIE and on the TAG_member DIE.
1442 if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat())
1443 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1444 GlobalValue::getRealLinkageName(LinkageName));
1446 } else if (const ConstantInt *CI =
1447 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1448 // AT_const_value was added when the static member was created. To avoid
1449 // emitting AT_const_value multiple times, we only add AT_const_value when
1450 // it is not a static member.
1451 if (!IsStaticMember)
1452 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1453 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1454 addToAccelTable = true;
1455 // GV is a merged global.
1456 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1457 Value *Ptr = CE->getOperand(0);
1458 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1459 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1460 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1461 addUInt(Block, 0, dwarf::DW_FORM_udata,
1462 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1463 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1464 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1467 if (addToAccelTable) {
1468 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1469 addAccelName(GV.getName(), AddrDIE);
1471 // If the linkage name is different than the name, go ahead and output
1472 // that as well into the name table.
1473 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1474 addAccelName(GV.getLinkageName(), AddrDIE);
1478 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1479 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1481 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1482 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1484 // The LowerBound value defines the lower bounds which is typically zero for
1485 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1486 // Count == -1 then the array is unbounded and we do not emit
1487 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1488 // Count == 0, then the array has zero elements in which case we do not emit
1490 int64_t LowerBound = SR.getLo();
1491 int64_t DefaultLowerBound = getDefaultLowerBound();
1492 int64_t Count = SR.getCount();
1494 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1495 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1497 if (Count != -1 && Count != 0)
1498 // FIXME: An unbounded array should reference the expression that defines
1500 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1502 Buffer.addChild(DW_Subrange);
1505 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1506 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1507 DICompositeType *CTy) {
1508 Buffer.setTag(dwarf::DW_TAG_array_type);
1509 if (CTy->isVector())
1510 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1512 // Emit the element type.
1513 addType(&Buffer, CTy->getTypeDerivedFrom());
1515 // Get an anonymous type for index type.
1516 // FIXME: This type should be passed down from the front end
1517 // as different languages may have different sizes for indexes.
1518 DIE *IdxTy = getIndexTyDie();
1520 // Construct an anonymous type for index type.
1521 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1522 addString(IdxTy, dwarf::DW_AT_name, "int");
1523 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1524 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1525 dwarf::DW_ATE_signed);
1527 setIndexTyDie(IdxTy);
1530 // Add subranges to array type.
1531 DIArray Elements = CTy->getTypeArray();
1532 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1533 DIDescriptor Element = Elements.getElement(i);
1534 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1535 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1539 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1540 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1541 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1542 StringRef Name = ETy.getName();
1543 addString(Enumerator, dwarf::DW_AT_name, Name);
1544 int64_t Value = ETy.getEnumValue();
1545 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1549 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1551 void CompileUnit::constructContainingTypeDIEs() {
1552 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1553 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1554 DIE *SPDie = CI->first;
1555 const MDNode *N = CI->second;
1557 DIE *NDie = getDIE(N);
1558 if (!NDie) continue;
1559 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1563 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1564 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1565 bool isScopeAbstract) {
1566 StringRef Name = DV->getName();
1568 // Translate tag to proper Dwarf tag.
1569 uint16_t Tag = DV->getTag();
1571 // Define variable debug information entry.
1572 DIE *VariableDie = new DIE(Tag);
1573 DbgVariable *AbsVar = DV->getAbstractVariable();
1574 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1576 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1577 dwarf::DW_FORM_ref4, AbsDIE);
1580 addString(VariableDie, dwarf::DW_AT_name, Name);
1581 addSourceLine(VariableDie, DV->getVariable());
1582 addType(VariableDie, DV->getType());
1585 if (DV->isArtificial())
1586 addFlag(VariableDie, dwarf::DW_AT_artificial);
1588 if (isScopeAbstract) {
1589 DV->setDIE(VariableDie);
1593 // Add variable address.
1595 unsigned Offset = DV->getDotDebugLocOffset();
1596 if (Offset != ~0U) {
1597 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1598 Asm->GetTempSymbol("debug_loc", Offset));
1599 DV->setDIE(VariableDie);
1603 // Check if variable is described by a DBG_VALUE instruction.
1604 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1605 assert(DVInsn->getNumOperands() == 3);
1606 if (DVInsn->getOperand(0).isReg()) {
1607 const MachineOperand RegOp = DVInsn->getOperand(0);
1608 // If the second operand is an immediate, this is an indirect value.
1609 if (DVInsn->getOperand(1).isImm()) {
1610 MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1611 addVariableAddress(*DV, VariableDie, Location);
1612 } else if (RegOp.getReg())
1613 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1614 } else if (DVInsn->getOperand(0).isImm())
1615 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1616 else if (DVInsn->getOperand(0).isFPImm())
1617 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1618 else if (DVInsn->getOperand(0).isCImm())
1619 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1620 DV->getType().isUnsignedDIType());
1622 DV->setDIE(VariableDie);
1625 // .. else use frame index.
1626 int FI = DV->getFrameIndex();
1628 unsigned FrameReg = 0;
1629 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1631 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1632 MachineLocation Location(FrameReg, Offset);
1633 addVariableAddress(*DV, VariableDie, Location);
1637 DV->setDIE(VariableDie);
1641 /// createMemberDIE - Create new member DIE.
1642 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1643 DIE *MemberDie = new DIE(DT.getTag());
1644 StringRef Name = DT.getName();
1646 addString(MemberDie, dwarf::DW_AT_name, Name);
1648 addType(MemberDie, DT.getTypeDerivedFrom());
1650 addSourceLine(MemberDie, DT);
1652 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1653 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1655 uint64_t Size = DT.getSizeInBits();
1656 uint64_t FieldSize = DT.getOriginalTypeSize();
1658 if (Size != FieldSize) {
1660 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1661 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1663 uint64_t Offset = DT.getOffsetInBits();
1664 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1665 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1666 uint64_t FieldOffset = (HiMark - FieldSize);
1667 Offset -= FieldOffset;
1669 // Maybe we need to work from the other end.
1670 if (Asm->getDataLayout().isLittleEndian())
1671 Offset = FieldSize - (Offset + Size);
1672 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1674 // Here WD_AT_data_member_location points to the anonymous
1675 // field that includes this bit field.
1676 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1679 // This is not a bitfield.
1680 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1682 if (DT.getTag() == dwarf::DW_TAG_inheritance
1683 && DT.isVirtual()) {
1685 // For C++, virtual base classes are not at fixed offset. Use following
1686 // expression to extract appropriate offset from vtable.
1687 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1689 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1690 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1691 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1692 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1693 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1694 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1695 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1696 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1698 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1701 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1703 if (DT.isProtected())
1704 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1705 dwarf::DW_ACCESS_protected);
1706 else if (DT.isPrivate())
1707 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1708 dwarf::DW_ACCESS_private);
1709 // Otherwise C++ member and base classes are considered public.
1711 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1712 dwarf::DW_ACCESS_public);
1714 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1715 dwarf::DW_VIRTUALITY_virtual);
1717 // Objective-C properties.
1718 if (MDNode *PNode = DT.getObjCProperty())
1719 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1720 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1723 if (DT.isArtificial())
1724 addFlag(MemberDie, dwarf::DW_AT_artificial);
1729 /// createStaticMemberDIE - Create new DIE for C++ static member.
1730 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1734 DIE *StaticMemberDIE = new DIE(DT.getTag());
1735 DIType Ty = DT.getTypeDerivedFrom();
1737 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1738 addType(StaticMemberDIE, Ty);
1739 addSourceLine(StaticMemberDIE, DT);
1740 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1741 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1743 // FIXME: We could omit private if the parent is a class_type, and
1744 // public if the parent is something else.
1745 if (DT.isProtected())
1746 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1747 dwarf::DW_ACCESS_protected);
1748 else if (DT.isPrivate())
1749 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1750 dwarf::DW_ACCESS_private);
1752 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1753 dwarf::DW_ACCESS_public);
1755 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1756 addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1757 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1758 addConstantFPValue(StaticMemberDIE, CFP);
1760 insertDIE(DT, StaticMemberDIE);
1761 return StaticMemberDIE;