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/TargetRegisterInfo.h"
34 /// CompileUnit - Compile unit constructor.
35 CompileUnit::CompileUnit(unsigned UID, unsigned L, DIE *D, AsmPrinter *A,
36 DwarfDebug *DW, DwarfUnits *DWU)
37 : UniqueID(UID), Language(L), CUDie(D), Asm(A), DD(DW), DU(DWU),
39 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
42 /// ~CompileUnit - Destructor for compile unit.
43 CompileUnit::~CompileUnit() {
44 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
45 DIEBlocks[j]->~DIEBlock();
48 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
49 /// information entry.
50 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
51 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
55 /// getDefaultLowerBound - Return the default lower bound for an array. If the
56 /// DWARF version doesn't handle the language, return -1.
57 int64_t CompileUnit::getDefaultLowerBound() const {
62 case dwarf::DW_LANG_C89:
63 case dwarf::DW_LANG_C99:
64 case dwarf::DW_LANG_C:
65 case dwarf::DW_LANG_C_plus_plus:
66 case dwarf::DW_LANG_ObjC:
67 case dwarf::DW_LANG_ObjC_plus_plus:
70 case dwarf::DW_LANG_Fortran77:
71 case dwarf::DW_LANG_Fortran90:
72 case dwarf::DW_LANG_Fortran95:
75 // The languages below have valid values only if the DWARF version >= 4.
76 case dwarf::DW_LANG_Java:
77 case dwarf::DW_LANG_Python:
78 case dwarf::DW_LANG_UPC:
79 case dwarf::DW_LANG_D:
80 if (dwarf::DWARF_VERSION >= 4)
84 case dwarf::DW_LANG_Ada83:
85 case dwarf::DW_LANG_Ada95:
86 case dwarf::DW_LANG_Cobol74:
87 case dwarf::DW_LANG_Cobol85:
88 case dwarf::DW_LANG_Modula2:
89 case dwarf::DW_LANG_Pascal83:
90 case dwarf::DW_LANG_PLI:
91 if (dwarf::DWARF_VERSION >= 4)
99 /// addFlag - Add a flag that is true.
100 void CompileUnit::addFlag(DIE *Die, unsigned Attribute) {
101 if (!DD->useDarwinGDBCompat())
102 Die->addValue(Attribute, dwarf::DW_FORM_flag_present,
105 addUInt(Die, Attribute, dwarf::DW_FORM_flag, 1);
108 /// addUInt - Add an unsigned integer attribute data and value.
110 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
111 unsigned Form, uint64_t Integer) {
112 if (!Form) Form = DIEInteger::BestForm(false, Integer);
113 DIEValue *Value = Integer == 1 ?
114 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
115 Die->addValue(Attribute, Form, Value);
118 /// addSInt - Add an signed integer attribute data and value.
120 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
121 unsigned Form, int64_t Integer) {
122 if (!Form) Form = DIEInteger::BestForm(true, Integer);
123 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
124 Die->addValue(Attribute, Form, Value);
127 /// addString - Add a string attribute data and value. We always emit a
128 /// reference to the string pool instead of immediate strings so that DIEs have
129 /// more predictable sizes. In the case of split dwarf we emit an index
130 /// into another table which gets us the static offset into the string
132 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
133 if (!DD->useSplitDwarf()) {
134 MCSymbol *Symb = DU->getStringPoolEntry(String);
136 if (Asm->needsRelocationsForDwarfStringPool())
137 Value = new (DIEValueAllocator) DIELabel(Symb);
139 MCSymbol *StringPool = DU->getStringPoolSym();
140 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
142 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
144 unsigned idx = DU->getStringPoolIndex(String);
145 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
146 Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Value);
150 /// addLocalString - Add a string attribute data and value. This is guaranteed
151 /// to be in the local string pool instead of indirected.
152 void CompileUnit::addLocalString(DIE *Die, unsigned Attribute,
154 MCSymbol *Symb = DU->getStringPoolEntry(String);
156 if (Asm->needsRelocationsForDwarfStringPool())
157 Value = new (DIEValueAllocator) DIELabel(Symb);
159 MCSymbol *StringPool = DU->getStringPoolSym();
160 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
162 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
165 /// addLabel - Add a Dwarf label attribute data and value.
167 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
168 const MCSymbol *Label) {
169 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
170 Die->addValue(Attribute, Form, Value);
173 /// addDelta - Add a label delta attribute data and value.
175 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
176 const MCSymbol *Hi, const MCSymbol *Lo) {
177 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
178 Die->addValue(Attribute, Form, Value);
181 /// addDIEEntry - Add a DIE attribute data and value.
183 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
185 Die->addValue(Attribute, Form, createDIEEntry(Entry));
188 /// addBlock - Add block data.
190 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
192 Block->ComputeSize(Asm);
193 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
194 Die->addValue(Attribute, Block->BestForm(), Block);
197 /// addSourceLine - Add location information to specified debug information
199 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
204 unsigned Line = V.getLineNumber();
207 unsigned FileID = DD->getOrCreateSourceID(V.getContext().getFilename(),
208 V.getContext().getDirectory());
209 assert(FileID && "Invalid file id");
210 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
211 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
214 /// addSourceLine - Add location information to specified debug information
216 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
217 // Verify global variable.
221 unsigned Line = G.getLineNumber();
224 unsigned FileID = DD->getOrCreateSourceID(G.getFilename(), G.getDirectory());
225 assert(FileID && "Invalid file id");
226 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
227 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
230 /// addSourceLine - Add location information to specified debug information
232 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
233 // Verify subprogram.
237 // If the line number is 0, don't add it.
238 unsigned Line = SP.getLineNumber();
242 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(),
244 assert(FileID && "Invalid file id");
245 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
246 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
249 /// addSourceLine - Add location information to specified debug information
251 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
256 unsigned Line = Ty.getLineNumber();
259 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(),
261 assert(FileID && "Invalid file id");
262 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
263 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
266 /// addSourceLine - Add location information to specified debug information
268 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
273 unsigned Line = Ty.getLineNumber();
276 DIFile File = Ty.getFile();
277 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
278 File.getDirectory());
279 assert(FileID && "Invalid file id");
280 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
281 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
284 /// addSourceLine - Add location information to specified debug information
286 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
291 unsigned Line = NS.getLineNumber();
294 StringRef FN = NS.getFilename();
296 unsigned FileID = DD->getOrCreateSourceID(FN, NS.getDirectory());
297 assert(FileID && "Invalid file id");
298 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
299 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
302 /// addVariableAddress - Add DW_AT_location attribute for a
303 /// DbgVariable based on provided MachineLocation.
304 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
305 MachineLocation Location) {
306 if (DV->variableHasComplexAddress())
307 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
308 else if (DV->isBlockByrefVariable())
309 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
311 addAddress(Die, dwarf::DW_AT_location, Location);
314 /// addRegisterOp - Add register operand.
315 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
316 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
317 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
319 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
321 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
322 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
326 /// addRegisterOffset - Add register offset.
327 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
329 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
330 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
331 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
332 if (Reg == TRI->getFrameRegister(*Asm->MF))
333 // If variable offset is based in frame register then use fbreg.
334 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
336 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
338 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
339 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
341 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
344 /// addAddress - Add an address attribute to a die based on the location
346 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
347 const MachineLocation &Location) {
348 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
350 if (Location.isReg())
351 addRegisterOp(Block, Location.getReg());
353 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
355 // Now attach the location information to the DIE.
356 addBlock(Die, Attribute, 0, Block);
359 /// addComplexAddress - Start with the address based on the location provided,
360 /// and generate the DWARF information necessary to find the actual variable
361 /// given the extra address information encoded in the DIVariable, starting from
362 /// the starting location. Add the DWARF information to the die.
364 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
366 const MachineLocation &Location) {
367 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
368 unsigned N = DV->getNumAddrElements();
370 if (Location.isReg()) {
371 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
372 // If first address element is OpPlus then emit
373 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
374 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
377 addRegisterOp(Block, Location.getReg());
380 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
383 uint64_t Element = DV->getAddrElement(i);
384 if (Element == DIBuilder::OpPlus) {
385 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
386 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
387 } else if (Element == DIBuilder::OpDeref) {
388 if (!Location.isReg())
389 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
390 } else llvm_unreachable("unknown DIBuilder Opcode");
393 // Now attach the location information to the DIE.
394 addBlock(Die, Attribute, 0, Block);
397 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
398 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
399 gives the variable VarName either the struct, or a pointer to the struct, as
400 its type. This is necessary for various behind-the-scenes things the
401 compiler needs to do with by-reference variables in Blocks.
403 However, as far as the original *programmer* is concerned, the variable
404 should still have type 'SomeType', as originally declared.
406 The function getBlockByrefType dives into the __Block_byref_x_VarName
407 struct to find the original type of the variable, which is then assigned to
408 the variable's Debug Information Entry as its real type. So far, so good.
409 However now the debugger will expect the variable VarName to have the type
410 SomeType. So we need the location attribute for the variable to be an
411 expression that explains to the debugger how to navigate through the
412 pointers and struct to find the actual variable of type SomeType.
414 The following function does just that. We start by getting
415 the "normal" location for the variable. This will be the location
416 of either the struct __Block_byref_x_VarName or the pointer to the
417 struct __Block_byref_x_VarName.
419 The struct will look something like:
421 struct __Block_byref_x_VarName {
423 struct __Block_byref_x_VarName *forwarding;
424 ... <various other fields>
426 ... <maybe more fields>
429 If we are given the struct directly (as our starting point) we
430 need to tell the debugger to:
432 1). Add the offset of the forwarding field.
434 2). Follow that pointer to get the real __Block_byref_x_VarName
435 struct to use (the real one may have been copied onto the heap).
437 3). Add the offset for the field VarName, to find the actual variable.
439 If we started with a pointer to the struct, then we need to
440 dereference that pointer first, before the other steps.
441 Translating this into DWARF ops, we will need to append the following
442 to the current location description for the variable:
444 DW_OP_deref -- optional, if we start with a pointer
445 DW_OP_plus_uconst <forward_fld_offset>
447 DW_OP_plus_uconst <varName_fld_offset>
449 That is what this function does. */
451 /// addBlockByrefAddress - Start with the address based on the location
452 /// provided, and generate the DWARF information necessary to find the
453 /// actual Block variable (navigating the Block struct) based on the
454 /// starting location. Add the DWARF information to the die. For
455 /// more information, read large comment just above here.
457 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
459 const MachineLocation &Location) {
460 DIType Ty = DV->getType();
462 unsigned Tag = Ty.getTag();
463 bool isPointer = false;
465 StringRef varName = DV->getName();
467 if (Tag == dwarf::DW_TAG_pointer_type) {
468 DIDerivedType DTy = DIDerivedType(Ty);
469 TmpTy = DTy.getTypeDerivedFrom();
473 DICompositeType blockStruct = DICompositeType(TmpTy);
475 // Find the __forwarding field and the variable field in the __Block_byref
477 DIArray Fields = blockStruct.getTypeArray();
478 DIDescriptor varField = DIDescriptor();
479 DIDescriptor forwardingField = DIDescriptor();
481 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
482 DIDescriptor Element = Fields.getElement(i);
483 DIDerivedType DT = DIDerivedType(Element);
484 StringRef fieldName = DT.getName();
485 if (fieldName == "__forwarding")
486 forwardingField = Element;
487 else if (fieldName == varName)
491 // Get the offsets for the forwarding field and the variable field.
492 unsigned forwardingFieldOffset =
493 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
494 unsigned varFieldOffset =
495 DIDerivedType(varField).getOffsetInBits() >> 3;
497 // Decode the original location, and use that as the start of the byref
498 // variable's location.
499 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
501 if (Location.isReg())
502 addRegisterOp(Block, Location.getReg());
504 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
506 // If we started with a pointer to the __Block_byref... struct, then
507 // the first thing we need to do is dereference the pointer (DW_OP_deref).
509 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
511 // Next add the offset for the '__forwarding' field:
512 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
513 // adding the offset if it's 0.
514 if (forwardingFieldOffset > 0) {
515 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
516 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
519 // Now dereference the __forwarding field to get to the real __Block_byref
520 // struct: DW_OP_deref.
521 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
523 // Now that we've got the real __Block_byref... struct, add the offset
524 // for the variable's field to get to the location of the actual variable:
525 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
526 if (varFieldOffset > 0) {
527 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
528 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
531 // Now attach the location information to the DIE.
532 addBlock(Die, Attribute, 0, Block);
535 /// isTypeSigned - Return true if the type is signed.
536 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
537 if (Ty.isDerivedType())
538 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
539 if (Ty.isBasicType())
540 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
541 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
542 *SizeInBits = Ty.getSizeInBits();
548 /// addConstantValue - Add constant value entry in variable DIE.
549 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
551 assert(MO.isImm() && "Invalid machine operand!");
552 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
554 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
555 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
556 switch (SizeInBits) {
557 case 8: Form = dwarf::DW_FORM_data1; break;
558 case 16: Form = dwarf::DW_FORM_data2; break;
559 case 32: Form = dwarf::DW_FORM_data4; break;
560 case 64: Form = dwarf::DW_FORM_data8; break;
563 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
564 : addUInt(Block, 0, Form, MO.getImm());
566 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
570 /// addConstantFPValue - Add constant value entry in variable DIE.
571 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
572 assert (MO.isFPImm() && "Invalid machine operand!");
573 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
574 APFloat FPImm = MO.getFPImm()->getValueAPF();
576 // Get the raw data form of the floating point.
577 const APInt FltVal = FPImm.bitcastToAPInt();
578 const char *FltPtr = (const char*)FltVal.getRawData();
580 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
581 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
582 int Incr = (LittleEndian ? 1 : -1);
583 int Start = (LittleEndian ? 0 : NumBytes - 1);
584 int Stop = (LittleEndian ? NumBytes : -1);
586 // Output the constant to DWARF one byte at a time.
587 for (; Start != Stop; Start += Incr)
588 addUInt(Block, 0, dwarf::DW_FORM_data1,
589 (unsigned char)0xFF & FltPtr[Start]);
591 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
595 /// addConstantValue - Add constant value entry in variable DIE.
596 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
598 unsigned CIBitWidth = CI->getBitWidth();
599 if (CIBitWidth <= 64) {
601 switch (CIBitWidth) {
602 case 8: form = dwarf::DW_FORM_data1; break;
603 case 16: form = dwarf::DW_FORM_data2; break;
604 case 32: form = dwarf::DW_FORM_data4; break;
605 case 64: form = dwarf::DW_FORM_data8; break;
607 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
610 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
612 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
616 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
618 // Get the raw data form of the large APInt.
619 const APInt Val = CI->getValue();
620 const uint64_t *Ptr64 = Val.getRawData();
622 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
623 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
625 // Output the constant to DWARF one byte at a time.
626 for (int i = 0; i < NumBytes; i++) {
629 c = Ptr64[i / 8] >> (8 * (i & 7));
631 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
632 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
635 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
639 /// addTemplateParams - Add template parameters in buffer.
640 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
641 // Add template parameters.
642 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
643 DIDescriptor Element = TParams.getElement(i);
644 if (Element.isTemplateTypeParameter())
645 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
646 DITemplateTypeParameter(Element)));
647 else if (Element.isTemplateValueParameter())
648 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
649 DITemplateValueParameter(Element)));
653 /// addToContextOwner - Add Die into the list of its context owner's children.
654 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
655 if (Context.isType()) {
656 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
657 ContextDIE->addChild(Die);
658 } else if (Context.isNameSpace()) {
659 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
660 ContextDIE->addChild(Die);
661 } else if (Context.isSubprogram()) {
662 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
663 ContextDIE->addChild(Die);
664 } else if (DIE *ContextDIE = getDIE(Context))
665 ContextDIE->addChild(Die);
670 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
672 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
676 DIE *TyDIE = getDIE(Ty);
681 TyDIE = new DIE(dwarf::DW_TAG_base_type);
682 insertDIE(Ty, TyDIE);
683 if (Ty.isBasicType())
684 constructTypeDIE(*TyDIE, DIBasicType(Ty));
685 else if (Ty.isCompositeType())
686 constructTypeDIE(*TyDIE, DICompositeType(Ty));
688 assert(Ty.isDerivedType() && "Unknown kind of DIType");
689 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
691 // If this is a named finished type then include it in the list of types
692 // for the accelerator tables.
693 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
694 bool IsImplementation = 0;
695 if (Ty.isCompositeType()) {
696 DICompositeType CT(Ty);
697 // A runtime language of 0 actually means C/C++ and that any
698 // non-negative value is some version of Objective-C/C++.
699 IsImplementation = (CT.getRunTimeLang() == 0) ||
700 CT.isObjcClassComplete();
702 unsigned Flags = IsImplementation ?
703 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
704 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
707 addToContextOwner(TyDIE, Ty.getContext());
711 /// addType - Add a new type attribute to the specified entity.
712 void CompileUnit::addType(DIE *Entity, DIType Ty, unsigned Attribute) {
716 // Check for pre-existence.
717 DIEEntry *Entry = getDIEEntry(Ty);
718 // If it exists then use the existing value.
720 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
725 DIE *Buffer = getOrCreateTypeDIE(Ty);
728 Entry = createDIEEntry(Buffer);
729 insertDIEEntry(Ty, Entry);
730 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
732 // If this is a complete composite type then include it in the
733 // list of global types.
737 /// addGlobalType - Add a new global type to the compile unit.
739 void CompileUnit::addGlobalType(DIType Ty) {
740 DIDescriptor Context = Ty.getContext();
741 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
742 && (!Context || Context.isCompileUnit() || Context.isFile()
743 || Context.isNameSpace()))
744 if (DIEEntry *Entry = getDIEEntry(Ty))
745 GlobalTypes[Ty.getName()] = Entry->getEntry();
748 /// addPubTypes - Add type for pubtypes section.
749 void CompileUnit::addPubTypes(DISubprogram SP) {
750 DICompositeType SPTy = SP.getType();
751 unsigned SPTag = SPTy.getTag();
752 if (SPTag != dwarf::DW_TAG_subroutine_type)
755 DIArray Args = SPTy.getTypeArray();
756 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
757 DIType ATy(Args.getElement(i));
764 /// constructTypeDIE - Construct basic type die from DIBasicType.
765 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
766 // Get core information.
767 StringRef Name = BTy.getName();
768 // Add name if not anonymous or intermediate type.
770 addString(&Buffer, dwarf::DW_AT_name, Name);
772 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
773 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
774 // Unspecified types has only name, nothing else.
778 Buffer.setTag(dwarf::DW_TAG_base_type);
779 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
782 uint64_t Size = BTy.getSizeInBits() >> 3;
783 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
786 /// constructTypeDIE - Construct derived type die from DIDerivedType.
787 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
788 // Get core information.
789 StringRef Name = DTy.getName();
790 uint64_t Size = DTy.getSizeInBits() >> 3;
791 unsigned Tag = DTy.getTag();
793 // FIXME - Workaround for templates.
794 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
798 // Map to main type, void will not have a type.
799 DIType FromTy = DTy.getTypeDerivedFrom();
800 addType(&Buffer, FromTy);
802 // Add name if not anonymous or intermediate type.
804 addString(&Buffer, dwarf::DW_AT_name, Name);
806 // Add size if non-zero (derived types might be zero-sized.)
807 if (Size && Tag != dwarf::DW_TAG_pointer_type)
808 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
810 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
811 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
812 getOrCreateTypeDIE(DTy.getClassType()));
813 // Add source line info if available and TyDesc is not a forward declaration.
814 if (!DTy.isForwardDecl())
815 addSourceLine(&Buffer, DTy);
818 /// constructTypeDIE - Construct type DIE from DICompositeType.
819 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
820 // Get core information.
821 StringRef Name = CTy.getName();
823 uint64_t Size = CTy.getSizeInBits() >> 3;
824 unsigned Tag = CTy.getTag();
828 case dwarf::DW_TAG_array_type:
829 constructArrayTypeDIE(Buffer, &CTy);
831 case dwarf::DW_TAG_enumeration_type: {
832 DIArray Elements = CTy.getTypeArray();
834 // Add enumerators to enumeration type.
835 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
837 DIDescriptor Enum(Elements.getElement(i));
838 if (Enum.isEnumerator()) {
839 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
840 Buffer.addChild(ElemDie);
843 DIType DTy = CTy.getTypeDerivedFrom();
845 addType(&Buffer, DTy);
846 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
850 case dwarf::DW_TAG_subroutine_type: {
852 DIArray Elements = CTy.getTypeArray();
853 DIDescriptor RTy = Elements.getElement(0);
854 addType(&Buffer, DIType(RTy));
856 bool isPrototyped = true;
858 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
859 DIDescriptor Ty = Elements.getElement(i);
860 if (Ty.isUnspecifiedParameter()) {
861 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
862 Buffer.addChild(Arg);
863 isPrototyped = false;
865 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
866 addType(Arg, DIType(Ty));
867 Buffer.addChild(Arg);
870 // Add prototype flag if we're dealing with a C language and the
871 // function has been prototyped.
873 (Language == dwarf::DW_LANG_C89 ||
874 Language == dwarf::DW_LANG_C99 ||
875 Language == dwarf::DW_LANG_ObjC))
876 addFlag(&Buffer, dwarf::DW_AT_prototyped);
879 case dwarf::DW_TAG_structure_type:
880 case dwarf::DW_TAG_union_type:
881 case dwarf::DW_TAG_class_type: {
882 // Add elements to structure type.
883 DIArray Elements = CTy.getTypeArray();
885 // A forward struct declared type may not have elements available.
886 unsigned N = Elements.getNumElements();
890 // Add elements to structure type.
891 for (unsigned i = 0; i < N; ++i) {
892 DIDescriptor Element = Elements.getElement(i);
894 if (Element.isSubprogram()) {
895 DISubprogram SP(Element);
896 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
897 if (SP.isProtected())
898 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
899 dwarf::DW_ACCESS_protected);
900 else if (SP.isPrivate())
901 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
902 dwarf::DW_ACCESS_private);
904 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
905 dwarf::DW_ACCESS_public);
907 addFlag(ElemDie, dwarf::DW_AT_explicit);
909 else if (Element.isVariable()) {
910 DIVariable DV(Element);
911 ElemDie = new DIE(dwarf::DW_TAG_variable);
912 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
913 addType(ElemDie, DV.getType());
914 addFlag(ElemDie, dwarf::DW_AT_declaration);
915 addFlag(ElemDie, dwarf::DW_AT_external);
916 addSourceLine(ElemDie, DV);
917 } else if (Element.isDerivedType()) {
918 DIDerivedType DDTy(Element);
919 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
920 ElemDie = new DIE(dwarf::DW_TAG_friend);
921 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
923 ElemDie = createMemberDIE(DIDerivedType(Element));
924 } else if (Element.isObjCProperty()) {
925 DIObjCProperty Property(Element);
926 ElemDie = new DIE(Property.getTag());
927 StringRef PropertyName = Property.getObjCPropertyName();
928 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
929 addType(ElemDie, Property.getType());
930 addSourceLine(ElemDie, Property);
931 StringRef GetterName = Property.getObjCPropertyGetterName();
932 if (!GetterName.empty())
933 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
934 StringRef SetterName = Property.getObjCPropertySetterName();
935 if (!SetterName.empty())
936 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
937 unsigned PropertyAttributes = 0;
938 if (Property.isReadOnlyObjCProperty())
939 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
940 if (Property.isReadWriteObjCProperty())
941 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
942 if (Property.isAssignObjCProperty())
943 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
944 if (Property.isRetainObjCProperty())
945 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
946 if (Property.isCopyObjCProperty())
947 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
948 if (Property.isNonAtomicObjCProperty())
949 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
950 if (PropertyAttributes)
951 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
954 DIEEntry *Entry = getDIEEntry(Element);
956 Entry = createDIEEntry(ElemDie);
957 insertDIEEntry(Element, Entry);
961 Buffer.addChild(ElemDie);
964 if (CTy.isAppleBlockExtension())
965 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
967 DICompositeType ContainingType = CTy.getContainingType();
968 if (DIDescriptor(ContainingType).isCompositeType())
969 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
970 getOrCreateTypeDIE(DIType(ContainingType)));
972 DIDescriptor Context = CTy.getContext();
973 addToContextOwner(&Buffer, Context);
976 if (CTy.isObjcClassComplete())
977 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
979 // Add template parameters to a class, structure or union types.
980 // FIXME: The support isn't in the metadata for this yet.
981 if (Tag == dwarf::DW_TAG_class_type ||
982 Tag == dwarf::DW_TAG_structure_type ||
983 Tag == dwarf::DW_TAG_union_type)
984 addTemplateParams(Buffer, CTy.getTemplateParams());
992 // Add name if not anonymous or intermediate type.
994 addString(&Buffer, dwarf::DW_AT_name, Name);
996 if (Tag == dwarf::DW_TAG_enumeration_type ||
997 Tag == dwarf::DW_TAG_class_type ||
998 Tag == dwarf::DW_TAG_structure_type ||
999 Tag == dwarf::DW_TAG_union_type) {
1000 // Add size if non-zero (derived types might be zero-sized.)
1001 // TODO: Do we care about size for enum forward declarations?
1003 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1004 else if (!CTy.isForwardDecl())
1005 // Add zero size if it is not a forward declaration.
1006 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1008 // If we're a forward decl, say so.
1009 if (CTy.isForwardDecl())
1010 addFlag(&Buffer, dwarf::DW_AT_declaration);
1012 // Add source line info if available.
1013 if (!CTy.isForwardDecl())
1014 addSourceLine(&Buffer, CTy);
1016 // No harm in adding the runtime language to the declaration.
1017 unsigned RLang = CTy.getRunTimeLang();
1019 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1020 dwarf::DW_FORM_data1, RLang);
1024 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1025 /// for the given DITemplateTypeParameter.
1027 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1028 DIE *ParamDIE = getDIE(TP);
1032 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1033 addType(ParamDIE, TP.getType());
1034 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1038 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1039 /// for the given DITemplateValueParameter.
1041 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){
1042 DIE *ParamDIE = getDIE(TPV);
1046 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
1047 addType(ParamDIE, TPV.getType());
1048 if (!TPV.getName().empty())
1049 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
1050 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1055 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1056 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1057 DIE *NDie = getDIE(NS);
1060 NDie = new DIE(dwarf::DW_TAG_namespace);
1061 insertDIE(NS, NDie);
1062 if (!NS.getName().empty()) {
1063 addString(NDie, dwarf::DW_AT_name, NS.getName());
1064 addAccelNamespace(NS.getName(), NDie);
1066 addAccelNamespace("(anonymous namespace)", NDie);
1067 addSourceLine(NDie, NS);
1068 addToContextOwner(NDie, NS.getContext());
1072 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1073 /// printer to not emit usual symbol prefix before the symbol name is used then
1074 /// return linkage name after skipping this special LLVM prefix.
1075 static StringRef getRealLinkageName(StringRef LinkageName) {
1077 if (LinkageName.startswith(StringRef(&One, 1)))
1078 return LinkageName.substr(1);
1082 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1083 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1084 DIE *SPDie = getDIE(SP);
1088 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1090 // DW_TAG_inlined_subroutine may refer to this DIE.
1091 insertDIE(SP, SPDie);
1093 DISubprogram SPDecl = SP.getFunctionDeclaration();
1094 DIE *DeclDie = NULL;
1095 if (SPDecl.isSubprogram()) {
1096 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1099 // Add to context owner.
1100 addToContextOwner(SPDie, SP.getContext());
1102 // Add function template parameters.
1103 addTemplateParams(*SPDie, SP.getTemplateParams());
1105 // Unfortunately this code needs to stay here instead of below the
1106 // AT_specification code in order to work around a bug in older
1107 // gdbs that requires the linkage name to resolve multiple template
1109 // TODO: Remove this set of code when we get rid of the old gdb
1111 StringRef LinkageName = SP.getLinkageName();
1112 if (!LinkageName.empty() && DD->useDarwinGDBCompat())
1113 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1114 getRealLinkageName(LinkageName));
1116 // If this DIE is going to refer declaration info using AT_specification
1117 // then there is no need to add other attributes.
1119 // Refer function declaration directly.
1120 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1126 // Add the linkage name if we have one.
1127 if (!LinkageName.empty() && !DD->useDarwinGDBCompat())
1128 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1129 getRealLinkageName(LinkageName));
1131 // Constructors and operators for anonymous aggregates do not have names.
1132 if (!SP.getName().empty())
1133 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1135 addSourceLine(SPDie, SP);
1137 // Add the prototype if we have a prototype and we have a C like
1139 if (SP.isPrototyped() &&
1140 (Language == dwarf::DW_LANG_C89 ||
1141 Language == dwarf::DW_LANG_C99 ||
1142 Language == dwarf::DW_LANG_ObjC))
1143 addFlag(SPDie, dwarf::DW_AT_prototyped);
1146 DICompositeType SPTy = SP.getType();
1147 DIArray Args = SPTy.getTypeArray();
1148 unsigned SPTag = SPTy.getTag();
1150 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1151 addType(SPDie, SPTy);
1153 addType(SPDie, DIType(Args.getElement(0)));
1155 unsigned VK = SP.getVirtuality();
1157 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1158 DIEBlock *Block = getDIEBlock();
1159 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1160 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1161 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1162 ContainingTypeMap.insert(std::make_pair(SPDie,
1163 SP.getContainingType()));
1166 if (!SP.isDefinition()) {
1167 addFlag(SPDie, dwarf::DW_AT_declaration);
1169 // Add arguments. Do not add arguments for subprogram definition. They will
1170 // be handled while processing variables.
1171 DICompositeType SPTy = SP.getType();
1172 DIArray Args = SPTy.getTypeArray();
1173 unsigned SPTag = SPTy.getTag();
1175 if (SPTag == dwarf::DW_TAG_subroutine_type)
1176 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1177 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1178 DIType ATy = DIType(Args.getElement(i));
1180 if (ATy.isArtificial())
1181 addFlag(Arg, dwarf::DW_AT_artificial);
1182 SPDie->addChild(Arg);
1186 if (SP.isArtificial())
1187 addFlag(SPDie, dwarf::DW_AT_artificial);
1189 if (!SP.isLocalToUnit())
1190 addFlag(SPDie, dwarf::DW_AT_external);
1192 if (SP.isOptimized())
1193 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1195 if (unsigned isa = Asm->getISAEncoding()) {
1196 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1202 // Return const expression if value is a GEP to access merged global
1204 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1205 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1206 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1207 if (!CE || CE->getNumOperands() != 3 ||
1208 CE->getOpcode() != Instruction::GetElementPtr)
1211 // First operand points to a global struct.
1212 Value *Ptr = CE->getOperand(0);
1213 if (!isa<GlobalValue>(Ptr) ||
1214 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1217 // Second operand is zero.
1218 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1219 if (!CI || !CI->isZero())
1222 // Third operand is offset.
1223 if (!isa<ConstantInt>(CE->getOperand(2)))
1229 /// createGlobalVariableDIE - create global variable DIE.
1230 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1231 // Check for pre-existence.
1235 DIGlobalVariable GV(N);
1239 DIE *VariableDIE = new DIE(GV.getTag());
1241 insertDIE(N, VariableDIE);
1244 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1245 StringRef LinkageName = GV.getLinkageName();
1246 bool isGlobalVariable = GV.getGlobal() != NULL;
1247 if (!LinkageName.empty() && isGlobalVariable)
1248 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1249 getRealLinkageName(LinkageName));
1251 DIType GTy = GV.getType();
1252 addType(VariableDIE, GTy);
1254 // Add scoping info.
1255 if (!GV.isLocalToUnit())
1256 addFlag(VariableDIE, dwarf::DW_AT_external);
1258 // Add line number info.
1259 addSourceLine(VariableDIE, GV);
1260 // Add to context owner.
1261 DIDescriptor GVContext = GV.getContext();
1262 addToContextOwner(VariableDIE, GVContext);
1264 bool addToAccelTable = false;
1265 DIE *VariableSpecDIE = NULL;
1266 if (isGlobalVariable) {
1267 addToAccelTable = true;
1268 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1269 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1270 addLabel(Block, 0, dwarf::DW_FORM_udata,
1271 Asm->Mang->getSymbol(GV.getGlobal()));
1272 // Do not create specification DIE if context is either compile unit
1274 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1275 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1276 // Create specification DIE.
1277 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1278 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1279 dwarf::DW_FORM_ref4, VariableDIE);
1280 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1281 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1282 addDie(VariableSpecDIE);
1284 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1286 } else if (const ConstantInt *CI =
1287 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1288 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1289 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1290 addToAccelTable = true;
1291 // GV is a merged global.
1292 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1293 Value *Ptr = CE->getOperand(0);
1294 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1295 addLabel(Block, 0, dwarf::DW_FORM_udata,
1296 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1297 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1298 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1299 addUInt(Block, 0, dwarf::DW_FORM_udata,
1300 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1301 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1302 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1305 if (addToAccelTable) {
1306 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1307 addAccelName(GV.getName(), AddrDIE);
1309 // If the linkage name is different than the name, go ahead and output
1310 // that as well into the name table.
1311 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1312 addAccelName(GV.getLinkageName(), AddrDIE);
1318 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1319 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1321 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1322 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1324 // The LowerBound value defines the lower bounds which is typically zero for
1325 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1326 // Count == -1 then the array is unbounded and we do not emit
1327 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1328 // Count == 0, then the array has zero elements in which case we do not emit
1330 int64_t LowerBound = SR.getLo();
1331 int64_t DefaultLowerBound = getDefaultLowerBound();
1332 int64_t Count = SR.getCount();
1334 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1335 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1337 if (Count != -1 && Count != 0)
1338 // FIXME: An unbounded array should reference the expression that defines
1340 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1342 Buffer.addChild(DW_Subrange);
1345 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1346 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1347 DICompositeType *CTy) {
1348 Buffer.setTag(dwarf::DW_TAG_array_type);
1349 if (CTy->isVector())
1350 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1352 // Emit derived type.
1353 addType(&Buffer, CTy->getTypeDerivedFrom());
1354 DIArray Elements = CTy->getTypeArray();
1356 // Get an anonymous type for index type.
1357 // FIXME: This type should be passed down from the front end
1358 // as different languages may have different sizes for indexes.
1359 DIE *IdxTy = getIndexTyDie();
1361 // Construct an anonymous type for index type.
1362 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1363 addString(IdxTy, dwarf::DW_AT_name, "int");
1364 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1365 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1366 dwarf::DW_ATE_signed);
1368 setIndexTyDie(IdxTy);
1371 // Add subranges to array type.
1372 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1373 DIDescriptor Element = Elements.getElement(i);
1374 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1375 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1379 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1380 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1381 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1382 StringRef Name = ETy.getName();
1383 addString(Enumerator, dwarf::DW_AT_name, Name);
1384 int64_t Value = ETy.getEnumValue();
1385 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1389 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1391 void CompileUnit::constructContainingTypeDIEs() {
1392 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1393 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1394 DIE *SPDie = CI->first;
1395 const MDNode *N = CI->second;
1397 DIE *NDie = getDIE(N);
1398 if (!NDie) continue;
1399 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1403 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1404 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1405 StringRef Name = DV->getName();
1407 // Translate tag to proper Dwarf tag.
1408 unsigned Tag = DV->getTag();
1410 // Define variable debug information entry.
1411 DIE *VariableDie = new DIE(Tag);
1412 DbgVariable *AbsVar = DV->getAbstractVariable();
1413 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1415 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1416 dwarf::DW_FORM_ref4, AbsDIE);
1418 addString(VariableDie, dwarf::DW_AT_name, Name);
1419 addSourceLine(VariableDie, DV->getVariable());
1420 addType(VariableDie, DV->getType());
1423 if (DV->isArtificial())
1424 addFlag(VariableDie, dwarf::DW_AT_artificial);
1426 if (isScopeAbstract) {
1427 DV->setDIE(VariableDie);
1431 // Add variable address.
1433 unsigned Offset = DV->getDotDebugLocOffset();
1434 if (Offset != ~0U) {
1435 addLabel(VariableDie, dwarf::DW_AT_location,
1436 dwarf::DW_FORM_data4,
1437 Asm->GetTempSymbol("debug_loc", Offset));
1438 DV->setDIE(VariableDie);
1442 // Check if variable is described by a DBG_VALUE instruction.
1443 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1444 bool updated = false;
1445 if (DVInsn->getNumOperands() == 3) {
1446 if (DVInsn->getOperand(0).isReg()) {
1447 const MachineOperand RegOp = DVInsn->getOperand(0);
1448 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1449 if (DVInsn->getOperand(1).isImm() &&
1450 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1451 unsigned FrameReg = 0;
1452 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1454 TFI->getFrameIndexReference(*Asm->MF,
1455 DVInsn->getOperand(1).getImm(),
1457 MachineLocation Location(FrameReg, Offset);
1458 addVariableAddress(DV, VariableDie, Location);
1460 } else if (RegOp.getReg())
1461 addVariableAddress(DV, VariableDie,
1462 MachineLocation(RegOp.getReg()));
1465 else if (DVInsn->getOperand(0).isImm())
1467 addConstantValue(VariableDie, DVInsn->getOperand(0),
1469 else if (DVInsn->getOperand(0).isFPImm())
1471 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1472 else if (DVInsn->getOperand(0).isCImm())
1474 addConstantValue(VariableDie,
1475 DVInsn->getOperand(0).getCImm(),
1476 DV->getType().isUnsignedDIType());
1478 addVariableAddress(DV, VariableDie,
1479 Asm->getDebugValueLocation(DVInsn));
1483 // If variableDie is not updated then DBG_VALUE instruction does not
1484 // have valid variable info.
1488 DV->setDIE(VariableDie);
1491 // .. else use frame index.
1492 int FI = DV->getFrameIndex();
1494 unsigned FrameReg = 0;
1495 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1497 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1498 MachineLocation Location(FrameReg, Offset);
1499 addVariableAddress(DV, VariableDie, Location);
1503 DV->setDIE(VariableDie);
1507 /// createMemberDIE - Create new member DIE.
1508 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1509 DIE *MemberDie = new DIE(DT.getTag());
1510 StringRef Name = DT.getName();
1512 addString(MemberDie, dwarf::DW_AT_name, Name);
1514 addType(MemberDie, DT.getTypeDerivedFrom());
1516 addSourceLine(MemberDie, DT);
1518 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1519 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1521 uint64_t Size = DT.getSizeInBits();
1522 uint64_t FieldSize = DT.getOriginalTypeSize();
1524 if (Size != FieldSize) {
1526 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1527 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1529 uint64_t Offset = DT.getOffsetInBits();
1530 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1531 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1532 uint64_t FieldOffset = (HiMark - FieldSize);
1533 Offset -= FieldOffset;
1535 // Maybe we need to work from the other end.
1536 if (Asm->getDataLayout().isLittleEndian())
1537 Offset = FieldSize - (Offset + Size);
1538 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1540 // Here WD_AT_data_member_location points to the anonymous
1541 // field that includes this bit field.
1542 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1545 // This is not a bitfield.
1546 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1548 if (DT.getTag() == dwarf::DW_TAG_inheritance
1549 && DT.isVirtual()) {
1551 // For C++, virtual base classes are not at fixed offset. Use following
1552 // expression to extract appropriate offset from vtable.
1553 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1555 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1556 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1557 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1558 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1559 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1560 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1561 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1562 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1564 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1567 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1569 if (DT.isProtected())
1570 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1571 dwarf::DW_ACCESS_protected);
1572 else if (DT.isPrivate())
1573 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1574 dwarf::DW_ACCESS_private);
1575 // Otherwise C++ member and base classes are considered public.
1577 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1578 dwarf::DW_ACCESS_public);
1580 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1581 dwarf::DW_VIRTUALITY_virtual);
1583 // Objective-C properties.
1584 if (MDNode *PNode = DT.getObjCProperty())
1585 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1586 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1589 if (DT.isArtificial())
1590 addFlag(MemberDie, dwarf::DW_AT_artificial);
1592 // This is only for backward compatibility.
1593 StringRef PropertyName = DT.getObjCPropertyName();
1594 if (!PropertyName.empty()) {
1595 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1596 StringRef GetterName = DT.getObjCPropertyGetterName();
1597 if (!GetterName.empty())
1598 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1599 StringRef SetterName = DT.getObjCPropertySetterName();
1600 if (!SetterName.empty())
1601 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1602 unsigned PropertyAttributes = 0;
1603 if (DT.isReadOnlyObjCProperty())
1604 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1605 if (DT.isReadWriteObjCProperty())
1606 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1607 if (DT.isAssignObjCProperty())
1608 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1609 if (DT.isRetainObjCProperty())
1610 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1611 if (DT.isCopyObjCProperty())
1612 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1613 if (DT.isNonAtomicObjCProperty())
1614 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1615 if (PropertyAttributes)
1616 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1617 PropertyAttributes);