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 "DwarfCompileUnit.h"
17 #include "DwarfDebug.h"
18 #include "llvm/Constants.h"
19 #include "llvm/GlobalVariable.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/Analysis/DIBuilder.h"
22 #include "llvm/Support/Debug.h"
23 #include "llvm/Target/Mangler.h"
24 #include "llvm/Target/TargetData.h"
25 #include "llvm/Target/TargetFrameLowering.h"
26 #include "llvm/Target/TargetMachine.h"
27 #include "llvm/Target/TargetRegisterInfo.h"
28 #include "llvm/ADT/APFloat.h"
29 #include "llvm/Support/ErrorHandling.h"
33 /// CompileUnit - Compile unit constructor.
34 CompileUnit::CompileUnit(unsigned I, DIE *D, AsmPrinter *A, DwarfDebug *DW)
35 : ID(I), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
36 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
39 /// ~CompileUnit - Destructor for compile unit.
40 CompileUnit::~CompileUnit() {
41 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
42 DIEBlocks[j]->~DIEBlock();
45 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
46 /// information entry.
47 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
48 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
52 /// addUInt - Add an unsigned integer attribute data and value.
54 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
55 unsigned Form, uint64_t Integer) {
56 if (!Form) Form = DIEInteger::BestForm(false, Integer);
57 DIEValue *Value = Integer == 1 ?
58 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
59 Die->addValue(Attribute, Form, Value);
62 /// addSInt - Add an signed integer attribute data and value.
64 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
65 unsigned Form, int64_t Integer) {
66 if (!Form) Form = DIEInteger::BestForm(true, Integer);
67 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
68 Die->addValue(Attribute, Form, Value);
71 /// addString - Add a string attribute data and value. We always emit a
72 /// reference to the string pool instead of immediate strings so that DIEs have
73 /// more predictable sizes.
74 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
75 MCSymbol *Symb = DD->getStringPoolEntry(String);
77 if (Asm->needsRelocationsForDwarfStringPool())
78 Value = new (DIEValueAllocator) DIELabel(Symb);
80 MCSymbol *StringPool = DD->getStringPool();
81 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
83 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
86 /// addLabel - Add a Dwarf label attribute data and value.
88 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
89 const MCSymbol *Label) {
90 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
91 Die->addValue(Attribute, Form, Value);
94 /// addDelta - Add a label delta attribute data and value.
96 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
97 const MCSymbol *Hi, const MCSymbol *Lo) {
98 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
99 Die->addValue(Attribute, Form, Value);
102 /// addDIEEntry - Add a DIE attribute data and value.
104 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
106 Die->addValue(Attribute, Form, createDIEEntry(Entry));
109 /// addBlock - Add block data.
111 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
113 Block->ComputeSize(Asm);
114 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
115 Die->addValue(Attribute, Block->BestForm(), Block);
118 /// addSourceLine - Add location information to specified debug information
120 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
125 unsigned Line = V.getLineNumber();
128 unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
129 V.getContext().getDirectory());
130 assert(FileID && "Invalid file id");
131 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
132 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
135 /// addSourceLine - Add location information to specified debug information
137 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
138 // Verify global variable.
142 unsigned Line = G.getLineNumber();
145 unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(), G.getDirectory());
146 assert(FileID && "Invalid file id");
147 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
148 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
151 /// addSourceLine - Add location information to specified debug information
153 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
154 // Verify subprogram.
157 // If the line number is 0, don't add it.
158 if (SP.getLineNumber() == 0)
161 unsigned Line = SP.getLineNumber();
162 if (!SP.getContext().Verify())
164 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
166 assert(FileID && "Invalid file id");
167 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
168 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
171 /// addSourceLine - Add location information to specified debug information
173 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
178 unsigned Line = Ty.getLineNumber();
179 if (Line == 0 || !Ty.getContext().Verify())
181 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
183 assert(FileID && "Invalid file id");
184 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
185 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
188 /// addSourceLine - Add location information to specified debug information
190 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
195 unsigned Line = NS.getLineNumber();
198 StringRef FN = NS.getFilename();
200 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
201 assert(FileID && "Invalid file id");
202 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
203 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
206 /// addVariableAddress - Add DW_AT_location attribute for a
207 /// DbgVariable based on provided MachineLocation.
208 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
209 MachineLocation Location) {
210 if (DV->variableHasComplexAddress())
211 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
212 else if (DV->isBlockByrefVariable())
213 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
215 addAddress(Die, dwarf::DW_AT_location, Location);
218 /// addRegisterOp - Add register operand.
219 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
220 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
221 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
223 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
225 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
226 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
230 /// addRegisterOffset - Add register offset.
231 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
233 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
234 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
235 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
236 if (Reg == TRI->getFrameRegister(*Asm->MF))
237 // If variable offset is based in frame register then use fbreg.
238 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
240 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
242 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
243 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
245 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
248 /// addAddress - Add an address attribute to a die based on the location
250 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
251 const MachineLocation &Location) {
252 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
254 if (Location.isReg())
255 addRegisterOp(Block, Location.getReg());
257 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
259 // Now attach the location information to the DIE.
260 addBlock(Die, Attribute, 0, Block);
263 /// addComplexAddress - Start with the address based on the location provided,
264 /// and generate the DWARF information necessary to find the actual variable
265 /// given the extra address information encoded in the DIVariable, starting from
266 /// the starting location. Add the DWARF information to the die.
268 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
270 const MachineLocation &Location) {
271 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
272 unsigned N = DV->getNumAddrElements();
274 if (Location.isReg()) {
275 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
276 // If first address element is OpPlus then emit
277 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
278 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
281 addRegisterOp(Block, Location.getReg());
284 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
287 uint64_t Element = DV->getAddrElement(i);
288 if (Element == DIBuilder::OpPlus) {
289 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
290 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
291 } else if (Element == DIBuilder::OpDeref) {
292 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
293 } else llvm_unreachable("unknown DIBuilder Opcode");
296 // Now attach the location information to the DIE.
297 addBlock(Die, Attribute, 0, Block);
300 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
301 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
302 gives the variable VarName either the struct, or a pointer to the struct, as
303 its type. This is necessary for various behind-the-scenes things the
304 compiler needs to do with by-reference variables in Blocks.
306 However, as far as the original *programmer* is concerned, the variable
307 should still have type 'SomeType', as originally declared.
309 The function getBlockByrefType dives into the __Block_byref_x_VarName
310 struct to find the original type of the variable, which is then assigned to
311 the variable's Debug Information Entry as its real type. So far, so good.
312 However now the debugger will expect the variable VarName to have the type
313 SomeType. So we need the location attribute for the variable to be an
314 expression that explains to the debugger how to navigate through the
315 pointers and struct to find the actual variable of type SomeType.
317 The following function does just that. We start by getting
318 the "normal" location for the variable. This will be the location
319 of either the struct __Block_byref_x_VarName or the pointer to the
320 struct __Block_byref_x_VarName.
322 The struct will look something like:
324 struct __Block_byref_x_VarName {
326 struct __Block_byref_x_VarName *forwarding;
327 ... <various other fields>
329 ... <maybe more fields>
332 If we are given the struct directly (as our starting point) we
333 need to tell the debugger to:
335 1). Add the offset of the forwarding field.
337 2). Follow that pointer to get the real __Block_byref_x_VarName
338 struct to use (the real one may have been copied onto the heap).
340 3). Add the offset for the field VarName, to find the actual variable.
342 If we started with a pointer to the struct, then we need to
343 dereference that pointer first, before the other steps.
344 Translating this into DWARF ops, we will need to append the following
345 to the current location description for the variable:
347 DW_OP_deref -- optional, if we start with a pointer
348 DW_OP_plus_uconst <forward_fld_offset>
350 DW_OP_plus_uconst <varName_fld_offset>
352 That is what this function does. */
354 /// addBlockByrefAddress - Start with the address based on the location
355 /// provided, and generate the DWARF information necessary to find the
356 /// actual Block variable (navigating the Block struct) based on the
357 /// starting location. Add the DWARF information to the die. For
358 /// more information, read large comment just above here.
360 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
362 const MachineLocation &Location) {
363 DIType Ty = DV->getType();
365 unsigned Tag = Ty.getTag();
366 bool isPointer = false;
368 StringRef varName = DV->getName();
370 if (Tag == dwarf::DW_TAG_pointer_type) {
371 DIDerivedType DTy = DIDerivedType(Ty);
372 TmpTy = DTy.getTypeDerivedFrom();
376 DICompositeType blockStruct = DICompositeType(TmpTy);
378 // Find the __forwarding field and the variable field in the __Block_byref
380 DIArray Fields = blockStruct.getTypeArray();
381 DIDescriptor varField = DIDescriptor();
382 DIDescriptor forwardingField = DIDescriptor();
384 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
385 DIDescriptor Element = Fields.getElement(i);
386 DIDerivedType DT = DIDerivedType(Element);
387 StringRef fieldName = DT.getName();
388 if (fieldName == "__forwarding")
389 forwardingField = Element;
390 else if (fieldName == varName)
394 // Get the offsets for the forwarding field and the variable field.
395 unsigned forwardingFieldOffset =
396 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
397 unsigned varFieldOffset =
398 DIDerivedType(varField).getOffsetInBits() >> 3;
400 // Decode the original location, and use that as the start of the byref
401 // variable's location.
402 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
403 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
404 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
406 if (Location.isReg()) {
408 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
410 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
411 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
415 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
417 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
418 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
421 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
424 // If we started with a pointer to the __Block_byref... struct, then
425 // the first thing we need to do is dereference the pointer (DW_OP_deref).
427 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
429 // Next add the offset for the '__forwarding' field:
430 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
431 // adding the offset if it's 0.
432 if (forwardingFieldOffset > 0) {
433 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
434 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
437 // Now dereference the __forwarding field to get to the real __Block_byref
438 // struct: DW_OP_deref.
439 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
441 // Now that we've got the real __Block_byref... struct, add the offset
442 // for the variable's field to get to the location of the actual variable:
443 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
444 if (varFieldOffset > 0) {
445 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
446 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
449 // Now attach the location information to the DIE.
450 addBlock(Die, Attribute, 0, Block);
453 /// isTypeSigned - Return true if the type is signed.
454 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
455 if (Ty.isDerivedType())
456 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
457 if (Ty.isBasicType())
458 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
459 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
460 *SizeInBits = Ty.getSizeInBits();
466 /// addConstantValue - Add constant value entry in variable DIE.
467 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
469 assert(MO.isImm() && "Invalid machine operand!");
470 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
472 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
473 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
474 switch (SizeInBits) {
475 case 8: Form = dwarf::DW_FORM_data1; break;
476 case 16: Form = dwarf::DW_FORM_data2; break;
477 case 32: Form = dwarf::DW_FORM_data4; break;
478 case 64: Form = dwarf::DW_FORM_data8; break;
481 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
482 : addUInt(Block, 0, Form, MO.getImm());
484 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
488 /// addConstantFPValue - Add constant value entry in variable DIE.
489 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
490 assert (MO.isFPImm() && "Invalid machine operand!");
491 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
492 APFloat FPImm = MO.getFPImm()->getValueAPF();
494 // Get the raw data form of the floating point.
495 const APInt FltVal = FPImm.bitcastToAPInt();
496 const char *FltPtr = (const char*)FltVal.getRawData();
498 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
499 bool LittleEndian = Asm->getTargetData().isLittleEndian();
500 int Incr = (LittleEndian ? 1 : -1);
501 int Start = (LittleEndian ? 0 : NumBytes - 1);
502 int Stop = (LittleEndian ? NumBytes : -1);
504 // Output the constant to DWARF one byte at a time.
505 for (; Start != Stop; Start += Incr)
506 addUInt(Block, 0, dwarf::DW_FORM_data1,
507 (unsigned char)0xFF & FltPtr[Start]);
509 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
513 /// addConstantValue - Add constant value entry in variable DIE.
514 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
516 unsigned CIBitWidth = CI->getBitWidth();
517 if (CIBitWidth <= 64) {
519 switch (CIBitWidth) {
520 case 8: form = dwarf::DW_FORM_data1; break;
521 case 16: form = dwarf::DW_FORM_data2; break;
522 case 32: form = dwarf::DW_FORM_data4; break;
523 case 64: form = dwarf::DW_FORM_data8; break;
525 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
528 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
530 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
534 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
536 // Get the raw data form of the large APInt.
537 const APInt Val = CI->getValue();
538 const uint64_t *Ptr64 = Val.getRawData();
540 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
541 bool LittleEndian = Asm->getTargetData().isLittleEndian();
543 // Output the constant to DWARF one byte at a time.
544 for (int i = 0; i < NumBytes; i++) {
547 c = Ptr64[i / 8] >> (8 * (i & 7));
549 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
550 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
553 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
557 /// addTemplateParams - Add template parameters in buffer.
558 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
559 // Add template parameters.
560 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
561 DIDescriptor Element = TParams.getElement(i);
562 if (Element.isTemplateTypeParameter())
563 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
564 DITemplateTypeParameter(Element)));
565 else if (Element.isTemplateValueParameter())
566 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
567 DITemplateValueParameter(Element)));
571 /// addToContextOwner - Add Die into the list of its context owner's children.
572 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
573 if (Context.isType()) {
574 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
575 ContextDIE->addChild(Die);
576 } else if (Context.isNameSpace()) {
577 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
578 ContextDIE->addChild(Die);
579 } else if (Context.isSubprogram()) {
580 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
581 ContextDIE->addChild(Die);
582 } else if (DIE *ContextDIE = getDIE(Context))
583 ContextDIE->addChild(Die);
588 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
590 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
594 DIE *TyDIE = getDIE(Ty);
599 TyDIE = new DIE(dwarf::DW_TAG_base_type);
600 insertDIE(Ty, TyDIE);
601 if (Ty.isBasicType())
602 constructTypeDIE(*TyDIE, DIBasicType(Ty));
603 else if (Ty.isCompositeType())
604 constructTypeDIE(*TyDIE, DICompositeType(Ty));
606 assert(Ty.isDerivedType() && "Unknown kind of DIType");
607 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
609 // If this is a named finished type then include it in the list of types
610 // for the accelerator tables.
611 if (!Ty.getName().empty() && !Ty.isForwardDecl())
612 addAccelType(Ty.getName(), TyDIE);
614 addToContextOwner(TyDIE, Ty.getContext());
618 /// addType - Add a new type attribute to the specified entity.
619 void CompileUnit::addType(DIE *Entity, DIType Ty) {
623 // Check for pre-existence.
624 DIEEntry *Entry = getDIEEntry(Ty);
625 // If it exists then use the existing value.
627 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
632 DIE *Buffer = getOrCreateTypeDIE(Ty);
635 Entry = createDIEEntry(Buffer);
636 insertDIEEntry(Ty, Entry);
637 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
639 // If this is a complete composite type then include it in the
640 // list of global types.
644 /// addGlobalType - Add a new global type to the compile unit.
646 void CompileUnit::addGlobalType(DIType Ty) {
647 DIDescriptor Context = Ty.getContext();
648 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
649 && (!Context || Context.isCompileUnit() || Context.isFile()
650 || Context.isNameSpace()))
651 if (DIEEntry *Entry = getDIEEntry(Ty))
652 GlobalTypes[Ty.getName()] = Entry->getEntry();
655 /// addPubTypes - Add type for pubtypes section.
656 void CompileUnit::addPubTypes(DISubprogram SP) {
657 DICompositeType SPTy = SP.getType();
658 unsigned SPTag = SPTy.getTag();
659 if (SPTag != dwarf::DW_TAG_subroutine_type)
662 DIArray Args = SPTy.getTypeArray();
663 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
664 DIType ATy(Args.getElement(i));
671 /// constructTypeDIE - Construct basic type die from DIBasicType.
672 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
673 // Get core information.
674 StringRef Name = BTy.getName();
675 // Add name if not anonymous or intermediate type.
677 addString(&Buffer, dwarf::DW_AT_name, Name);
679 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
680 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
681 // Unspecified types has only name, nothing else.
685 Buffer.setTag(dwarf::DW_TAG_base_type);
686 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
689 uint64_t Size = BTy.getSizeInBits() >> 3;
690 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
693 /// constructTypeDIE - Construct derived type die from DIDerivedType.
694 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
695 // Get core information.
696 StringRef Name = DTy.getName();
697 uint64_t Size = DTy.getSizeInBits() >> 3;
698 unsigned Tag = DTy.getTag();
700 // FIXME - Workaround for templates.
701 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
705 // Map to main type, void will not have a type.
706 DIType FromTy = DTy.getTypeDerivedFrom();
707 addType(&Buffer, FromTy);
709 // Add name if not anonymous or intermediate type.
711 addString(&Buffer, dwarf::DW_AT_name, Name);
713 // Add size if non-zero (derived types might be zero-sized.)
715 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
717 // Add source line info if available and TyDesc is not a forward declaration.
718 if (!DTy.isForwardDecl())
719 addSourceLine(&Buffer, DTy);
722 /// constructTypeDIE - Construct type DIE from DICompositeType.
723 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
724 // Get core information.
725 StringRef Name = CTy.getName();
727 uint64_t Size = CTy.getSizeInBits() >> 3;
728 unsigned Tag = CTy.getTag();
732 case dwarf::DW_TAG_vector_type:
733 case dwarf::DW_TAG_array_type:
734 constructArrayTypeDIE(Buffer, &CTy);
736 case dwarf::DW_TAG_enumeration_type: {
737 DIArray Elements = CTy.getTypeArray();
739 // Add enumerators to enumeration type.
740 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
742 DIDescriptor Enum(Elements.getElement(i));
743 if (Enum.isEnumerator()) {
744 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
745 Buffer.addChild(ElemDie);
750 case dwarf::DW_TAG_subroutine_type: {
752 DIArray Elements = CTy.getTypeArray();
753 DIDescriptor RTy = Elements.getElement(0);
754 addType(&Buffer, DIType(RTy));
756 bool isPrototyped = true;
758 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
759 DIDescriptor Ty = Elements.getElement(i);
760 if (Ty.isUnspecifiedParameter()) {
761 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
762 Buffer.addChild(Arg);
763 isPrototyped = false;
765 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
766 addType(Arg, DIType(Ty));
767 Buffer.addChild(Arg);
770 // Add prototype flag.
772 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
775 case dwarf::DW_TAG_structure_type:
776 case dwarf::DW_TAG_union_type:
777 case dwarf::DW_TAG_class_type: {
778 // Add elements to structure type.
779 DIArray Elements = CTy.getTypeArray();
781 // A forward struct declared type may not have elements available.
782 unsigned N = Elements.getNumElements();
786 // Add elements to structure type.
787 for (unsigned i = 0; i < N; ++i) {
788 DIDescriptor Element = Elements.getElement(i);
790 if (Element.isSubprogram()) {
791 DISubprogram SP(Element);
792 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
793 if (SP.isProtected())
794 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
795 dwarf::DW_ACCESS_protected);
796 else if (SP.isPrivate())
797 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
798 dwarf::DW_ACCESS_private);
800 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
801 dwarf::DW_ACCESS_public);
803 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
805 else if (Element.isVariable()) {
806 DIVariable DV(Element);
807 ElemDie = new DIE(dwarf::DW_TAG_variable);
808 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
809 addType(ElemDie, DV.getType());
810 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
811 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
812 addSourceLine(ElemDie, DV);
813 } else if (Element.isDerivedType())
814 ElemDie = createMemberDIE(DIDerivedType(Element));
817 Buffer.addChild(ElemDie);
820 if (CTy.isAppleBlockExtension())
821 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
823 unsigned RLang = CTy.getRunTimeLang();
825 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
826 dwarf::DW_FORM_data1, RLang);
828 DICompositeType ContainingType = CTy.getContainingType();
829 if (DIDescriptor(ContainingType).isCompositeType())
830 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
831 getOrCreateTypeDIE(DIType(ContainingType)));
833 DIDescriptor Context = CTy.getContext();
834 addToContextOwner(&Buffer, Context);
837 if (CTy.isObjcClassComplete())
838 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
839 dwarf::DW_FORM_flag, 1);
841 if (Tag == dwarf::DW_TAG_class_type)
842 addTemplateParams(Buffer, CTy.getTemplateParams());
850 // Add name if not anonymous or intermediate type.
852 addString(&Buffer, dwarf::DW_AT_name, Name);
854 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
855 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
857 // Add size if non-zero (derived types might be zero-sized.)
859 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
861 // Add zero size if it is not a forward declaration.
862 if (CTy.isForwardDecl())
863 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
865 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
868 // Add source line info if available.
869 if (!CTy.isForwardDecl())
870 addSourceLine(&Buffer, CTy);
874 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
875 /// for the given DITemplateTypeParameter.
877 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
878 DIE *ParamDIE = getDIE(TP);
882 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
883 addType(ParamDIE, TP.getType());
884 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
888 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
889 /// for the given DITemplateValueParameter.
891 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
892 DIE *ParamDIE = getDIE(TPV);
896 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
897 addType(ParamDIE, TPV.getType());
898 if (!TPV.getName().empty())
899 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
900 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
905 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
906 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
907 DIE *NDie = getDIE(NS);
910 NDie = new DIE(dwarf::DW_TAG_namespace);
912 if (!NS.getName().empty()) {
913 addString(NDie, dwarf::DW_AT_name, NS.getName());
914 addAccelNamespace(NS.getName(), NDie);
916 addAccelNamespace("(anonymous namespace)", NDie);
917 addSourceLine(NDie, NS);
918 addToContextOwner(NDie, NS.getContext());
922 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
923 /// printer to not emit usual symbol prefix before the symbol name is used then
924 /// return linkage name after skipping this special LLVM prefix.
925 static StringRef getRealLinkageName(StringRef LinkageName) {
927 if (LinkageName.startswith(StringRef(&One, 1)))
928 return LinkageName.substr(1);
932 /// getOrCreateSubprogramDIE - Create new DIE using SP.
933 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
934 DIE *SPDie = getDIE(SP);
938 DISubprogram SPDecl = SP.getFunctionDeclaration();
940 if (SPDecl.isSubprogram()) {
941 DeclDie = getOrCreateSubprogramDIE(SPDecl);
944 SPDie = new DIE(dwarf::DW_TAG_subprogram);
946 // DW_TAG_inlined_subroutine may refer to this DIE.
947 insertDIE(SP, SPDie);
949 // Add to context owner.
950 addToContextOwner(SPDie, SP.getContext());
952 // Add function template parameters.
953 addTemplateParams(*SPDie, SP.getTemplateParams());
955 StringRef LinkageName = SP.getLinkageName();
956 if (!LinkageName.empty())
957 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
958 getRealLinkageName(LinkageName));
960 // If this DIE is going to refer declaration info using AT_specification
961 // then there is no need to add other attributes.
963 // Refer function declaration directly.
964 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
970 // Constructors and operators for anonymous aggregates do not have names.
971 if (!SP.getName().empty())
972 addString(SPDie, dwarf::DW_AT_name, SP.getName());
974 addSourceLine(SPDie, SP);
976 if (SP.isPrototyped())
977 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
980 DICompositeType SPTy = SP.getType();
981 DIArray Args = SPTy.getTypeArray();
982 unsigned SPTag = SPTy.getTag();
984 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
985 addType(SPDie, SPTy);
987 addType(SPDie, DIType(Args.getElement(0)));
989 unsigned VK = SP.getVirtuality();
991 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
992 DIEBlock *Block = getDIEBlock();
993 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
994 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
995 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
996 ContainingTypeMap.insert(std::make_pair(SPDie,
997 SP.getContainingType()));
1000 if (!SP.isDefinition()) {
1001 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1003 // Add arguments. Do not add arguments for subprogram definition. They will
1004 // be handled while processing variables.
1005 DICompositeType SPTy = SP.getType();
1006 DIArray Args = SPTy.getTypeArray();
1007 unsigned SPTag = SPTy.getTag();
1009 if (SPTag == dwarf::DW_TAG_subroutine_type)
1010 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1011 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1012 DIType ATy = DIType(DIType(Args.getElement(i)));
1014 if (ATy.isArtificial())
1015 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1016 SPDie->addChild(Arg);
1020 if (SP.isArtificial())
1021 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1023 if (!SP.isLocalToUnit())
1024 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1026 if (SP.isOptimized())
1027 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1029 if (unsigned isa = Asm->getISAEncoding()) {
1030 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1036 // Return const expression if value is a GEP to access merged global
1038 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1039 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1040 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1041 if (!CE || CE->getNumOperands() != 3 ||
1042 CE->getOpcode() != Instruction::GetElementPtr)
1045 // First operand points to a global struct.
1046 Value *Ptr = CE->getOperand(0);
1047 if (!isa<GlobalValue>(Ptr) ||
1048 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1051 // Second operand is zero.
1052 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1053 if (!CI || !CI->isZero())
1056 // Third operand is offset.
1057 if (!isa<ConstantInt>(CE->getOperand(2)))
1063 /// createGlobalVariableDIE - create global variable DIE.
1064 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1065 // Check for pre-existence.
1069 DIGlobalVariable GV(N);
1073 DIE *VariableDIE = new DIE(GV.getTag());
1075 insertDIE(N, VariableDIE);
1078 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1079 StringRef LinkageName = GV.getLinkageName();
1080 bool isGlobalVariable = GV.getGlobal() != NULL;
1081 if (!LinkageName.empty() && isGlobalVariable)
1082 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1083 getRealLinkageName(LinkageName));
1085 DIType GTy = GV.getType();
1086 addType(VariableDIE, GTy);
1088 // Add scoping info.
1089 if (!GV.isLocalToUnit())
1090 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1092 // Add line number info.
1093 addSourceLine(VariableDIE, GV);
1094 // Add to context owner.
1095 DIDescriptor GVContext = GV.getContext();
1096 addToContextOwner(VariableDIE, GVContext);
1098 bool addToAccelTable = false;
1099 DIE *VariableSpecDIE = NULL;
1100 if (isGlobalVariable) {
1101 addToAccelTable = true;
1102 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1103 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1104 addLabel(Block, 0, dwarf::DW_FORM_udata,
1105 Asm->Mang->getSymbol(GV.getGlobal()));
1106 // Do not create specification DIE if context is either compile unit
1108 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1109 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1110 // Create specification DIE.
1111 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1112 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1113 dwarf::DW_FORM_ref4, VariableDIE);
1114 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1115 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1117 addDie(VariableSpecDIE);
1119 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1121 } else if (const ConstantInt *CI =
1122 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1123 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1124 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1125 addToAccelTable = true;
1126 // GV is a merged global.
1127 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1128 Value *Ptr = CE->getOperand(0);
1129 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1130 addLabel(Block, 0, dwarf::DW_FORM_udata,
1131 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1132 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1133 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1134 addUInt(Block, 0, dwarf::DW_FORM_udata,
1135 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1136 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1137 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1140 if (addToAccelTable) {
1141 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1142 addAccelName(GV.getName(), AddrDIE);
1144 // If the linkage name is different than the name, go ahead and output
1145 // that as well into the name table.
1146 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1147 addAccelName(GV.getLinkageName(), AddrDIE);
1153 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1154 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1155 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1156 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1157 uint64_t L = SR.getLo();
1158 uint64_t H = SR.getHi();
1160 // The L value defines the lower bounds which is typically zero for C/C++. The
1161 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1162 // of the array. If L > H then do not emit DW_AT_lower_bound and
1163 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1164 // array has one element and in such case do not emit lower bound.
1167 Buffer.addChild(DW_Subrange);
1171 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1172 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1173 Buffer.addChild(DW_Subrange);
1176 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1177 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1178 DICompositeType *CTy) {
1179 Buffer.setTag(dwarf::DW_TAG_array_type);
1180 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1181 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1183 // Emit derived type.
1184 addType(&Buffer, CTy->getTypeDerivedFrom());
1185 DIArray Elements = CTy->getTypeArray();
1187 // Get an anonymous type for index type.
1188 DIE *IdxTy = getIndexTyDie();
1190 // Construct an anonymous type for index type.
1191 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1192 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1193 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1194 dwarf::DW_ATE_signed);
1196 setIndexTyDie(IdxTy);
1199 // Add subranges to array type.
1200 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1201 DIDescriptor Element = Elements.getElement(i);
1202 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1203 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1207 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1208 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1209 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1210 StringRef Name = ETy.getName();
1211 addString(Enumerator, dwarf::DW_AT_name, Name);
1212 int64_t Value = ETy.getEnumValue();
1213 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1217 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1219 void CompileUnit::constructContainingTypeDIEs() {
1220 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1221 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1222 DIE *SPDie = CI->first;
1223 const MDNode *N = CI->second;
1225 DIE *NDie = getDIE(N);
1226 if (!NDie) continue;
1227 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1231 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1232 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1233 StringRef Name = DV->getName();
1237 // Translate tag to proper Dwarf tag.
1238 unsigned Tag = DV->getTag();
1240 // Define variable debug information entry.
1241 DIE *VariableDie = new DIE(Tag);
1242 DbgVariable *AbsVar = DV->getAbstractVariable();
1243 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1245 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1246 dwarf::DW_FORM_ref4, AbsDIE);
1248 addString(VariableDie, dwarf::DW_AT_name, Name);
1249 addSourceLine(VariableDie, DV->getVariable());
1250 addType(VariableDie, DV->getType());
1253 if (DV->isArtificial())
1254 addUInt(VariableDie, dwarf::DW_AT_artificial,
1255 dwarf::DW_FORM_flag, 1);
1257 if (isScopeAbstract) {
1258 DV->setDIE(VariableDie);
1262 // Add variable address.
1264 unsigned Offset = DV->getDotDebugLocOffset();
1265 if (Offset != ~0U) {
1266 addLabel(VariableDie, dwarf::DW_AT_location,
1267 dwarf::DW_FORM_data4,
1268 Asm->GetTempSymbol("debug_loc", Offset));
1269 DV->setDIE(VariableDie);
1273 // Check if variable is described by a DBG_VALUE instruction.
1274 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1275 bool updated = false;
1276 if (DVInsn->getNumOperands() == 3) {
1277 if (DVInsn->getOperand(0).isReg()) {
1278 const MachineOperand RegOp = DVInsn->getOperand(0);
1279 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1280 if (DVInsn->getOperand(1).isImm() &&
1281 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1282 unsigned FrameReg = 0;
1283 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1285 TFI->getFrameIndexReference(*Asm->MF,
1286 DVInsn->getOperand(1).getImm(),
1288 MachineLocation Location(FrameReg, Offset);
1289 addVariableAddress(DV, VariableDie, Location);
1291 } else if (RegOp.getReg())
1292 addVariableAddress(DV, VariableDie,
1293 MachineLocation(RegOp.getReg()));
1296 else if (DVInsn->getOperand(0).isImm())
1298 addConstantValue(VariableDie, DVInsn->getOperand(0),
1300 else if (DVInsn->getOperand(0).isFPImm())
1302 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1303 else if (DVInsn->getOperand(0).isCImm())
1305 addConstantValue(VariableDie,
1306 DVInsn->getOperand(0).getCImm(),
1307 DV->getType().isUnsignedDIType());
1309 addVariableAddress(DV, VariableDie,
1310 Asm->getDebugValueLocation(DVInsn));
1314 // If variableDie is not updated then DBG_VALUE instruction does not
1315 // have valid variable info.
1319 DV->setDIE(VariableDie);
1322 // .. else use frame index.
1323 int FI = DV->getFrameIndex();
1325 unsigned FrameReg = 0;
1326 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1328 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1329 MachineLocation Location(FrameReg, Offset);
1330 addVariableAddress(DV, VariableDie, Location);
1334 DV->setDIE(VariableDie);
1338 /// createMemberDIE - Create new member DIE.
1339 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1340 DIE *MemberDie = new DIE(DT.getTag());
1341 StringRef Name = DT.getName();
1343 addString(MemberDie, dwarf::DW_AT_name, Name);
1345 addType(MemberDie, DT.getTypeDerivedFrom());
1347 addSourceLine(MemberDie, DT);
1349 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1350 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1352 uint64_t Size = DT.getSizeInBits();
1353 uint64_t FieldSize = DT.getOriginalTypeSize();
1355 if (Size != FieldSize) {
1357 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1358 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1360 uint64_t Offset = DT.getOffsetInBits();
1361 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1362 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1363 uint64_t FieldOffset = (HiMark - FieldSize);
1364 Offset -= FieldOffset;
1366 // Maybe we need to work from the other end.
1367 if (Asm->getTargetData().isLittleEndian())
1368 Offset = FieldSize - (Offset + Size);
1369 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1371 // Here WD_AT_data_member_location points to the anonymous
1372 // field that includes this bit field.
1373 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1376 // This is not a bitfield.
1377 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1379 if (DT.getTag() == dwarf::DW_TAG_inheritance
1380 && DT.isVirtual()) {
1382 // For C++, virtual base classes are not at fixed offset. Use following
1383 // expression to extract appropriate offset from vtable.
1384 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1386 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1387 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1388 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1389 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1390 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1391 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1392 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1393 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1395 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1398 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1400 if (DT.isProtected())
1401 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1402 dwarf::DW_ACCESS_protected);
1403 else if (DT.isPrivate())
1404 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1405 dwarf::DW_ACCESS_private);
1406 // Otherwise C++ member and base classes are considered public.
1408 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1409 dwarf::DW_ACCESS_public);
1411 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1412 dwarf::DW_VIRTUALITY_virtual);
1414 // Objective-C properties.
1415 StringRef PropertyName = DT.getObjCPropertyName();
1416 if (!PropertyName.empty()) {
1417 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1418 StringRef GetterName = DT.getObjCPropertyGetterName();
1419 if (!GetterName.empty())
1420 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1421 StringRef SetterName = DT.getObjCPropertySetterName();
1422 if (!SetterName.empty())
1423 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1424 unsigned PropertyAttributes = 0;
1425 if (DT.isReadOnlyObjCProperty())
1426 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1427 if (DT.isReadWriteObjCProperty())
1428 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1429 if (DT.isAssignObjCProperty())
1430 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1431 if (DT.isRetainObjCProperty())
1432 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1433 if (DT.isCopyObjCProperty())
1434 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1435 if (DT.isNonAtomicObjCProperty())
1436 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1437 if (PropertyAttributes)
1438 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1439 PropertyAttributes);