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 // Add template parameters to a class, structure or union types.
842 // FIXME: The support isn't in the metadata for this yet.
843 if (Tag == dwarf::DW_TAG_class_type ||
844 Tag == dwarf::DW_TAG_structure_type ||
845 Tag == dwarf::DW_TAG_union_type)
846 addTemplateParams(Buffer, CTy.getTemplateParams());
854 // Add name if not anonymous or intermediate type.
856 addString(&Buffer, dwarf::DW_AT_name, Name);
858 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
859 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
861 // Add size if non-zero (derived types might be zero-sized.)
863 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
865 // Add zero size if it is not a forward declaration.
866 if (CTy.isForwardDecl())
867 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
869 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
872 // Add source line info if available.
873 if (!CTy.isForwardDecl())
874 addSourceLine(&Buffer, CTy);
878 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
879 /// for the given DITemplateTypeParameter.
881 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
882 DIE *ParamDIE = getDIE(TP);
886 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
887 addType(ParamDIE, TP.getType());
888 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
892 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
893 /// for the given DITemplateValueParameter.
895 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
896 DIE *ParamDIE = getDIE(TPV);
900 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
901 addType(ParamDIE, TPV.getType());
902 if (!TPV.getName().empty())
903 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
904 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
909 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
910 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
911 DIE *NDie = getDIE(NS);
914 NDie = new DIE(dwarf::DW_TAG_namespace);
916 if (!NS.getName().empty()) {
917 addString(NDie, dwarf::DW_AT_name, NS.getName());
918 addAccelNamespace(NS.getName(), NDie);
920 addAccelNamespace("(anonymous namespace)", NDie);
921 addSourceLine(NDie, NS);
922 addToContextOwner(NDie, NS.getContext());
926 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
927 /// printer to not emit usual symbol prefix before the symbol name is used then
928 /// return linkage name after skipping this special LLVM prefix.
929 static StringRef getRealLinkageName(StringRef LinkageName) {
931 if (LinkageName.startswith(StringRef(&One, 1)))
932 return LinkageName.substr(1);
936 /// getOrCreateSubprogramDIE - Create new DIE using SP.
937 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
938 DIE *SPDie = getDIE(SP);
942 DISubprogram SPDecl = SP.getFunctionDeclaration();
944 if (SPDecl.isSubprogram()) {
945 DeclDie = getOrCreateSubprogramDIE(SPDecl);
948 SPDie = new DIE(dwarf::DW_TAG_subprogram);
950 // DW_TAG_inlined_subroutine may refer to this DIE.
951 insertDIE(SP, SPDie);
953 // Add to context owner.
954 addToContextOwner(SPDie, SP.getContext());
956 // Add function template parameters.
957 addTemplateParams(*SPDie, SP.getTemplateParams());
959 StringRef LinkageName = SP.getLinkageName();
960 if (!LinkageName.empty())
961 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
962 getRealLinkageName(LinkageName));
964 // If this DIE is going to refer declaration info using AT_specification
965 // then there is no need to add other attributes.
967 // Refer function declaration directly.
968 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
974 // Constructors and operators for anonymous aggregates do not have names.
975 if (!SP.getName().empty())
976 addString(SPDie, dwarf::DW_AT_name, SP.getName());
978 addSourceLine(SPDie, SP);
980 if (SP.isPrototyped())
981 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
984 DICompositeType SPTy = SP.getType();
985 DIArray Args = SPTy.getTypeArray();
986 unsigned SPTag = SPTy.getTag();
988 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
989 addType(SPDie, SPTy);
991 addType(SPDie, DIType(Args.getElement(0)));
993 unsigned VK = SP.getVirtuality();
995 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
996 DIEBlock *Block = getDIEBlock();
997 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
998 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
999 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1000 ContainingTypeMap.insert(std::make_pair(SPDie,
1001 SP.getContainingType()));
1004 if (!SP.isDefinition()) {
1005 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1007 // Add arguments. Do not add arguments for subprogram definition. They will
1008 // be handled while processing variables.
1009 DICompositeType SPTy = SP.getType();
1010 DIArray Args = SPTy.getTypeArray();
1011 unsigned SPTag = SPTy.getTag();
1013 if (SPTag == dwarf::DW_TAG_subroutine_type)
1014 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1015 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1016 DIType ATy = DIType(DIType(Args.getElement(i)));
1018 if (ATy.isArtificial())
1019 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1020 SPDie->addChild(Arg);
1024 if (SP.isArtificial())
1025 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1027 if (!SP.isLocalToUnit())
1028 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1030 if (SP.isOptimized())
1031 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1033 if (unsigned isa = Asm->getISAEncoding()) {
1034 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1040 // Return const expression if value is a GEP to access merged global
1042 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1043 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1044 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1045 if (!CE || CE->getNumOperands() != 3 ||
1046 CE->getOpcode() != Instruction::GetElementPtr)
1049 // First operand points to a global struct.
1050 Value *Ptr = CE->getOperand(0);
1051 if (!isa<GlobalValue>(Ptr) ||
1052 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1055 // Second operand is zero.
1056 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1057 if (!CI || !CI->isZero())
1060 // Third operand is offset.
1061 if (!isa<ConstantInt>(CE->getOperand(2)))
1067 /// createGlobalVariableDIE - create global variable DIE.
1068 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1069 // Check for pre-existence.
1073 DIGlobalVariable GV(N);
1077 DIE *VariableDIE = new DIE(GV.getTag());
1079 insertDIE(N, VariableDIE);
1082 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1083 StringRef LinkageName = GV.getLinkageName();
1084 bool isGlobalVariable = GV.getGlobal() != NULL;
1085 if (!LinkageName.empty() && isGlobalVariable)
1086 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1087 getRealLinkageName(LinkageName));
1089 DIType GTy = GV.getType();
1090 addType(VariableDIE, GTy);
1092 // Add scoping info.
1093 if (!GV.isLocalToUnit())
1094 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1096 // Add line number info.
1097 addSourceLine(VariableDIE, GV);
1098 // Add to context owner.
1099 DIDescriptor GVContext = GV.getContext();
1100 addToContextOwner(VariableDIE, GVContext);
1102 bool addToAccelTable = false;
1103 DIE *VariableSpecDIE = NULL;
1104 if (isGlobalVariable) {
1105 addToAccelTable = true;
1106 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1107 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1108 addLabel(Block, 0, dwarf::DW_FORM_udata,
1109 Asm->Mang->getSymbol(GV.getGlobal()));
1110 // Do not create specification DIE if context is either compile unit
1112 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1113 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1114 // Create specification DIE.
1115 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1116 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1117 dwarf::DW_FORM_ref4, VariableDIE);
1118 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1119 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1121 addDie(VariableSpecDIE);
1123 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1125 } else if (const ConstantInt *CI =
1126 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1127 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1128 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1129 addToAccelTable = true;
1130 // GV is a merged global.
1131 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1132 Value *Ptr = CE->getOperand(0);
1133 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1134 addLabel(Block, 0, dwarf::DW_FORM_udata,
1135 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1136 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1137 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1138 addUInt(Block, 0, dwarf::DW_FORM_udata,
1139 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1140 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1141 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1144 if (addToAccelTable) {
1145 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1146 addAccelName(GV.getName(), AddrDIE);
1148 // If the linkage name is different than the name, go ahead and output
1149 // that as well into the name table.
1150 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1151 addAccelName(GV.getLinkageName(), AddrDIE);
1157 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1158 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1159 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1160 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1161 uint64_t L = SR.getLo();
1162 uint64_t H = SR.getHi();
1164 // The L value defines the lower bounds which is typically zero for C/C++. The
1165 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1166 // of the array. If L > H then do not emit DW_AT_lower_bound and
1167 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1168 // array has one element and in such case do not emit lower bound.
1171 Buffer.addChild(DW_Subrange);
1175 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1176 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1177 Buffer.addChild(DW_Subrange);
1180 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1181 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1182 DICompositeType *CTy) {
1183 Buffer.setTag(dwarf::DW_TAG_array_type);
1184 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1185 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1187 // Emit derived type.
1188 addType(&Buffer, CTy->getTypeDerivedFrom());
1189 DIArray Elements = CTy->getTypeArray();
1191 // Get an anonymous type for index type.
1192 DIE *IdxTy = getIndexTyDie();
1194 // Construct an anonymous type for index type.
1195 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1196 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1197 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1198 dwarf::DW_ATE_signed);
1200 setIndexTyDie(IdxTy);
1203 // Add subranges to array type.
1204 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1205 DIDescriptor Element = Elements.getElement(i);
1206 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1207 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1211 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1212 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1213 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1214 StringRef Name = ETy.getName();
1215 addString(Enumerator, dwarf::DW_AT_name, Name);
1216 int64_t Value = ETy.getEnumValue();
1217 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1221 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1223 void CompileUnit::constructContainingTypeDIEs() {
1224 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1225 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1226 DIE *SPDie = CI->first;
1227 const MDNode *N = CI->second;
1229 DIE *NDie = getDIE(N);
1230 if (!NDie) continue;
1231 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1235 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1236 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1237 StringRef Name = DV->getName();
1241 // Translate tag to proper Dwarf tag.
1242 unsigned Tag = DV->getTag();
1244 // Define variable debug information entry.
1245 DIE *VariableDie = new DIE(Tag);
1246 DbgVariable *AbsVar = DV->getAbstractVariable();
1247 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1249 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1250 dwarf::DW_FORM_ref4, AbsDIE);
1252 addString(VariableDie, dwarf::DW_AT_name, Name);
1253 addSourceLine(VariableDie, DV->getVariable());
1254 addType(VariableDie, DV->getType());
1257 if (DV->isArtificial())
1258 addUInt(VariableDie, dwarf::DW_AT_artificial,
1259 dwarf::DW_FORM_flag, 1);
1261 if (isScopeAbstract) {
1262 DV->setDIE(VariableDie);
1266 // Add variable address.
1268 unsigned Offset = DV->getDotDebugLocOffset();
1269 if (Offset != ~0U) {
1270 addLabel(VariableDie, dwarf::DW_AT_location,
1271 dwarf::DW_FORM_data4,
1272 Asm->GetTempSymbol("debug_loc", Offset));
1273 DV->setDIE(VariableDie);
1277 // Check if variable is described by a DBG_VALUE instruction.
1278 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1279 bool updated = false;
1280 if (DVInsn->getNumOperands() == 3) {
1281 if (DVInsn->getOperand(0).isReg()) {
1282 const MachineOperand RegOp = DVInsn->getOperand(0);
1283 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1284 if (DVInsn->getOperand(1).isImm() &&
1285 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1286 unsigned FrameReg = 0;
1287 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1289 TFI->getFrameIndexReference(*Asm->MF,
1290 DVInsn->getOperand(1).getImm(),
1292 MachineLocation Location(FrameReg, Offset);
1293 addVariableAddress(DV, VariableDie, Location);
1295 } else if (RegOp.getReg())
1296 addVariableAddress(DV, VariableDie,
1297 MachineLocation(RegOp.getReg()));
1300 else if (DVInsn->getOperand(0).isImm())
1302 addConstantValue(VariableDie, DVInsn->getOperand(0),
1304 else if (DVInsn->getOperand(0).isFPImm())
1306 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1307 else if (DVInsn->getOperand(0).isCImm())
1309 addConstantValue(VariableDie,
1310 DVInsn->getOperand(0).getCImm(),
1311 DV->getType().isUnsignedDIType());
1313 addVariableAddress(DV, VariableDie,
1314 Asm->getDebugValueLocation(DVInsn));
1318 // If variableDie is not updated then DBG_VALUE instruction does not
1319 // have valid variable info.
1323 DV->setDIE(VariableDie);
1326 // .. else use frame index.
1327 int FI = DV->getFrameIndex();
1329 unsigned FrameReg = 0;
1330 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1332 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1333 MachineLocation Location(FrameReg, Offset);
1334 addVariableAddress(DV, VariableDie, Location);
1338 DV->setDIE(VariableDie);
1342 /// createMemberDIE - Create new member DIE.
1343 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1344 DIE *MemberDie = new DIE(DT.getTag());
1345 StringRef Name = DT.getName();
1347 addString(MemberDie, dwarf::DW_AT_name, Name);
1349 addType(MemberDie, DT.getTypeDerivedFrom());
1351 addSourceLine(MemberDie, DT);
1353 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1354 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1356 uint64_t Size = DT.getSizeInBits();
1357 uint64_t FieldSize = DT.getOriginalTypeSize();
1359 if (Size != FieldSize) {
1361 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1362 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1364 uint64_t Offset = DT.getOffsetInBits();
1365 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1366 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1367 uint64_t FieldOffset = (HiMark - FieldSize);
1368 Offset -= FieldOffset;
1370 // Maybe we need to work from the other end.
1371 if (Asm->getTargetData().isLittleEndian())
1372 Offset = FieldSize - (Offset + Size);
1373 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1375 // Here WD_AT_data_member_location points to the anonymous
1376 // field that includes this bit field.
1377 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1380 // This is not a bitfield.
1381 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1383 if (DT.getTag() == dwarf::DW_TAG_inheritance
1384 && DT.isVirtual()) {
1386 // For C++, virtual base classes are not at fixed offset. Use following
1387 // expression to extract appropriate offset from vtable.
1388 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1390 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1391 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1392 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1393 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1394 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1395 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1396 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1397 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1399 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1402 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1404 if (DT.isProtected())
1405 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1406 dwarf::DW_ACCESS_protected);
1407 else if (DT.isPrivate())
1408 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1409 dwarf::DW_ACCESS_private);
1410 // Otherwise C++ member and base classes are considered public.
1412 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1413 dwarf::DW_ACCESS_public);
1415 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1416 dwarf::DW_VIRTUALITY_virtual);
1418 // Objective-C properties.
1419 StringRef PropertyName = DT.getObjCPropertyName();
1420 if (!PropertyName.empty()) {
1421 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1422 StringRef GetterName = DT.getObjCPropertyGetterName();
1423 if (!GetterName.empty())
1424 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1425 StringRef SetterName = DT.getObjCPropertySetterName();
1426 if (!SetterName.empty())
1427 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1428 unsigned PropertyAttributes = 0;
1429 if (DT.isReadOnlyObjCProperty())
1430 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1431 if (DT.isReadWriteObjCProperty())
1432 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1433 if (DT.isAssignObjCProperty())
1434 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1435 if (DT.isRetainObjCProperty())
1436 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1437 if (DT.isCopyObjCProperty())
1438 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1439 if (DT.isNonAtomicObjCProperty())
1440 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1441 if (PropertyAttributes)
1442 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1443 PropertyAttributes);