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 writing dwarf compile unit.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
16 #include "DwarfAccelTable.h"
17 #include "DwarfCompileUnit.h"
18 #include "DwarfDebug.h"
19 #include "llvm/Constants.h"
20 #include "llvm/GlobalVariable.h"
21 #include "llvm/Instructions.h"
22 #include "llvm/Analysis/DIBuilder.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Target/Mangler.h"
25 #include "llvm/Target/TargetData.h"
26 #include "llvm/Target/TargetFrameLowering.h"
27 #include "llvm/Target/TargetMachine.h"
28 #include "llvm/Target/TargetRegisterInfo.h"
29 #include "llvm/ADT/APFloat.h"
30 #include "llvm/Support/ErrorHandling.h"
34 /// CompileUnit - Compile unit constructor.
35 CompileUnit::CompileUnit(unsigned I, unsigned L, DIE *D, AsmPrinter *A,
37 : ID(I), Language(L), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
38 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
41 /// ~CompileUnit - Destructor for compile unit.
42 CompileUnit::~CompileUnit() {
43 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
44 DIEBlocks[j]->~DIEBlock();
47 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
48 /// information entry.
49 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
50 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
54 /// addUInt - Add an unsigned integer attribute data and value.
56 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
57 unsigned Form, uint64_t Integer) {
58 if (!Form) Form = DIEInteger::BestForm(false, Integer);
59 DIEValue *Value = Integer == 1 ?
60 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
61 Die->addValue(Attribute, Form, Value);
64 /// addSInt - Add an signed integer attribute data and value.
66 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
67 unsigned Form, int64_t Integer) {
68 if (!Form) Form = DIEInteger::BestForm(true, Integer);
69 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
70 Die->addValue(Attribute, Form, Value);
73 /// addString - Add a string attribute data and value. We always emit a
74 /// reference to the string pool instead of immediate strings so that DIEs have
75 /// more predictable sizes.
76 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
77 MCSymbol *Symb = DD->getStringPoolEntry(String);
79 if (Asm->needsRelocationsForDwarfStringPool())
80 Value = new (DIEValueAllocator) DIELabel(Symb);
82 MCSymbol *StringPool = DD->getStringPool();
83 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
85 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
88 /// addLabel - Add a Dwarf label attribute data and value.
90 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
91 const MCSymbol *Label) {
92 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
93 Die->addValue(Attribute, Form, Value);
96 /// addDelta - Add a label delta attribute data and value.
98 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
99 const MCSymbol *Hi, const MCSymbol *Lo) {
100 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
101 Die->addValue(Attribute, Form, Value);
104 /// addDIEEntry - Add a DIE attribute data and value.
106 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
108 Die->addValue(Attribute, Form, createDIEEntry(Entry));
111 /// addBlock - Add block data.
113 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
115 Block->ComputeSize(Asm);
116 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
117 Die->addValue(Attribute, Block->BestForm(), Block);
120 /// addSourceLine - Add location information to specified debug information
122 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
127 unsigned Line = V.getLineNumber();
130 unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
131 V.getContext().getDirectory());
132 assert(FileID && "Invalid file id");
133 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
134 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
137 /// addSourceLine - Add location information to specified debug information
139 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
140 // Verify global variable.
144 unsigned Line = G.getLineNumber();
147 unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(), G.getDirectory());
148 assert(FileID && "Invalid file id");
149 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
150 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
153 /// addSourceLine - Add location information to specified debug information
155 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
156 // Verify subprogram.
160 // If the line number is 0, don't add it.
161 unsigned Line = SP.getLineNumber();
165 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
167 assert(FileID && "Invalid file id");
168 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
169 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
172 /// addSourceLine - Add location information to specified debug information
174 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
179 unsigned Line = Ty.getLineNumber();
182 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
184 assert(FileID && "Invalid file id");
185 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
186 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
189 /// addSourceLine - Add location information to specified debug information
191 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
196 unsigned Line = Ty.getLineNumber();
199 DIFile File = Ty.getFile();
200 unsigned FileID = DD->GetOrCreateSourceID(File.getFilename(),
201 File.getDirectory());
202 assert(FileID && "Invalid file id");
203 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
204 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
207 /// addSourceLine - Add location information to specified debug information
209 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
214 unsigned Line = NS.getLineNumber();
217 StringRef FN = NS.getFilename();
219 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
220 assert(FileID && "Invalid file id");
221 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
222 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
225 /// addVariableAddress - Add DW_AT_location attribute for a
226 /// DbgVariable based on provided MachineLocation.
227 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
228 MachineLocation Location) {
229 if (DV->variableHasComplexAddress())
230 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
231 else if (DV->isBlockByrefVariable())
232 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
234 addAddress(Die, dwarf::DW_AT_location, Location);
237 /// addRegisterOp - Add register operand.
238 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
239 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
240 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
242 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
244 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
245 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
249 /// addRegisterOffset - Add register offset.
250 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
252 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
253 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
254 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
255 if (Reg == TRI->getFrameRegister(*Asm->MF))
256 // If variable offset is based in frame register then use fbreg.
257 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
259 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
261 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
262 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
264 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
267 /// addAddress - Add an address attribute to a die based on the location
269 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
270 const MachineLocation &Location) {
271 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
273 if (Location.isReg())
274 addRegisterOp(Block, Location.getReg());
276 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
278 // Now attach the location information to the DIE.
279 addBlock(Die, Attribute, 0, Block);
282 /// addComplexAddress - Start with the address based on the location provided,
283 /// and generate the DWARF information necessary to find the actual variable
284 /// given the extra address information encoded in the DIVariable, starting from
285 /// the starting location. Add the DWARF information to the die.
287 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
289 const MachineLocation &Location) {
290 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
291 unsigned N = DV->getNumAddrElements();
293 if (Location.isReg()) {
294 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
295 // If first address element is OpPlus then emit
296 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
297 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
300 addRegisterOp(Block, Location.getReg());
303 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
306 uint64_t Element = DV->getAddrElement(i);
307 if (Element == DIBuilder::OpPlus) {
308 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
309 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
310 } else if (Element == DIBuilder::OpDeref) {
311 if (!Location.isReg())
312 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
313 } else llvm_unreachable("unknown DIBuilder Opcode");
316 // Now attach the location information to the DIE.
317 addBlock(Die, Attribute, 0, Block);
320 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
321 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
322 gives the variable VarName either the struct, or a pointer to the struct, as
323 its type. This is necessary for various behind-the-scenes things the
324 compiler needs to do with by-reference variables in Blocks.
326 However, as far as the original *programmer* is concerned, the variable
327 should still have type 'SomeType', as originally declared.
329 The function getBlockByrefType dives into the __Block_byref_x_VarName
330 struct to find the original type of the variable, which is then assigned to
331 the variable's Debug Information Entry as its real type. So far, so good.
332 However now the debugger will expect the variable VarName to have the type
333 SomeType. So we need the location attribute for the variable to be an
334 expression that explains to the debugger how to navigate through the
335 pointers and struct to find the actual variable of type SomeType.
337 The following function does just that. We start by getting
338 the "normal" location for the variable. This will be the location
339 of either the struct __Block_byref_x_VarName or the pointer to the
340 struct __Block_byref_x_VarName.
342 The struct will look something like:
344 struct __Block_byref_x_VarName {
346 struct __Block_byref_x_VarName *forwarding;
347 ... <various other fields>
349 ... <maybe more fields>
352 If we are given the struct directly (as our starting point) we
353 need to tell the debugger to:
355 1). Add the offset of the forwarding field.
357 2). Follow that pointer to get the real __Block_byref_x_VarName
358 struct to use (the real one may have been copied onto the heap).
360 3). Add the offset for the field VarName, to find the actual variable.
362 If we started with a pointer to the struct, then we need to
363 dereference that pointer first, before the other steps.
364 Translating this into DWARF ops, we will need to append the following
365 to the current location description for the variable:
367 DW_OP_deref -- optional, if we start with a pointer
368 DW_OP_plus_uconst <forward_fld_offset>
370 DW_OP_plus_uconst <varName_fld_offset>
372 That is what this function does. */
374 /// addBlockByrefAddress - Start with the address based on the location
375 /// provided, and generate the DWARF information necessary to find the
376 /// actual Block variable (navigating the Block struct) based on the
377 /// starting location. Add the DWARF information to the die. For
378 /// more information, read large comment just above here.
380 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
382 const MachineLocation &Location) {
383 DIType Ty = DV->getType();
385 unsigned Tag = Ty.getTag();
386 bool isPointer = false;
388 StringRef varName = DV->getName();
390 if (Tag == dwarf::DW_TAG_pointer_type) {
391 DIDerivedType DTy = DIDerivedType(Ty);
392 TmpTy = DTy.getTypeDerivedFrom();
396 DICompositeType blockStruct = DICompositeType(TmpTy);
398 // Find the __forwarding field and the variable field in the __Block_byref
400 DIArray Fields = blockStruct.getTypeArray();
401 DIDescriptor varField = DIDescriptor();
402 DIDescriptor forwardingField = DIDescriptor();
404 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
405 DIDescriptor Element = Fields.getElement(i);
406 DIDerivedType DT = DIDerivedType(Element);
407 StringRef fieldName = DT.getName();
408 if (fieldName == "__forwarding")
409 forwardingField = Element;
410 else if (fieldName == varName)
414 // Get the offsets for the forwarding field and the variable field.
415 unsigned forwardingFieldOffset =
416 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
417 unsigned varFieldOffset =
418 DIDerivedType(varField).getOffsetInBits() >> 3;
420 // Decode the original location, and use that as the start of the byref
421 // variable's location.
422 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
423 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
424 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
426 if (Location.isReg()) {
428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
430 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
431 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
435 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
437 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
438 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
441 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
444 // If we started with a pointer to the __Block_byref... struct, then
445 // the first thing we need to do is dereference the pointer (DW_OP_deref).
447 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
449 // Next add the offset for the '__forwarding' field:
450 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
451 // adding the offset if it's 0.
452 if (forwardingFieldOffset > 0) {
453 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
454 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
457 // Now dereference the __forwarding field to get to the real __Block_byref
458 // struct: DW_OP_deref.
459 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
461 // Now that we've got the real __Block_byref... struct, add the offset
462 // for the variable's field to get to the location of the actual variable:
463 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
464 if (varFieldOffset > 0) {
465 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
466 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
469 // Now attach the location information to the DIE.
470 addBlock(Die, Attribute, 0, Block);
473 /// isTypeSigned - Return true if the type is signed.
474 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
475 if (Ty.isDerivedType())
476 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
477 if (Ty.isBasicType())
478 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
479 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
480 *SizeInBits = Ty.getSizeInBits();
486 /// addConstantValue - Add constant value entry in variable DIE.
487 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
489 assert(MO.isImm() && "Invalid machine operand!");
490 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
492 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
493 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
494 switch (SizeInBits) {
495 case 8: Form = dwarf::DW_FORM_data1; break;
496 case 16: Form = dwarf::DW_FORM_data2; break;
497 case 32: Form = dwarf::DW_FORM_data4; break;
498 case 64: Form = dwarf::DW_FORM_data8; break;
501 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
502 : addUInt(Block, 0, Form, MO.getImm());
504 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
508 /// addConstantFPValue - Add constant value entry in variable DIE.
509 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
510 assert (MO.isFPImm() && "Invalid machine operand!");
511 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
512 APFloat FPImm = MO.getFPImm()->getValueAPF();
514 // Get the raw data form of the floating point.
515 const APInt FltVal = FPImm.bitcastToAPInt();
516 const char *FltPtr = (const char*)FltVal.getRawData();
518 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
519 bool LittleEndian = Asm->getTargetData().isLittleEndian();
520 int Incr = (LittleEndian ? 1 : -1);
521 int Start = (LittleEndian ? 0 : NumBytes - 1);
522 int Stop = (LittleEndian ? NumBytes : -1);
524 // Output the constant to DWARF one byte at a time.
525 for (; Start != Stop; Start += Incr)
526 addUInt(Block, 0, dwarf::DW_FORM_data1,
527 (unsigned char)0xFF & FltPtr[Start]);
529 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
533 /// addConstantValue - Add constant value entry in variable DIE.
534 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
536 unsigned CIBitWidth = CI->getBitWidth();
537 if (CIBitWidth <= 64) {
539 switch (CIBitWidth) {
540 case 8: form = dwarf::DW_FORM_data1; break;
541 case 16: form = dwarf::DW_FORM_data2; break;
542 case 32: form = dwarf::DW_FORM_data4; break;
543 case 64: form = dwarf::DW_FORM_data8; break;
545 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
548 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
550 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
554 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
556 // Get the raw data form of the large APInt.
557 const APInt Val = CI->getValue();
558 const uint64_t *Ptr64 = Val.getRawData();
560 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
561 bool LittleEndian = Asm->getTargetData().isLittleEndian();
563 // Output the constant to DWARF one byte at a time.
564 for (int i = 0; i < NumBytes; i++) {
567 c = Ptr64[i / 8] >> (8 * (i & 7));
569 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
570 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
573 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
577 /// addTemplateParams - Add template parameters in buffer.
578 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
579 // Add template parameters.
580 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
581 DIDescriptor Element = TParams.getElement(i);
582 if (Element.isTemplateTypeParameter())
583 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
584 DITemplateTypeParameter(Element)));
585 else if (Element.isTemplateValueParameter())
586 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
587 DITemplateValueParameter(Element)));
591 /// addToContextOwner - Add Die into the list of its context owner's children.
592 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
593 if (Context.isType()) {
594 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
595 ContextDIE->addChild(Die);
596 } else if (Context.isNameSpace()) {
597 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
598 ContextDIE->addChild(Die);
599 } else if (Context.isSubprogram()) {
600 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
601 ContextDIE->addChild(Die);
602 } else if (DIE *ContextDIE = getDIE(Context))
603 ContextDIE->addChild(Die);
608 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
610 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
614 DIE *TyDIE = getDIE(Ty);
619 TyDIE = new DIE(dwarf::DW_TAG_base_type);
620 insertDIE(Ty, TyDIE);
621 if (Ty.isBasicType())
622 constructTypeDIE(*TyDIE, DIBasicType(Ty));
623 else if (Ty.isCompositeType())
624 constructTypeDIE(*TyDIE, DICompositeType(Ty));
626 assert(Ty.isDerivedType() && "Unknown kind of DIType");
627 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
629 // If this is a named finished type then include it in the list of types
630 // for the accelerator tables.
631 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
632 bool IsImplementation = 0;
633 if (Ty.isCompositeType()) {
634 DICompositeType CT(Ty);
635 // A runtime language of 0 actually means C/C++ and that any
636 // non-negative value is some version of Objective-C/C++.
637 IsImplementation = (CT.getRunTimeLang() == 0) ||
638 CT.isObjcClassComplete();
640 unsigned Flags = IsImplementation ?
641 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
642 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
645 addToContextOwner(TyDIE, Ty.getContext());
649 /// addType - Add a new type attribute to the specified entity.
650 void CompileUnit::addType(DIE *Entity, DIType Ty,
651 unsigned Attribute) {
655 // Check for pre-existence.
656 DIEEntry *Entry = getDIEEntry(Ty);
657 // If it exists then use the existing value.
659 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
664 DIE *Buffer = getOrCreateTypeDIE(Ty);
667 Entry = createDIEEntry(Buffer);
668 insertDIEEntry(Ty, Entry);
669 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
671 // If this is a complete composite type then include it in the
672 // list of global types.
676 /// addGlobalType - Add a new global type to the compile unit.
678 void CompileUnit::addGlobalType(DIType Ty) {
679 DIDescriptor Context = Ty.getContext();
680 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
681 && (!Context || Context.isCompileUnit() || Context.isFile()
682 || Context.isNameSpace()))
683 if (DIEEntry *Entry = getDIEEntry(Ty))
684 GlobalTypes[Ty.getName()] = Entry->getEntry();
687 /// addPubTypes - Add type for pubtypes section.
688 void CompileUnit::addPubTypes(DISubprogram SP) {
689 DICompositeType SPTy = SP.getType();
690 unsigned SPTag = SPTy.getTag();
691 if (SPTag != dwarf::DW_TAG_subroutine_type)
694 DIArray Args = SPTy.getTypeArray();
695 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
696 DIType ATy(Args.getElement(i));
703 /// constructTypeDIE - Construct basic type die from DIBasicType.
704 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
705 // Get core information.
706 StringRef Name = BTy.getName();
707 // Add name if not anonymous or intermediate type.
709 addString(&Buffer, dwarf::DW_AT_name, Name);
711 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
712 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
713 // Unspecified types has only name, nothing else.
717 Buffer.setTag(dwarf::DW_TAG_base_type);
718 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
721 uint64_t Size = BTy.getSizeInBits() >> 3;
722 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
725 /// constructTypeDIE - Construct derived type die from DIDerivedType.
726 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
727 // Get core information.
728 StringRef Name = DTy.getName();
729 uint64_t Size = DTy.getSizeInBits() >> 3;
730 unsigned Tag = DTy.getTag();
732 // FIXME - Workaround for templates.
733 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
737 // Map to main type, void will not have a type.
738 DIType FromTy = DTy.getTypeDerivedFrom();
739 addType(&Buffer, FromTy);
741 // Add name if not anonymous or intermediate type.
743 addString(&Buffer, dwarf::DW_AT_name, Name);
745 // Add size if non-zero (derived types might be zero-sized.)
746 if (Size && Tag != dwarf::DW_TAG_pointer_type)
747 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
749 // Add source line info if available and TyDesc is not a forward declaration.
750 if (!DTy.isForwardDecl())
751 addSourceLine(&Buffer, DTy);
754 /// constructTypeDIE - Construct type DIE from DICompositeType.
755 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
756 // Get core information.
757 StringRef Name = CTy.getName();
759 uint64_t Size = CTy.getSizeInBits() >> 3;
760 unsigned Tag = CTy.getTag();
764 case dwarf::DW_TAG_vector_type:
765 case dwarf::DW_TAG_array_type:
766 constructArrayTypeDIE(Buffer, &CTy);
768 case dwarf::DW_TAG_enumeration_type: {
769 DIArray Elements = CTy.getTypeArray();
771 // Add enumerators to enumeration type.
772 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
774 DIDescriptor Enum(Elements.getElement(i));
775 if (Enum.isEnumerator()) {
776 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
777 Buffer.addChild(ElemDie);
782 case dwarf::DW_TAG_subroutine_type: {
784 DIArray Elements = CTy.getTypeArray();
785 DIDescriptor RTy = Elements.getElement(0);
786 addType(&Buffer, DIType(RTy));
788 bool isPrototyped = true;
790 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
791 DIDescriptor Ty = Elements.getElement(i);
792 if (Ty.isUnspecifiedParameter()) {
793 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
794 Buffer.addChild(Arg);
795 isPrototyped = false;
797 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
798 addType(Arg, DIType(Ty));
799 Buffer.addChild(Arg);
802 // Add prototype flag if we're dealing with a C language and the
803 // function has been prototyped.
805 (Language == dwarf::DW_LANG_C89 ||
806 Language == dwarf::DW_LANG_C99 ||
807 Language == dwarf::DW_LANG_ObjC))
808 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
811 case dwarf::DW_TAG_structure_type:
812 case dwarf::DW_TAG_union_type:
813 case dwarf::DW_TAG_class_type: {
814 // Add elements to structure type.
815 DIArray Elements = CTy.getTypeArray();
817 // A forward struct declared type may not have elements available.
818 unsigned N = Elements.getNumElements();
822 // Add elements to structure type.
823 for (unsigned i = 0; i < N; ++i) {
824 DIDescriptor Element = Elements.getElement(i);
826 if (Element.isSubprogram()) {
827 DISubprogram SP(Element);
828 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
829 if (SP.isProtected())
830 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
831 dwarf::DW_ACCESS_protected);
832 else if (SP.isPrivate())
833 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
834 dwarf::DW_ACCESS_private);
836 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
837 dwarf::DW_ACCESS_public);
839 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
841 else if (Element.isVariable()) {
842 DIVariable DV(Element);
843 ElemDie = new DIE(dwarf::DW_TAG_variable);
844 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
845 addType(ElemDie, DV.getType());
846 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
847 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
848 addSourceLine(ElemDie, DV);
849 } else if (Element.isDerivedType()) {
850 DIDerivedType DDTy(Element);
851 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
852 ElemDie = new DIE(dwarf::DW_TAG_friend);
853 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
855 ElemDie = createMemberDIE(DIDerivedType(Element));
856 } else if (Element.isObjCProperty()) {
857 DIObjCProperty Property(Element);
858 ElemDie = new DIE(Property.getTag());
859 StringRef PropertyName = Property.getObjCPropertyName();
860 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
861 addType(ElemDie, Property.getType());
862 addSourceLine(ElemDie, Property);
863 StringRef GetterName = Property.getObjCPropertyGetterName();
864 if (!GetterName.empty())
865 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
866 StringRef SetterName = Property.getObjCPropertySetterName();
867 if (!SetterName.empty())
868 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
869 unsigned PropertyAttributes = 0;
870 if (Property.isReadOnlyObjCProperty())
871 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
872 if (Property.isReadWriteObjCProperty())
873 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
874 if (Property.isAssignObjCProperty())
875 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
876 if (Property.isRetainObjCProperty())
877 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
878 if (Property.isCopyObjCProperty())
879 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
880 if (Property.isNonAtomicObjCProperty())
881 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
882 if (PropertyAttributes)
883 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
886 DIEEntry *Entry = getDIEEntry(Element);
888 Entry = createDIEEntry(ElemDie);
889 insertDIEEntry(Element, Entry);
893 Buffer.addChild(ElemDie);
896 if (CTy.isAppleBlockExtension())
897 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
899 DICompositeType ContainingType = CTy.getContainingType();
900 if (DIDescriptor(ContainingType).isCompositeType())
901 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
902 getOrCreateTypeDIE(DIType(ContainingType)));
904 DIDescriptor Context = CTy.getContext();
905 addToContextOwner(&Buffer, Context);
908 if (CTy.isObjcClassComplete())
909 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
910 dwarf::DW_FORM_flag, 1);
912 // Add template parameters to a class, structure or union types.
913 // FIXME: The support isn't in the metadata for this yet.
914 if (Tag == dwarf::DW_TAG_class_type ||
915 Tag == dwarf::DW_TAG_structure_type ||
916 Tag == dwarf::DW_TAG_union_type)
917 addTemplateParams(Buffer, CTy.getTemplateParams());
925 // Add name if not anonymous or intermediate type.
927 addString(&Buffer, dwarf::DW_AT_name, Name);
929 if (Tag == dwarf::DW_TAG_enumeration_type ||
930 Tag == dwarf::DW_TAG_class_type ||
931 Tag == dwarf::DW_TAG_structure_type ||
932 Tag == dwarf::DW_TAG_union_type) {
933 // Add size if non-zero (derived types might be zero-sized.)
935 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
937 // Add zero size if it is not a forward declaration.
938 if (CTy.isForwardDecl())
939 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
941 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
944 // Add source line info if available.
945 if (!CTy.isForwardDecl())
946 addSourceLine(&Buffer, CTy);
948 // No harm in adding the runtime language to the declaration.
949 unsigned RLang = CTy.getRunTimeLang();
951 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
952 dwarf::DW_FORM_data1, RLang);
956 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
957 /// for the given DITemplateTypeParameter.
959 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
960 DIE *ParamDIE = getDIE(TP);
964 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
965 addType(ParamDIE, TP.getType());
966 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
970 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
971 /// for the given DITemplateValueParameter.
973 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
974 DIE *ParamDIE = getDIE(TPV);
978 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
979 addType(ParamDIE, TPV.getType());
980 if (!TPV.getName().empty())
981 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
982 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
987 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
988 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
989 DIE *NDie = getDIE(NS);
992 NDie = new DIE(dwarf::DW_TAG_namespace);
994 if (!NS.getName().empty()) {
995 addString(NDie, dwarf::DW_AT_name, NS.getName());
996 addAccelNamespace(NS.getName(), NDie);
998 addAccelNamespace("(anonymous namespace)", NDie);
999 addSourceLine(NDie, NS);
1000 addToContextOwner(NDie, NS.getContext());
1004 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1005 /// printer to not emit usual symbol prefix before the symbol name is used then
1006 /// return linkage name after skipping this special LLVM prefix.
1007 static StringRef getRealLinkageName(StringRef LinkageName) {
1009 if (LinkageName.startswith(StringRef(&One, 1)))
1010 return LinkageName.substr(1);
1014 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1015 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1016 DIE *SPDie = getDIE(SP);
1020 DISubprogram SPDecl = SP.getFunctionDeclaration();
1021 DIE *DeclDie = NULL;
1022 if (SPDecl.isSubprogram()) {
1023 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1026 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1028 // DW_TAG_inlined_subroutine may refer to this DIE.
1029 insertDIE(SP, SPDie);
1031 // Add to context owner.
1032 addToContextOwner(SPDie, SP.getContext());
1034 // Add function template parameters.
1035 addTemplateParams(*SPDie, SP.getTemplateParams());
1037 // Unfortunately this code needs to stay here instead of below the
1038 // AT_specification code in order to work around a bug in older
1039 // gdbs that requires the linkage name to resolve multiple template
1041 StringRef LinkageName = SP.getLinkageName();
1042 if (!LinkageName.empty())
1043 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1044 getRealLinkageName(LinkageName));
1046 // If this DIE is going to refer declaration info using AT_specification
1047 // then there is no need to add other attributes.
1049 // Refer function declaration directly.
1050 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1056 // Constructors and operators for anonymous aggregates do not have names.
1057 if (!SP.getName().empty())
1058 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1060 addSourceLine(SPDie, SP);
1062 // Add the prototype if we have a prototype and we have a C like
1064 if (SP.isPrototyped() &&
1065 (Language == dwarf::DW_LANG_C89 ||
1066 Language == dwarf::DW_LANG_C99 ||
1067 Language == dwarf::DW_LANG_ObjC))
1068 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1071 DICompositeType SPTy = SP.getType();
1072 DIArray Args = SPTy.getTypeArray();
1073 unsigned SPTag = SPTy.getTag();
1075 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1076 addType(SPDie, SPTy);
1078 addType(SPDie, DIType(Args.getElement(0)));
1080 unsigned VK = SP.getVirtuality();
1082 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1083 DIEBlock *Block = getDIEBlock();
1084 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1085 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1086 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1087 ContainingTypeMap.insert(std::make_pair(SPDie,
1088 SP.getContainingType()));
1091 if (!SP.isDefinition()) {
1092 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1094 // Add arguments. Do not add arguments for subprogram definition. They will
1095 // be handled while processing variables.
1096 DICompositeType SPTy = SP.getType();
1097 DIArray Args = SPTy.getTypeArray();
1098 unsigned SPTag = SPTy.getTag();
1100 if (SPTag == dwarf::DW_TAG_subroutine_type)
1101 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1102 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1103 DIType ATy = DIType(DIType(Args.getElement(i)));
1105 if (ATy.isArtificial())
1106 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1107 SPDie->addChild(Arg);
1111 if (SP.isArtificial())
1112 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1114 if (!SP.isLocalToUnit())
1115 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1117 if (SP.isOptimized())
1118 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1120 if (unsigned isa = Asm->getISAEncoding()) {
1121 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1127 // Return const expression if value is a GEP to access merged global
1129 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1130 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1131 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1132 if (!CE || CE->getNumOperands() != 3 ||
1133 CE->getOpcode() != Instruction::GetElementPtr)
1136 // First operand points to a global struct.
1137 Value *Ptr = CE->getOperand(0);
1138 if (!isa<GlobalValue>(Ptr) ||
1139 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1142 // Second operand is zero.
1143 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1144 if (!CI || !CI->isZero())
1147 // Third operand is offset.
1148 if (!isa<ConstantInt>(CE->getOperand(2)))
1154 /// createGlobalVariableDIE - create global variable DIE.
1155 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1156 // Check for pre-existence.
1160 DIGlobalVariable GV(N);
1164 DIE *VariableDIE = new DIE(GV.getTag());
1166 insertDIE(N, VariableDIE);
1169 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1170 StringRef LinkageName = GV.getLinkageName();
1171 bool isGlobalVariable = GV.getGlobal() != NULL;
1172 if (!LinkageName.empty() && isGlobalVariable)
1173 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1174 getRealLinkageName(LinkageName));
1176 DIType GTy = GV.getType();
1177 addType(VariableDIE, GTy);
1179 // Add scoping info.
1180 if (!GV.isLocalToUnit())
1181 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1183 // Add line number info.
1184 addSourceLine(VariableDIE, GV);
1185 // Add to context owner.
1186 DIDescriptor GVContext = GV.getContext();
1187 addToContextOwner(VariableDIE, GVContext);
1189 bool addToAccelTable = false;
1190 DIE *VariableSpecDIE = NULL;
1191 if (isGlobalVariable) {
1192 addToAccelTable = true;
1193 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1194 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1195 addLabel(Block, 0, dwarf::DW_FORM_udata,
1196 Asm->Mang->getSymbol(GV.getGlobal()));
1197 // Do not create specification DIE if context is either compile unit
1199 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1200 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1201 // Create specification DIE.
1202 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1203 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1204 dwarf::DW_FORM_ref4, VariableDIE);
1205 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1206 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1208 addDie(VariableSpecDIE);
1210 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1212 } else if (const ConstantInt *CI =
1213 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1214 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1215 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1216 addToAccelTable = true;
1217 // GV is a merged global.
1218 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1219 Value *Ptr = CE->getOperand(0);
1220 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1221 addLabel(Block, 0, dwarf::DW_FORM_udata,
1222 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1223 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1224 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1225 addUInt(Block, 0, dwarf::DW_FORM_udata,
1226 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1227 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1228 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1231 if (addToAccelTable) {
1232 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1233 addAccelName(GV.getName(), AddrDIE);
1235 // If the linkage name is different than the name, go ahead and output
1236 // that as well into the name table.
1237 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1238 addAccelName(GV.getLinkageName(), AddrDIE);
1244 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1245 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1246 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1247 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1248 uint64_t L = SR.getLo();
1249 uint64_t H = SR.getHi();
1251 // The L value defines the lower bounds which is typically zero for C/C++. The
1252 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1253 // of the array. If L > H then do not emit DW_AT_lower_bound and
1254 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1255 // array has one element and in such case do not emit lower bound.
1258 Buffer.addChild(DW_Subrange);
1262 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1263 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1264 Buffer.addChild(DW_Subrange);
1267 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1268 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1269 DICompositeType *CTy) {
1270 Buffer.setTag(dwarf::DW_TAG_array_type);
1271 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1272 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1274 // Emit derived type.
1275 addType(&Buffer, CTy->getTypeDerivedFrom());
1276 DIArray Elements = CTy->getTypeArray();
1278 // Get an anonymous type for index type.
1279 DIE *IdxTy = getIndexTyDie();
1281 // Construct an anonymous type for index type.
1282 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1283 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1284 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1285 dwarf::DW_ATE_signed);
1287 setIndexTyDie(IdxTy);
1290 // Add subranges to array type.
1291 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1292 DIDescriptor Element = Elements.getElement(i);
1293 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1294 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1298 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1299 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1300 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1301 StringRef Name = ETy.getName();
1302 addString(Enumerator, dwarf::DW_AT_name, Name);
1303 int64_t Value = ETy.getEnumValue();
1304 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1308 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1310 void CompileUnit::constructContainingTypeDIEs() {
1311 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1312 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1313 DIE *SPDie = CI->first;
1314 const MDNode *N = CI->second;
1316 DIE *NDie = getDIE(N);
1317 if (!NDie) continue;
1318 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1322 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1323 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1324 StringRef Name = DV->getName();
1328 // Translate tag to proper Dwarf tag.
1329 unsigned Tag = DV->getTag();
1331 // Define variable debug information entry.
1332 DIE *VariableDie = new DIE(Tag);
1333 DbgVariable *AbsVar = DV->getAbstractVariable();
1334 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1336 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1337 dwarf::DW_FORM_ref4, AbsDIE);
1339 addString(VariableDie, dwarf::DW_AT_name, Name);
1340 addSourceLine(VariableDie, DV->getVariable());
1341 addType(VariableDie, DV->getType());
1344 if (DV->isArtificial())
1345 addUInt(VariableDie, dwarf::DW_AT_artificial,
1346 dwarf::DW_FORM_flag, 1);
1348 if (isScopeAbstract) {
1349 DV->setDIE(VariableDie);
1353 // Add variable address.
1355 unsigned Offset = DV->getDotDebugLocOffset();
1356 if (Offset != ~0U) {
1357 addLabel(VariableDie, dwarf::DW_AT_location,
1358 dwarf::DW_FORM_data4,
1359 Asm->GetTempSymbol("debug_loc", Offset));
1360 DV->setDIE(VariableDie);
1364 // Check if variable is described by a DBG_VALUE instruction.
1365 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1366 bool updated = false;
1367 if (DVInsn->getNumOperands() == 3) {
1368 if (DVInsn->getOperand(0).isReg()) {
1369 const MachineOperand RegOp = DVInsn->getOperand(0);
1370 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1371 if (DVInsn->getOperand(1).isImm() &&
1372 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1373 unsigned FrameReg = 0;
1374 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1376 TFI->getFrameIndexReference(*Asm->MF,
1377 DVInsn->getOperand(1).getImm(),
1379 MachineLocation Location(FrameReg, Offset);
1380 addVariableAddress(DV, VariableDie, Location);
1382 } else if (RegOp.getReg())
1383 addVariableAddress(DV, VariableDie,
1384 MachineLocation(RegOp.getReg()));
1387 else if (DVInsn->getOperand(0).isImm())
1389 addConstantValue(VariableDie, DVInsn->getOperand(0),
1391 else if (DVInsn->getOperand(0).isFPImm())
1393 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1394 else if (DVInsn->getOperand(0).isCImm())
1396 addConstantValue(VariableDie,
1397 DVInsn->getOperand(0).getCImm(),
1398 DV->getType().isUnsignedDIType());
1400 addVariableAddress(DV, VariableDie,
1401 Asm->getDebugValueLocation(DVInsn));
1405 // If variableDie is not updated then DBG_VALUE instruction does not
1406 // have valid variable info.
1410 DV->setDIE(VariableDie);
1413 // .. else use frame index.
1414 int FI = DV->getFrameIndex();
1416 unsigned FrameReg = 0;
1417 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1419 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1420 MachineLocation Location(FrameReg, Offset);
1421 addVariableAddress(DV, VariableDie, Location);
1425 DV->setDIE(VariableDie);
1429 /// createMemberDIE - Create new member DIE.
1430 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1431 DIE *MemberDie = new DIE(DT.getTag());
1432 StringRef Name = DT.getName();
1434 addString(MemberDie, dwarf::DW_AT_name, Name);
1436 addType(MemberDie, DT.getTypeDerivedFrom());
1438 addSourceLine(MemberDie, DT);
1440 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1441 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1443 uint64_t Size = DT.getSizeInBits();
1444 uint64_t FieldSize = DT.getOriginalTypeSize();
1446 if (Size != FieldSize) {
1448 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1449 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1451 uint64_t Offset = DT.getOffsetInBits();
1452 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1453 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1454 uint64_t FieldOffset = (HiMark - FieldSize);
1455 Offset -= FieldOffset;
1457 // Maybe we need to work from the other end.
1458 if (Asm->getTargetData().isLittleEndian())
1459 Offset = FieldSize - (Offset + Size);
1460 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1462 // Here WD_AT_data_member_location points to the anonymous
1463 // field that includes this bit field.
1464 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1467 // This is not a bitfield.
1468 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1470 if (DT.getTag() == dwarf::DW_TAG_inheritance
1471 && DT.isVirtual()) {
1473 // For C++, virtual base classes are not at fixed offset. Use following
1474 // expression to extract appropriate offset from vtable.
1475 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1477 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1478 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1479 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1480 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1481 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1482 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1483 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1484 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1486 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1489 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1491 if (DT.isProtected())
1492 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1493 dwarf::DW_ACCESS_protected);
1494 else if (DT.isPrivate())
1495 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1496 dwarf::DW_ACCESS_private);
1497 // Otherwise C++ member and base classes are considered public.
1499 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1500 dwarf::DW_ACCESS_public);
1502 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1503 dwarf::DW_VIRTUALITY_virtual);
1505 // Objective-C properties.
1506 if (MDNode *PNode = DT.getObjCProperty())
1507 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1508 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1511 // This is only for backward compatibility.
1512 StringRef PropertyName = DT.getObjCPropertyName();
1513 if (!PropertyName.empty()) {
1514 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1515 StringRef GetterName = DT.getObjCPropertyGetterName();
1516 if (!GetterName.empty())
1517 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1518 StringRef SetterName = DT.getObjCPropertySetterName();
1519 if (!SetterName.empty())
1520 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1521 unsigned PropertyAttributes = 0;
1522 if (DT.isReadOnlyObjCProperty())
1523 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1524 if (DT.isReadWriteObjCProperty())
1525 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1526 if (DT.isAssignObjCProperty())
1527 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1528 if (DT.isRetainObjCProperty())
1529 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1530 if (DT.isCopyObjCProperty())
1531 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1532 if (DT.isNonAtomicObjCProperty())
1533 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1534 if (PropertyAttributes)
1535 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1536 PropertyAttributes);