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 // FIXME: a structure type can have template params too.
842 if (Tag == dwarf::DW_TAG_class_type)
843 addTemplateParams(Buffer, CTy.getTemplateParams());
851 // Add name if not anonymous or intermediate type.
853 addString(&Buffer, dwarf::DW_AT_name, Name);
855 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
856 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
858 // Add size if non-zero (derived types might be zero-sized.)
860 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
862 // Add zero size if it is not a forward declaration.
863 if (CTy.isForwardDecl())
864 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
866 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
869 // Add source line info if available.
870 if (!CTy.isForwardDecl())
871 addSourceLine(&Buffer, CTy);
875 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
876 /// for the given DITemplateTypeParameter.
878 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
879 DIE *ParamDIE = getDIE(TP);
883 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
884 addType(ParamDIE, TP.getType());
885 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
889 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
890 /// for the given DITemplateValueParameter.
892 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
893 DIE *ParamDIE = getDIE(TPV);
897 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
898 addType(ParamDIE, TPV.getType());
899 if (!TPV.getName().empty())
900 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
901 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
906 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
907 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
908 DIE *NDie = getDIE(NS);
911 NDie = new DIE(dwarf::DW_TAG_namespace);
913 if (!NS.getName().empty()) {
914 addString(NDie, dwarf::DW_AT_name, NS.getName());
915 addAccelNamespace(NS.getName(), NDie);
917 addAccelNamespace("(anonymous namespace)", NDie);
918 addSourceLine(NDie, NS);
919 addToContextOwner(NDie, NS.getContext());
923 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
924 /// printer to not emit usual symbol prefix before the symbol name is used then
925 /// return linkage name after skipping this special LLVM prefix.
926 static StringRef getRealLinkageName(StringRef LinkageName) {
928 if (LinkageName.startswith(StringRef(&One, 1)))
929 return LinkageName.substr(1);
933 /// getOrCreateSubprogramDIE - Create new DIE using SP.
934 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
935 DIE *SPDie = getDIE(SP);
939 DISubprogram SPDecl = SP.getFunctionDeclaration();
941 if (SPDecl.isSubprogram()) {
942 DeclDie = getOrCreateSubprogramDIE(SPDecl);
945 SPDie = new DIE(dwarf::DW_TAG_subprogram);
947 // DW_TAG_inlined_subroutine may refer to this DIE.
948 insertDIE(SP, SPDie);
950 // Add to context owner.
951 addToContextOwner(SPDie, SP.getContext());
953 // Add function template parameters.
954 addTemplateParams(*SPDie, SP.getTemplateParams());
956 StringRef LinkageName = SP.getLinkageName();
957 if (!LinkageName.empty())
958 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
959 getRealLinkageName(LinkageName));
961 // If this DIE is going to refer declaration info using AT_specification
962 // then there is no need to add other attributes.
964 // Refer function declaration directly.
965 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
971 // Constructors and operators for anonymous aggregates do not have names.
972 if (!SP.getName().empty())
973 addString(SPDie, dwarf::DW_AT_name, SP.getName());
975 addSourceLine(SPDie, SP);
977 if (SP.isPrototyped())
978 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
981 DICompositeType SPTy = SP.getType();
982 DIArray Args = SPTy.getTypeArray();
983 unsigned SPTag = SPTy.getTag();
985 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
986 addType(SPDie, SPTy);
988 addType(SPDie, DIType(Args.getElement(0)));
990 unsigned VK = SP.getVirtuality();
992 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
993 DIEBlock *Block = getDIEBlock();
994 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
995 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
996 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
997 ContainingTypeMap.insert(std::make_pair(SPDie,
998 SP.getContainingType()));
1001 if (!SP.isDefinition()) {
1002 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1004 // Add arguments. Do not add arguments for subprogram definition. They will
1005 // be handled while processing variables.
1006 DICompositeType SPTy = SP.getType();
1007 DIArray Args = SPTy.getTypeArray();
1008 unsigned SPTag = SPTy.getTag();
1010 if (SPTag == dwarf::DW_TAG_subroutine_type)
1011 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1012 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1013 DIType ATy = DIType(DIType(Args.getElement(i)));
1015 if (ATy.isArtificial())
1016 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1017 SPDie->addChild(Arg);
1021 if (SP.isArtificial())
1022 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1024 if (!SP.isLocalToUnit())
1025 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1027 if (SP.isOptimized())
1028 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1030 if (unsigned isa = Asm->getISAEncoding()) {
1031 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1037 // Return const expression if value is a GEP to access merged global
1039 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1040 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1041 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1042 if (!CE || CE->getNumOperands() != 3 ||
1043 CE->getOpcode() != Instruction::GetElementPtr)
1046 // First operand points to a global struct.
1047 Value *Ptr = CE->getOperand(0);
1048 if (!isa<GlobalValue>(Ptr) ||
1049 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1052 // Second operand is zero.
1053 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1054 if (!CI || !CI->isZero())
1057 // Third operand is offset.
1058 if (!isa<ConstantInt>(CE->getOperand(2)))
1064 /// createGlobalVariableDIE - create global variable DIE.
1065 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1066 // Check for pre-existence.
1070 DIGlobalVariable GV(N);
1074 DIE *VariableDIE = new DIE(GV.getTag());
1076 insertDIE(N, VariableDIE);
1079 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1080 StringRef LinkageName = GV.getLinkageName();
1081 bool isGlobalVariable = GV.getGlobal() != NULL;
1082 if (!LinkageName.empty() && isGlobalVariable)
1083 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1084 getRealLinkageName(LinkageName));
1086 DIType GTy = GV.getType();
1087 addType(VariableDIE, GTy);
1089 // Add scoping info.
1090 if (!GV.isLocalToUnit())
1091 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1093 // Add line number info.
1094 addSourceLine(VariableDIE, GV);
1095 // Add to context owner.
1096 DIDescriptor GVContext = GV.getContext();
1097 addToContextOwner(VariableDIE, GVContext);
1099 bool addToAccelTable = false;
1100 DIE *VariableSpecDIE = NULL;
1101 if (isGlobalVariable) {
1102 addToAccelTable = true;
1103 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1104 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1105 addLabel(Block, 0, dwarf::DW_FORM_udata,
1106 Asm->Mang->getSymbol(GV.getGlobal()));
1107 // Do not create specification DIE if context is either compile unit
1109 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1110 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1111 // Create specification DIE.
1112 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1113 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1114 dwarf::DW_FORM_ref4, VariableDIE);
1115 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1116 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1118 addDie(VariableSpecDIE);
1120 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1122 } else if (const ConstantInt *CI =
1123 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1124 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1125 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1126 addToAccelTable = true;
1127 // GV is a merged global.
1128 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1129 Value *Ptr = CE->getOperand(0);
1130 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1131 addLabel(Block, 0, dwarf::DW_FORM_udata,
1132 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1133 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1134 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1135 addUInt(Block, 0, dwarf::DW_FORM_udata,
1136 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1137 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1138 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1141 if (addToAccelTable) {
1142 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1143 addAccelName(GV.getName(), AddrDIE);
1145 // If the linkage name is different than the name, go ahead and output
1146 // that as well into the name table.
1147 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1148 addAccelName(GV.getLinkageName(), AddrDIE);
1154 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1155 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1156 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1157 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1158 uint64_t L = SR.getLo();
1159 uint64_t H = SR.getHi();
1161 // The L value defines the lower bounds which is typically zero for C/C++. The
1162 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1163 // of the array. If L > H then do not emit DW_AT_lower_bound and
1164 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1165 // array has one element and in such case do not emit lower bound.
1168 Buffer.addChild(DW_Subrange);
1172 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1173 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1174 Buffer.addChild(DW_Subrange);
1177 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1178 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1179 DICompositeType *CTy) {
1180 Buffer.setTag(dwarf::DW_TAG_array_type);
1181 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1182 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1184 // Emit derived type.
1185 addType(&Buffer, CTy->getTypeDerivedFrom());
1186 DIArray Elements = CTy->getTypeArray();
1188 // Get an anonymous type for index type.
1189 DIE *IdxTy = getIndexTyDie();
1191 // Construct an anonymous type for index type.
1192 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1193 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1194 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1195 dwarf::DW_ATE_signed);
1197 setIndexTyDie(IdxTy);
1200 // Add subranges to array type.
1201 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1202 DIDescriptor Element = Elements.getElement(i);
1203 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1204 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1208 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1209 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1210 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1211 StringRef Name = ETy.getName();
1212 addString(Enumerator, dwarf::DW_AT_name, Name);
1213 int64_t Value = ETy.getEnumValue();
1214 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1218 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1220 void CompileUnit::constructContainingTypeDIEs() {
1221 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1222 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1223 DIE *SPDie = CI->first;
1224 const MDNode *N = CI->second;
1226 DIE *NDie = getDIE(N);
1227 if (!NDie) continue;
1228 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1232 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1233 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1234 StringRef Name = DV->getName();
1238 // Translate tag to proper Dwarf tag.
1239 unsigned Tag = DV->getTag();
1241 // Define variable debug information entry.
1242 DIE *VariableDie = new DIE(Tag);
1243 DbgVariable *AbsVar = DV->getAbstractVariable();
1244 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1246 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1247 dwarf::DW_FORM_ref4, AbsDIE);
1249 addString(VariableDie, dwarf::DW_AT_name, Name);
1250 addSourceLine(VariableDie, DV->getVariable());
1251 addType(VariableDie, DV->getType());
1254 if (DV->isArtificial())
1255 addUInt(VariableDie, dwarf::DW_AT_artificial,
1256 dwarf::DW_FORM_flag, 1);
1258 if (isScopeAbstract) {
1259 DV->setDIE(VariableDie);
1263 // Add variable address.
1265 unsigned Offset = DV->getDotDebugLocOffset();
1266 if (Offset != ~0U) {
1267 addLabel(VariableDie, dwarf::DW_AT_location,
1268 dwarf::DW_FORM_data4,
1269 Asm->GetTempSymbol("debug_loc", Offset));
1270 DV->setDIE(VariableDie);
1274 // Check if variable is described by a DBG_VALUE instruction.
1275 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1276 bool updated = false;
1277 if (DVInsn->getNumOperands() == 3) {
1278 if (DVInsn->getOperand(0).isReg()) {
1279 const MachineOperand RegOp = DVInsn->getOperand(0);
1280 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1281 if (DVInsn->getOperand(1).isImm() &&
1282 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1283 unsigned FrameReg = 0;
1284 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1286 TFI->getFrameIndexReference(*Asm->MF,
1287 DVInsn->getOperand(1).getImm(),
1289 MachineLocation Location(FrameReg, Offset);
1290 addVariableAddress(DV, VariableDie, Location);
1292 } else if (RegOp.getReg())
1293 addVariableAddress(DV, VariableDie,
1294 MachineLocation(RegOp.getReg()));
1297 else if (DVInsn->getOperand(0).isImm())
1299 addConstantValue(VariableDie, DVInsn->getOperand(0),
1301 else if (DVInsn->getOperand(0).isFPImm())
1303 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1304 else if (DVInsn->getOperand(0).isCImm())
1306 addConstantValue(VariableDie,
1307 DVInsn->getOperand(0).getCImm(),
1308 DV->getType().isUnsignedDIType());
1310 addVariableAddress(DV, VariableDie,
1311 Asm->getDebugValueLocation(DVInsn));
1315 // If variableDie is not updated then DBG_VALUE instruction does not
1316 // have valid variable info.
1320 DV->setDIE(VariableDie);
1323 // .. else use frame index.
1324 int FI = DV->getFrameIndex();
1326 unsigned FrameReg = 0;
1327 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1329 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1330 MachineLocation Location(FrameReg, Offset);
1331 addVariableAddress(DV, VariableDie, Location);
1335 DV->setDIE(VariableDie);
1339 /// createMemberDIE - Create new member DIE.
1340 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1341 DIE *MemberDie = new DIE(DT.getTag());
1342 StringRef Name = DT.getName();
1344 addString(MemberDie, dwarf::DW_AT_name, Name);
1346 addType(MemberDie, DT.getTypeDerivedFrom());
1348 addSourceLine(MemberDie, DT);
1350 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1351 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1353 uint64_t Size = DT.getSizeInBits();
1354 uint64_t FieldSize = DT.getOriginalTypeSize();
1356 if (Size != FieldSize) {
1358 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1359 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1361 uint64_t Offset = DT.getOffsetInBits();
1362 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1363 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1364 uint64_t FieldOffset = (HiMark - FieldSize);
1365 Offset -= FieldOffset;
1367 // Maybe we need to work from the other end.
1368 if (Asm->getTargetData().isLittleEndian())
1369 Offset = FieldSize - (Offset + Size);
1370 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1372 // Here WD_AT_data_member_location points to the anonymous
1373 // field that includes this bit field.
1374 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1377 // This is not a bitfield.
1378 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1380 if (DT.getTag() == dwarf::DW_TAG_inheritance
1381 && DT.isVirtual()) {
1383 // For C++, virtual base classes are not at fixed offset. Use following
1384 // expression to extract appropriate offset from vtable.
1385 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1387 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1388 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1389 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1390 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1391 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1392 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1393 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1394 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1396 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1399 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1401 if (DT.isProtected())
1402 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1403 dwarf::DW_ACCESS_protected);
1404 else if (DT.isPrivate())
1405 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1406 dwarf::DW_ACCESS_private);
1407 // Otherwise C++ member and base classes are considered public.
1409 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1410 dwarf::DW_ACCESS_public);
1412 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1413 dwarf::DW_VIRTUALITY_virtual);
1415 // Objective-C properties.
1416 StringRef PropertyName = DT.getObjCPropertyName();
1417 if (!PropertyName.empty()) {
1418 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1419 StringRef GetterName = DT.getObjCPropertyGetterName();
1420 if (!GetterName.empty())
1421 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1422 StringRef SetterName = DT.getObjCPropertySetterName();
1423 if (!SetterName.empty())
1424 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1425 unsigned PropertyAttributes = 0;
1426 if (DT.isReadOnlyObjCProperty())
1427 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1428 if (DT.isReadWriteObjCProperty())
1429 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1430 if (DT.isAssignObjCProperty())
1431 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1432 if (DT.isRetainObjCProperty())
1433 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1434 if (DT.isCopyObjCProperty())
1435 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1436 if (DT.isNonAtomicObjCProperty())
1437 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1438 if (PropertyAttributes)
1439 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1440 PropertyAttributes);