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 DD->addDIEEntry(Die, 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 = DD->getTypeDIE(Ty);
792 TyDIE = new DIE(dwarf::DW_TAG_base_type);
793 DD->insertTypeDIE(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 DD->addDIEEntry(Entity, Attribute, dwarf::DW_FORM_ref4, Entry);
834 DIE *Buffer = getOrCreateTypeDIE(Ty);
837 Entry = createDIEEntry(Buffer);
838 insertDIEEntry(Ty, Entry);
839 DD->addDIEEntry(Entity, 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 // Accelerator table mutators - add each name along with its companion
847 // DIE to the proper table while ensuring that the name that we're going
848 // to reference is in the string table. We do this since the names we
849 // add may not only be identical to the names in the DIE.
850 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
851 DU->getStringPoolEntry(Name);
852 std::vector<DIE *> &DIEs = AccelNames[Name];
856 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
857 DU->getStringPoolEntry(Name);
858 std::vector<DIE *> &DIEs = AccelObjC[Name];
862 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
863 DU->getStringPoolEntry(Name);
864 std::vector<DIE *> &DIEs = AccelNamespace[Name];
868 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
869 DU->getStringPoolEntry(Name);
870 std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
874 /// addGlobalName - Add a new global name to the compile unit.
875 void CompileUnit::addGlobalName(StringRef Name, DIE *Die) {
876 GlobalNames[Name] = Die;
879 /// addGlobalType - Add a new global type to the compile unit.
881 void CompileUnit::addGlobalType(DIType Ty) {
882 DIDescriptor Context = DD->resolve(Ty.getContext());
883 if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
884 (!Context || Context.isCompileUnit() || Context.isFile() ||
885 Context.isNameSpace()))
886 if (DIEEntry *Entry = getDIEEntry(Ty))
887 GlobalTypes[Ty.getName()] = Entry->getEntry();
890 /// addPubTypes - Add type for pubtypes section.
891 void CompileUnit::addPubTypes(DISubprogram SP) {
892 DICompositeType SPTy = SP.getType();
893 uint16_t SPTag = SPTy.getTag();
894 if (SPTag != dwarf::DW_TAG_subroutine_type)
897 DIArray Args = SPTy.getTypeArray();
898 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
899 DIType ATy(Args.getElement(i));
906 /// constructTypeDIE - Construct basic type die from DIBasicType.
907 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
908 // Get core information.
909 StringRef Name = BTy.getName();
910 // Add name if not anonymous or intermediate type.
912 addString(&Buffer, dwarf::DW_AT_name, Name);
914 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
915 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
916 // An unspecified type only has a name attribute.
920 Buffer.setTag(dwarf::DW_TAG_base_type);
921 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
924 uint64_t Size = BTy.getSizeInBits() >> 3;
925 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
928 /// constructTypeDIE - Construct derived type die from DIDerivedType.
929 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
930 // Get core information.
931 StringRef Name = DTy.getName();
932 uint64_t Size = DTy.getSizeInBits() >> 3;
933 uint16_t Tag = DTy.getTag();
935 // FIXME - Workaround for templates.
936 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
940 // Map to main type, void will not have a type.
941 DIType FromTy = DTy.getTypeDerivedFrom();
943 addType(&Buffer, FromTy);
945 // Add name if not anonymous or intermediate type.
947 addString(&Buffer, dwarf::DW_AT_name, Name);
949 // Add size if non-zero (derived types might be zero-sized.)
950 if (Size && Tag != dwarf::DW_TAG_pointer_type)
951 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
953 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
954 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
955 getOrCreateTypeDIE(DD->resolve(DTy.getClassType())));
956 // Add source line info if available and TyDesc is not a forward declaration.
957 if (!DTy.isForwardDecl())
958 addSourceLine(&Buffer, DTy);
961 /// Return true if the type is appropriately scoped to be contained inside
962 /// its own type unit.
963 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
964 DIScope Parent = DD->resolve(Ty.getContext());
966 // Don't generate a hash for anything scoped inside a function.
967 if (Parent.isSubprogram())
969 Parent = DD->resolve(Parent.getContext());
974 /// Return true if the type should be split out into a type unit.
975 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
976 uint16_t Tag = CTy.getTag();
979 case dwarf::DW_TAG_structure_type:
980 case dwarf::DW_TAG_union_type:
981 case dwarf::DW_TAG_enumeration_type:
982 case dwarf::DW_TAG_class_type:
983 // If this is a class, structure, union, or enumeration type
984 // that is not a declaration, is a type definition, and not scoped
985 // inside a function then separate this out as a type unit.
986 if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy, DD))
994 /// constructTypeDIE - Construct type DIE from DICompositeType.
995 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
996 // Get core information.
997 StringRef Name = CTy.getName();
999 uint64_t Size = CTy.getSizeInBits() >> 3;
1000 uint16_t Tag = CTy.getTag();
1004 case dwarf::DW_TAG_array_type:
1005 constructArrayTypeDIE(Buffer, &CTy);
1007 case dwarf::DW_TAG_enumeration_type: {
1008 DIArray Elements = CTy.getTypeArray();
1010 // Add enumerators to enumeration type.
1011 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1012 DIE *ElemDie = NULL;
1013 DIDescriptor Enum(Elements.getElement(i));
1014 if (Enum.isEnumerator()) {
1015 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1016 Buffer.addChild(ElemDie);
1019 DIType DTy = CTy.getTypeDerivedFrom();
1021 addType(&Buffer, DTy);
1022 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
1026 case dwarf::DW_TAG_subroutine_type: {
1027 // Add return type. A void return won't have a type.
1028 DIArray Elements = CTy.getTypeArray();
1029 DIDescriptor RTy = Elements.getElement(0);
1031 addType(&Buffer, DIType(RTy));
1033 bool isPrototyped = true;
1035 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1036 DIDescriptor Ty = Elements.getElement(i);
1037 if (Ty.isUnspecifiedParameter()) {
1038 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1039 Buffer.addChild(Arg);
1040 isPrototyped = false;
1042 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1043 addType(Arg, DIType(Ty));
1044 if (DIType(Ty).isArtificial())
1045 addFlag(Arg, dwarf::DW_AT_artificial);
1046 Buffer.addChild(Arg);
1049 // Add prototype flag if we're dealing with a C language and the
1050 // function has been prototyped.
1051 uint16_t Language = DICompileUnit(Node).getLanguage();
1053 (Language == dwarf::DW_LANG_C89 ||
1054 Language == dwarf::DW_LANG_C99 ||
1055 Language == dwarf::DW_LANG_ObjC))
1056 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1059 case dwarf::DW_TAG_structure_type:
1060 case dwarf::DW_TAG_union_type:
1061 case dwarf::DW_TAG_class_type: {
1062 // Add elements to structure type.
1063 DIArray Elements = CTy.getTypeArray();
1064 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1065 DIDescriptor Element = Elements.getElement(i);
1066 DIE *ElemDie = NULL;
1067 if (Element.isSubprogram()) {
1068 DISubprogram SP(Element);
1069 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1070 if (SP.isProtected())
1071 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1072 dwarf::DW_ACCESS_protected);
1073 else if (SP.isPrivate())
1074 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1075 dwarf::DW_ACCESS_private);
1077 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1078 dwarf::DW_ACCESS_public);
1079 if (SP.isExplicit())
1080 addFlag(ElemDie, dwarf::DW_AT_explicit);
1081 } else if (Element.isDerivedType()) {
1082 DIDerivedType DDTy(Element);
1083 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1084 ElemDie = new DIE(dwarf::DW_TAG_friend);
1085 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1086 } else if (DDTy.isStaticMember())
1087 ElemDie = createStaticMemberDIE(DDTy);
1089 ElemDie = createMemberDIE(DDTy);
1090 } else if (Element.isObjCProperty()) {
1091 DIObjCProperty Property(Element);
1092 ElemDie = new DIE(Property.getTag());
1093 StringRef PropertyName = Property.getObjCPropertyName();
1094 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1095 addType(ElemDie, Property.getType());
1096 addSourceLine(ElemDie, Property);
1097 StringRef GetterName = Property.getObjCPropertyGetterName();
1098 if (!GetterName.empty())
1099 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1100 StringRef SetterName = Property.getObjCPropertySetterName();
1101 if (!SetterName.empty())
1102 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1103 unsigned PropertyAttributes = 0;
1104 if (Property.isReadOnlyObjCProperty())
1105 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1106 if (Property.isReadWriteObjCProperty())
1107 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1108 if (Property.isAssignObjCProperty())
1109 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1110 if (Property.isRetainObjCProperty())
1111 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1112 if (Property.isCopyObjCProperty())
1113 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1114 if (Property.isNonAtomicObjCProperty())
1115 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1116 if (PropertyAttributes)
1117 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1118 PropertyAttributes);
1120 DIEEntry *Entry = getDIEEntry(Element);
1122 Entry = createDIEEntry(ElemDie);
1123 insertDIEEntry(Element, Entry);
1127 Buffer.addChild(ElemDie);
1130 if (CTy.isAppleBlockExtension())
1131 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1133 DICompositeType ContainingType(DD->resolve(CTy.getContainingType()));
1134 if (DIDescriptor(ContainingType).isCompositeType())
1135 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1136 getOrCreateTypeDIE(DIType(ContainingType)));
1138 addToContextOwner(&Buffer, DD->resolve(CTy.getContext()));
1140 if (CTy.isObjcClassComplete())
1141 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1143 // Add template parameters to a class, structure or union types.
1144 // FIXME: The support isn't in the metadata for this yet.
1145 if (Tag == dwarf::DW_TAG_class_type ||
1146 Tag == dwarf::DW_TAG_structure_type ||
1147 Tag == dwarf::DW_TAG_union_type)
1148 addTemplateParams(Buffer, CTy.getTemplateParams());
1156 // Add name if not anonymous or intermediate type.
1158 addString(&Buffer, dwarf::DW_AT_name, Name);
1160 if (Tag == dwarf::DW_TAG_enumeration_type ||
1161 Tag == dwarf::DW_TAG_class_type ||
1162 Tag == dwarf::DW_TAG_structure_type ||
1163 Tag == dwarf::DW_TAG_union_type) {
1164 // Add size if non-zero (derived types might be zero-sized.)
1165 // TODO: Do we care about size for enum forward declarations?
1167 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1168 else if (!CTy.isForwardDecl())
1169 // Add zero size if it is not a forward declaration.
1170 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1172 // If we're a forward decl, say so.
1173 if (CTy.isForwardDecl())
1174 addFlag(&Buffer, dwarf::DW_AT_declaration);
1176 // Add source line info if available.
1177 if (!CTy.isForwardDecl())
1178 addSourceLine(&Buffer, CTy);
1180 // No harm in adding the runtime language to the declaration.
1181 unsigned RLang = CTy.getRunTimeLang();
1183 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1184 dwarf::DW_FORM_data1, RLang);
1186 // If this is a type applicable to a type unit it then add it to the
1187 // list of types we'll compute a hash for later.
1188 if (shouldCreateTypeUnit(CTy, DD))
1189 DD->addTypeUnitType(&Buffer);
1192 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1193 /// for the given DITemplateTypeParameter.
1195 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1196 DIE *ParamDIE = getDIE(TP);
1200 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1201 // Add the type if it exists, it could be void and therefore no type.
1203 addType(ParamDIE, TP.getType());
1204 if (!TP.getName().empty())
1205 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1209 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1210 /// for the given DITemplateValueParameter.
1212 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1213 DIE *ParamDIE = getDIE(VP);
1217 ParamDIE = new DIE(VP.getTag());
1219 // Add the type if there is one, template template and template parameter
1220 // packs will not have a type.
1222 addType(ParamDIE, VP.getType());
1223 if (!VP.getName().empty())
1224 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1225 if (Value *Val = VP.getValue()) {
1226 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1227 addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1228 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1229 // For declaration non-type template parameters (such as global values and
1231 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1232 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1233 // Emit DW_OP_stack_value to use the address as the immediate value of the
1234 // parameter, rather than a pointer to it.
1235 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1236 addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1237 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1238 assert(isa<MDString>(Val));
1239 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1240 cast<MDString>(Val)->getString());
1241 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1242 assert(isa<MDNode>(Val));
1243 DIArray A(cast<MDNode>(Val));
1244 addTemplateParams(*ParamDIE, A);
1251 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1252 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1253 DIE *NDie = getDIE(NS);
1256 NDie = new DIE(dwarf::DW_TAG_namespace);
1257 insertDIE(NS, NDie);
1258 if (!NS.getName().empty()) {
1259 addString(NDie, dwarf::DW_AT_name, NS.getName());
1260 addAccelNamespace(NS.getName(), NDie);
1261 addGlobalName(NS.getName(), NDie);
1263 addAccelNamespace("(anonymous namespace)", NDie);
1264 addSourceLine(NDie, NS);
1265 addToContextOwner(NDie, NS.getContext());
1269 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1270 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1271 DIE *SPDie = DD->getSPDIE(SP);
1275 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1277 // DW_TAG_inlined_subroutine may refer to this DIE.
1278 DD->insertSPDIE(SP, SPDie);
1280 DISubprogram SPDecl = SP.getFunctionDeclaration();
1281 DIE *DeclDie = NULL;
1282 if (SPDecl.isSubprogram()) {
1283 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1286 // Add to context owner.
1287 addToContextOwner(SPDie, SP.getContext());
1289 // Add function template parameters.
1290 addTemplateParams(*SPDie, SP.getTemplateParams());
1292 // If this DIE is going to refer declaration info using AT_specification
1293 // then there is no need to add other attributes.
1295 // Refer function declaration directly.
1296 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1302 // Add the linkage name if we have one.
1303 StringRef LinkageName = SP.getLinkageName();
1304 if (!LinkageName.empty())
1305 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1306 GlobalValue::getRealLinkageName(LinkageName));
1308 // Constructors and operators for anonymous aggregates do not have names.
1309 if (!SP.getName().empty())
1310 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1312 addSourceLine(SPDie, SP);
1314 // Add the prototype if we have a prototype and we have a C like
1316 uint16_t Language = DICompileUnit(Node).getLanguage();
1317 if (SP.isPrototyped() &&
1318 (Language == dwarf::DW_LANG_C89 ||
1319 Language == dwarf::DW_LANG_C99 ||
1320 Language == dwarf::DW_LANG_ObjC))
1321 addFlag(SPDie, dwarf::DW_AT_prototyped);
1323 // Add Return Type. A void return type will not have a type.
1324 DICompositeType SPTy = SP.getType();
1325 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1326 "the type of a subprogram should be a subroutine");
1328 DIArray Args = SPTy.getTypeArray();
1329 if (Args.getElement(0))
1330 addType(SPDie, DIType(Args.getElement(0)));
1332 unsigned VK = SP.getVirtuality();
1334 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1335 DIEBlock *Block = getDIEBlock();
1336 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1337 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1338 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1339 ContainingTypeMap.insert(std::make_pair(SPDie,
1340 DD->resolve(SP.getContainingType())));
1343 if (!SP.isDefinition()) {
1344 addFlag(SPDie, dwarf::DW_AT_declaration);
1346 // Add arguments. Do not add arguments for subprogram definition. They will
1347 // be handled while processing variables.
1348 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1349 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1350 DIType ATy = DIType(Args.getElement(i));
1352 if (ATy.isArtificial())
1353 addFlag(Arg, dwarf::DW_AT_artificial);
1354 SPDie->addChild(Arg);
1358 if (SP.isArtificial())
1359 addFlag(SPDie, dwarf::DW_AT_artificial);
1361 if (!SP.isLocalToUnit())
1362 addFlag(SPDie, dwarf::DW_AT_external);
1364 if (SP.isOptimized())
1365 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1367 if (unsigned isa = Asm->getISAEncoding()) {
1368 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1374 // Return const expression if value is a GEP to access merged global
1376 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1377 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1378 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1379 if (!CE || CE->getNumOperands() != 3 ||
1380 CE->getOpcode() != Instruction::GetElementPtr)
1383 // First operand points to a global struct.
1384 Value *Ptr = CE->getOperand(0);
1385 if (!isa<GlobalValue>(Ptr) ||
1386 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1389 // Second operand is zero.
1390 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1391 if (!CI || !CI->isZero())
1394 // Third operand is offset.
1395 if (!isa<ConstantInt>(CE->getOperand(2)))
1401 /// createGlobalVariableDIE - create global variable DIE.
1402 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1403 // Check for pre-existence.
1407 DIGlobalVariable GV(N);
1408 if (!GV.isGlobalVariable())
1411 DIDescriptor GVContext = GV.getContext();
1412 DIType GTy = GV.getType();
1414 // If this is a static data member definition, some attributes belong
1415 // to the declaration DIE.
1416 DIE *VariableDIE = NULL;
1417 bool IsStaticMember = false;
1418 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1419 if (SDMDecl.Verify()) {
1420 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1421 // We need the declaration DIE that is in the static member's class.
1422 // But that class might not exist in the DWARF yet.
1423 // Creating the class will create the static member decl DIE.
1424 getOrCreateContextDIE(DD->resolve(SDMDecl.getContext()));
1425 VariableDIE = DD->getStaticMemberDIE(SDMDecl);
1426 assert(VariableDIE && "Static member decl has no context?");
1427 IsStaticMember = true;
1430 // If this is not a static data member definition, create the variable
1431 // DIE and add the initial set of attributes to it.
1433 VariableDIE = new DIE(GV.getTag());
1435 insertDIE(N, VariableDIE);
1437 // Add name and type.
1438 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1439 addType(VariableDIE, GTy);
1441 // Add scoping info.
1442 if (!GV.isLocalToUnit()) {
1443 addFlag(VariableDIE, dwarf::DW_AT_external);
1444 addGlobalName(GV.getName(), VariableDIE);
1447 // Add line number info.
1448 addSourceLine(VariableDIE, GV);
1449 // Add to context owner.
1450 addToContextOwner(VariableDIE, GVContext);
1454 bool addToAccelTable = false;
1455 DIE *VariableSpecDIE = NULL;
1456 bool isGlobalVariable = GV.getGlobal() != NULL;
1457 if (isGlobalVariable) {
1458 addToAccelTable = true;
1459 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1460 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1461 if (GV.getGlobal()->isThreadLocal()) {
1462 // FIXME: Make this work with -gsplit-dwarf.
1463 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1464 assert((PointerSize == 4 || PointerSize == 8) &&
1465 "Add support for other sizes if necessary");
1466 const MCExpr *Expr =
1467 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1468 // Based on GCC's support for TLS:
1469 if (!DD->useSplitDwarf()) {
1470 // 1) Start with a constNu of the appropriate pointer size
1471 addUInt(Block, 0, dwarf::DW_FORM_data1,
1472 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1473 // 2) containing the (relocated) address of the TLS variable
1474 addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1476 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1477 addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1479 // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1480 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1482 addOpAddress(Block, Sym);
1483 // Do not create specification DIE if context is either compile unit
1485 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1486 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1487 // Create specification DIE.
1488 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1489 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1490 dwarf::DW_FORM_ref4, VariableDIE);
1491 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1492 // A static member's declaration is already flagged as such.
1493 if (!SDMDecl.Verify())
1494 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1495 addDie(VariableSpecDIE);
1497 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1499 // Add the linkage name.
1500 StringRef LinkageName = GV.getLinkageName();
1501 if (!LinkageName.empty())
1502 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1503 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1505 addString(IsStaticMember && VariableSpecDIE ?
1506 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1507 GlobalValue::getRealLinkageName(LinkageName));
1508 } else if (const ConstantInt *CI =
1509 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1510 // AT_const_value was added when the static member was created. To avoid
1511 // emitting AT_const_value multiple times, we only add AT_const_value when
1512 // it is not a static member.
1513 if (!IsStaticMember)
1514 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1515 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1516 addToAccelTable = true;
1517 // GV is a merged global.
1518 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1519 Value *Ptr = CE->getOperand(0);
1520 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1521 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1522 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1523 addUInt(Block, 0, dwarf::DW_FORM_udata,
1524 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1525 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1526 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1529 if (addToAccelTable) {
1530 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1531 addAccelName(GV.getName(), AddrDIE);
1533 // If the linkage name is different than the name, go ahead and output
1534 // that as well into the name table.
1535 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1536 addAccelName(GV.getLinkageName(), AddrDIE);
1540 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1541 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1543 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1544 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1546 // The LowerBound value defines the lower bounds which is typically zero for
1547 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1548 // Count == -1 then the array is unbounded and we do not emit
1549 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1550 // Count == 0, then the array has zero elements in which case we do not emit
1552 int64_t LowerBound = SR.getLo();
1553 int64_t DefaultLowerBound = getDefaultLowerBound();
1554 int64_t Count = SR.getCount();
1556 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1557 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1559 if (Count != -1 && Count != 0)
1560 // FIXME: An unbounded array should reference the expression that defines
1562 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1564 Buffer.addChild(DW_Subrange);
1567 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1568 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1569 DICompositeType *CTy) {
1570 Buffer.setTag(dwarf::DW_TAG_array_type);
1571 if (CTy->isVector())
1572 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1574 // Emit the element type.
1575 addType(&Buffer, CTy->getTypeDerivedFrom());
1577 // Get an anonymous type for index type.
1578 // FIXME: This type should be passed down from the front end
1579 // as different languages may have different sizes for indexes.
1580 DIE *IdxTy = getIndexTyDie();
1582 // Construct an anonymous type for index type.
1583 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1584 addString(IdxTy, dwarf::DW_AT_name, "int");
1585 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1586 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1587 dwarf::DW_ATE_signed);
1589 setIndexTyDie(IdxTy);
1592 // Add subranges to array type.
1593 DIArray Elements = CTy->getTypeArray();
1594 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1595 DIDescriptor Element = Elements.getElement(i);
1596 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1597 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1601 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1602 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1603 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1604 StringRef Name = ETy.getName();
1605 addString(Enumerator, dwarf::DW_AT_name, Name);
1606 int64_t Value = ETy.getEnumValue();
1607 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1611 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1613 void CompileUnit::constructContainingTypeDIEs() {
1614 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1615 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1616 DIE *SPDie = CI->first;
1617 const MDNode *N = CI->second;
1619 DIE *NDie = DD->getTypeDIE(N);
1620 if (!NDie) continue;
1621 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1625 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1626 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1627 bool isScopeAbstract) {
1628 StringRef Name = DV->getName();
1630 // Translate tag to proper Dwarf tag.
1631 uint16_t Tag = DV->getTag();
1633 // Define variable debug information entry.
1634 DIE *VariableDie = new DIE(Tag);
1635 DbgVariable *AbsVar = DV->getAbstractVariable();
1636 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1638 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1639 dwarf::DW_FORM_ref4, AbsDIE);
1642 addString(VariableDie, dwarf::DW_AT_name, Name);
1643 addSourceLine(VariableDie, DV->getVariable());
1644 addType(VariableDie, DV->getType());
1647 if (DV->isArtificial())
1648 addFlag(VariableDie, dwarf::DW_AT_artificial);
1650 if (isScopeAbstract) {
1651 DV->setDIE(VariableDie);
1655 // Add variable address.
1657 unsigned Offset = DV->getDotDebugLocOffset();
1658 if (Offset != ~0U) {
1659 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1660 Asm->GetTempSymbol("debug_loc", Offset));
1661 DV->setDIE(VariableDie);
1665 // Check if variable is described by a DBG_VALUE instruction.
1666 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1667 assert(DVInsn->getNumOperands() == 3);
1668 if (DVInsn->getOperand(0).isReg()) {
1669 const MachineOperand RegOp = DVInsn->getOperand(0);
1670 // If the second operand is an immediate, this is an indirect value.
1671 if (DVInsn->getOperand(1).isImm()) {
1672 MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1673 addVariableAddress(*DV, VariableDie, Location);
1674 } else if (RegOp.getReg())
1675 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1676 } else if (DVInsn->getOperand(0).isImm())
1677 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1678 else if (DVInsn->getOperand(0).isFPImm())
1679 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1680 else if (DVInsn->getOperand(0).isCImm())
1681 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1682 DV->getType().isUnsignedDIType());
1684 DV->setDIE(VariableDie);
1687 // .. else use frame index.
1688 int FI = DV->getFrameIndex();
1690 unsigned FrameReg = 0;
1691 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1693 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1694 MachineLocation Location(FrameReg, Offset);
1695 addVariableAddress(*DV, VariableDie, Location);
1699 DV->setDIE(VariableDie);
1703 /// createMemberDIE - Create new member DIE.
1704 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1705 DIE *MemberDie = new DIE(DT.getTag());
1706 StringRef Name = DT.getName();
1708 addString(MemberDie, dwarf::DW_AT_name, Name);
1710 addType(MemberDie, DT.getTypeDerivedFrom());
1712 addSourceLine(MemberDie, DT);
1714 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1715 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1717 uint64_t Size = DT.getSizeInBits();
1718 uint64_t FieldSize = DT.getOriginalTypeSize();
1720 if (Size != FieldSize) {
1722 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1723 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1725 uint64_t Offset = DT.getOffsetInBits();
1726 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1727 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1728 uint64_t FieldOffset = (HiMark - FieldSize);
1729 Offset -= FieldOffset;
1731 // Maybe we need to work from the other end.
1732 if (Asm->getDataLayout().isLittleEndian())
1733 Offset = FieldSize - (Offset + Size);
1734 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1736 // Here WD_AT_data_member_location points to the anonymous
1737 // field that includes this bit field.
1738 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1741 // This is not a bitfield.
1742 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1744 if (DT.getTag() == dwarf::DW_TAG_inheritance
1745 && DT.isVirtual()) {
1747 // For C++, virtual base classes are not at fixed offset. Use following
1748 // expression to extract appropriate offset from vtable.
1749 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1751 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1752 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1753 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1754 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1755 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1756 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1757 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1758 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1760 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1763 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1765 if (DT.isProtected())
1766 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1767 dwarf::DW_ACCESS_protected);
1768 else if (DT.isPrivate())
1769 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1770 dwarf::DW_ACCESS_private);
1771 // Otherwise C++ member and base classes are considered public.
1773 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1774 dwarf::DW_ACCESS_public);
1776 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1777 dwarf::DW_VIRTUALITY_virtual);
1779 // Objective-C properties.
1780 if (MDNode *PNode = DT.getObjCProperty())
1781 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1782 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1785 if (DT.isArtificial())
1786 addFlag(MemberDie, dwarf::DW_AT_artificial);
1791 /// createStaticMemberDIE - Create new DIE for C++ static member.
1792 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1796 DIE *StaticMemberDIE = new DIE(DT.getTag());
1797 DIType Ty = DT.getTypeDerivedFrom();
1799 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1800 addType(StaticMemberDIE, Ty);
1801 addSourceLine(StaticMemberDIE, DT);
1802 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1803 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1805 // FIXME: We could omit private if the parent is a class_type, and
1806 // public if the parent is something else.
1807 if (DT.isProtected())
1808 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1809 dwarf::DW_ACCESS_protected);
1810 else if (DT.isPrivate())
1811 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1812 dwarf::DW_ACCESS_private);
1814 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1815 dwarf::DW_ACCESS_public);
1817 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1818 addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1819 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1820 addConstantFPValue(StaticMemberDIE, CFP);
1822 DD->insertStaticMemberDIE(DT, StaticMemberDIE);
1823 return StaticMemberDIE;