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/Target/Mangler.h"
23 #include "llvm/Target/TargetData.h"
24 #include "llvm/Target/TargetFrameLowering.h"
25 #include "llvm/Target/TargetMachine.h"
26 #include "llvm/Target/TargetRegisterInfo.h"
27 #include "llvm/ADT/APFloat.h"
28 #include "llvm/Support/ErrorHandling.h"
32 /// CompileUnit - Compile unit constructor.
33 CompileUnit::CompileUnit(unsigned I, DIE *D, AsmPrinter *A, DwarfDebug *DW)
34 : ID(I), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
35 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
38 /// ~CompileUnit - Destructor for compile unit.
39 CompileUnit::~CompileUnit() {
40 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
41 DIEBlocks[j]->~DIEBlock();
44 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
45 /// information entry.
46 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
47 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
51 /// addUInt - Add an unsigned integer attribute data and value.
53 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
54 unsigned Form, uint64_t Integer) {
55 if (!Form) Form = DIEInteger::BestForm(false, Integer);
56 DIEValue *Value = Integer == 1 ?
57 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
58 Die->addValue(Attribute, Form, Value);
61 /// addSInt - Add an signed integer attribute data and value.
63 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
64 unsigned Form, int64_t Integer) {
65 if (!Form) Form = DIEInteger::BestForm(true, Integer);
66 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
67 Die->addValue(Attribute, Form, Value);
70 /// addString - Add a string attribute data and value. DIEString only
71 /// keeps string reference.
72 void CompileUnit::addString(DIE *Die, unsigned Attribute, unsigned Form,
74 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
75 Die->addValue(Attribute, Form, Value);
78 /// addLabel - Add a Dwarf label attribute data and value.
80 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
81 const MCSymbol *Label) {
82 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
83 Die->addValue(Attribute, Form, Value);
86 /// addDelta - Add a label delta attribute data and value.
88 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
89 const MCSymbol *Hi, const MCSymbol *Lo) {
90 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
91 Die->addValue(Attribute, Form, Value);
94 /// addDIEEntry - Add a DIE attribute data and value.
96 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
98 Die->addValue(Attribute, Form, createDIEEntry(Entry));
102 /// addBlock - Add block data.
104 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
106 Block->ComputeSize(Asm);
107 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
108 Die->addValue(Attribute, Block->BestForm(), Block);
111 /// addSourceLine - Add location information to specified debug information
113 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
118 unsigned Line = V.getLineNumber();
121 unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
122 V.getContext().getDirectory());
123 assert(FileID && "Invalid file id");
124 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
125 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
128 /// addSourceLine - Add location information to specified debug information
130 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
131 // Verify global variable.
135 unsigned Line = G.getLineNumber();
138 unsigned FileID = DD->GetOrCreateSourceID(G.getContext().getFilename(),
139 G.getContext().getDirectory());
140 assert(FileID && "Invalid file id");
141 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
142 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
145 /// addSourceLine - Add location information to specified debug information
147 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
148 // Verify subprogram.
151 // If the line number is 0, don't add it.
152 if (SP.getLineNumber() == 0)
155 unsigned Line = SP.getLineNumber();
156 if (!SP.getContext().Verify())
158 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(), SP.getDirectory());
159 assert(FileID && "Invalid file id");
160 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
161 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
164 /// addSourceLine - Add location information to specified debug information
166 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
171 unsigned Line = Ty.getLineNumber();
172 if (Line == 0 || !Ty.getContext().Verify())
174 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(), Ty.getDirectory());
175 assert(FileID && "Invalid file id");
176 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
177 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
180 /// addSourceLine - Add location information to specified debug information
182 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
187 unsigned Line = NS.getLineNumber();
190 StringRef FN = NS.getFilename();
192 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
193 assert(FileID && "Invalid file id");
194 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
195 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
198 /// addVariableAddress - Add DW_AT_location attribute for a
199 /// DbgVariable based on provided MachineLocation.
200 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
201 MachineLocation Location) {
202 if (DV->variableHasComplexAddress())
203 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
204 else if (DV->isBlockByrefVariable())
205 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
207 addAddress(Die, dwarf::DW_AT_location, Location);
210 /// addRegisterOp - Add register operand.
211 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
212 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
213 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
215 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
217 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
218 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
222 /// addRegisterOffset - Add register offset.
223 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
225 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
226 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
227 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
228 if (Reg == TRI->getFrameRegister(*Asm->MF))
229 // If variable offset is based in frame register then use fbreg.
230 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
232 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
234 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
235 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
237 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
240 /// addAddress - Add an address attribute to a die based on the location
242 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
243 const MachineLocation &Location) {
244 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
246 if (Location.isReg())
247 addRegisterOp(Block, Location.getReg());
249 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
251 // Now attach the location information to the DIE.
252 addBlock(Die, Attribute, 0, Block);
255 /// addComplexAddress - Start with the address based on the location provided,
256 /// and generate the DWARF information necessary to find the actual variable
257 /// given the extra address information encoded in the DIVariable, starting from
258 /// the starting location. Add the DWARF information to the die.
260 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
262 const MachineLocation &Location) {
263 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
264 unsigned N = DV->getNumAddrElements();
266 if (Location.isReg()) {
267 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
268 // If first address element is OpPlus then emit
269 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
270 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
273 addRegisterOp(Block, Location.getReg());
276 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
279 uint64_t Element = DV->getAddrElement(i);
280 if (Element == DIBuilder::OpPlus) {
281 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
282 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
283 } else if (Element == DIBuilder::OpDeref) {
284 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
285 } else llvm_unreachable("unknown DIBuilder Opcode");
288 // Now attach the location information to the DIE.
289 addBlock(Die, Attribute, 0, Block);
292 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
293 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
294 gives the variable VarName either the struct, or a pointer to the struct, as
295 its type. This is necessary for various behind-the-scenes things the
296 compiler needs to do with by-reference variables in Blocks.
298 However, as far as the original *programmer* is concerned, the variable
299 should still have type 'SomeType', as originally declared.
301 The function getBlockByrefType dives into the __Block_byref_x_VarName
302 struct to find the original type of the variable, which is then assigned to
303 the variable's Debug Information Entry as its real type. So far, so good.
304 However now the debugger will expect the variable VarName to have the type
305 SomeType. So we need the location attribute for the variable to be an
306 expression that explains to the debugger how to navigate through the
307 pointers and struct to find the actual variable of type SomeType.
309 The following function does just that. We start by getting
310 the "normal" location for the variable. This will be the location
311 of either the struct __Block_byref_x_VarName or the pointer to the
312 struct __Block_byref_x_VarName.
314 The struct will look something like:
316 struct __Block_byref_x_VarName {
318 struct __Block_byref_x_VarName *forwarding;
319 ... <various other fields>
321 ... <maybe more fields>
324 If we are given the struct directly (as our starting point) we
325 need to tell the debugger to:
327 1). Add the offset of the forwarding field.
329 2). Follow that pointer to get the real __Block_byref_x_VarName
330 struct to use (the real one may have been copied onto the heap).
332 3). Add the offset for the field VarName, to find the actual variable.
334 If we started with a pointer to the struct, then we need to
335 dereference that pointer first, before the other steps.
336 Translating this into DWARF ops, we will need to append the following
337 to the current location description for the variable:
339 DW_OP_deref -- optional, if we start with a pointer
340 DW_OP_plus_uconst <forward_fld_offset>
342 DW_OP_plus_uconst <varName_fld_offset>
344 That is what this function does. */
346 /// addBlockByrefAddress - Start with the address based on the location
347 /// provided, and generate the DWARF information necessary to find the
348 /// actual Block variable (navigating the Block struct) based on the
349 /// starting location. Add the DWARF information to the die. For
350 /// more information, read large comment just above here.
352 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
354 const MachineLocation &Location) {
355 DIType Ty = DV->getType();
357 unsigned Tag = Ty.getTag();
358 bool isPointer = false;
360 StringRef varName = DV->getName();
362 if (Tag == dwarf::DW_TAG_pointer_type) {
363 DIDerivedType DTy = DIDerivedType(Ty);
364 TmpTy = DTy.getTypeDerivedFrom();
368 DICompositeType blockStruct = DICompositeType(TmpTy);
370 // Find the __forwarding field and the variable field in the __Block_byref
372 DIArray Fields = blockStruct.getTypeArray();
373 DIDescriptor varField = DIDescriptor();
374 DIDescriptor forwardingField = DIDescriptor();
376 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
377 DIDescriptor Element = Fields.getElement(i);
378 DIDerivedType DT = DIDerivedType(Element);
379 StringRef fieldName = DT.getName();
380 if (fieldName == "__forwarding")
381 forwardingField = Element;
382 else if (fieldName == varName)
386 // Get the offsets for the forwarding field and the variable field.
387 unsigned forwardingFieldOffset =
388 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
389 unsigned varFieldOffset =
390 DIDerivedType(varField).getOffsetInBits() >> 3;
392 // Decode the original location, and use that as the start of the byref
393 // variable's location.
394 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
395 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
396 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
398 if (Location.isReg()) {
400 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
402 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
403 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
407 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
409 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
410 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
413 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
416 // If we started with a pointer to the __Block_byref... struct, then
417 // the first thing we need to do is dereference the pointer (DW_OP_deref).
419 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
421 // Next add the offset for the '__forwarding' field:
422 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
423 // adding the offset if it's 0.
424 if (forwardingFieldOffset > 0) {
425 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
426 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
429 // Now dereference the __forwarding field to get to the real __Block_byref
430 // struct: DW_OP_deref.
431 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
433 // Now that we've got the real __Block_byref... struct, add the offset
434 // for the variable's field to get to the location of the actual variable:
435 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
436 if (varFieldOffset > 0) {
437 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
438 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
441 // Now attach the location information to the DIE.
442 addBlock(Die, Attribute, 0, Block);
445 /// isTypeSigned - Return true if the type is signed.
446 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
447 if (Ty.isDerivedType())
448 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
449 if (Ty.isBasicType())
450 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
451 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
452 *SizeInBits = Ty.getSizeInBits();
458 /// addConstantValue - Add constant value entry in variable DIE.
459 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
461 assert (MO.isImm() && "Invalid machine operand!");
462 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
464 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
465 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
466 switch (SizeInBits) {
467 case 8: Form = dwarf::DW_FORM_data1; break;
468 case 16: Form = dwarf::DW_FORM_data2; break;
469 case 32: Form = dwarf::DW_FORM_data4; break;
470 case 64: Form = dwarf::DW_FORM_data8; break;
473 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
474 : addUInt(Block, 0, Form, MO.getImm());
476 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
480 /// addConstantFPValue - Add constant value entry in variable DIE.
481 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
482 assert (MO.isFPImm() && "Invalid machine operand!");
483 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
484 APFloat FPImm = MO.getFPImm()->getValueAPF();
486 // Get the raw data form of the floating point.
487 const APInt FltVal = FPImm.bitcastToAPInt();
488 const char *FltPtr = (const char*)FltVal.getRawData();
490 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
491 bool LittleEndian = Asm->getTargetData().isLittleEndian();
492 int Incr = (LittleEndian ? 1 : -1);
493 int Start = (LittleEndian ? 0 : NumBytes - 1);
494 int Stop = (LittleEndian ? NumBytes : -1);
496 // Output the constant to DWARF one byte at a time.
497 for (; Start != Stop; Start += Incr)
498 addUInt(Block, 0, dwarf::DW_FORM_data1,
499 (unsigned char)0xFF & FltPtr[Start]);
501 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
505 /// addConstantValue - Add constant value entry in variable DIE.
506 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
508 unsigned CIBitWidth = CI->getBitWidth();
509 if (CIBitWidth <= 64) {
511 switch (CIBitWidth) {
512 case 8: form = dwarf::DW_FORM_data1; break;
513 case 16: form = dwarf::DW_FORM_data2; break;
514 case 32: form = dwarf::DW_FORM_data4; break;
515 case 64: form = dwarf::DW_FORM_data8; break;
517 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
520 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
522 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
526 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
528 // Get the raw data form of the large APInt.
529 const APInt Val = CI->getValue();
530 const char *Ptr = (const char*)Val.getRawData();
532 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
533 bool LittleEndian = Asm->getTargetData().isLittleEndian();
534 int Incr = (LittleEndian ? 1 : -1);
535 int Start = (LittleEndian ? 0 : NumBytes - 1);
536 int Stop = (LittleEndian ? NumBytes : -1);
538 // Output the constant to DWARF one byte at a time.
539 for (; Start != Stop; Start += Incr)
540 addUInt(Block, 0, dwarf::DW_FORM_data1,
541 (unsigned char)0xFF & Ptr[Start]);
543 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
547 /// addTemplateParams - Add template parameters in buffer.
548 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
549 // Add template parameters.
550 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
551 DIDescriptor Element = TParams.getElement(i);
552 if (Element.isTemplateTypeParameter())
553 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
554 DITemplateTypeParameter(Element)));
555 else if (Element.isTemplateValueParameter())
556 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
557 DITemplateValueParameter(Element)));
561 /// addToContextOwner - Add Die into the list of its context owner's children.
562 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
563 if (Context.isType()) {
564 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
565 ContextDIE->addChild(Die);
566 } else if (Context.isNameSpace()) {
567 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
568 ContextDIE->addChild(Die);
569 } else if (Context.isSubprogram()) {
570 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
571 ContextDIE->addChild(Die);
572 } else if (DIE *ContextDIE = getDIE(Context))
573 ContextDIE->addChild(Die);
578 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
580 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
584 DIE *TyDIE = getDIE(Ty);
589 TyDIE = new DIE(dwarf::DW_TAG_base_type);
590 insertDIE(Ty, TyDIE);
591 if (Ty.isBasicType())
592 constructTypeDIE(*TyDIE, DIBasicType(Ty));
593 else if (Ty.isCompositeType())
594 constructTypeDIE(*TyDIE, DICompositeType(Ty));
596 assert(Ty.isDerivedType() && "Unknown kind of DIType");
597 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
600 addToContextOwner(TyDIE, Ty.getContext());
604 /// addType - Add a new type attribute to the specified entity.
605 void CompileUnit::addType(DIE *Entity, DIType Ty) {
609 // Check for pre-existence.
610 DIEEntry *Entry = getDIEEntry(Ty);
611 // If it exists then use the existing value.
613 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
618 DIE *Buffer = getOrCreateTypeDIE(Ty);
621 Entry = createDIEEntry(Buffer);
622 insertDIEEntry(Ty, Entry);
623 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
625 // If this is a complete composite type then include it in the
626 // list of global types.
630 /// addGlobalType - Add a new global type to the compile unit.
632 void CompileUnit::addGlobalType(DIType Ty) {
633 DIDescriptor Context = Ty.getContext();
634 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
635 && (!Context || Context.isCompileUnit() || Context.isFile()
636 || Context.isNameSpace()))
637 if (DIEEntry *Entry = getDIEEntry(Ty))
638 GlobalTypes[Ty.getName()] = Entry->getEntry();
641 /// addPubTypes - Add type for pubtypes section.
642 void CompileUnit::addPubTypes(DISubprogram SP) {
643 DICompositeType SPTy = SP.getType();
644 unsigned SPTag = SPTy.getTag();
645 if (SPTag != dwarf::DW_TAG_subroutine_type)
648 DIArray Args = SPTy.getTypeArray();
649 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
650 DIType ATy(Args.getElement(i));
657 /// constructTypeDIE - Construct basic type die from DIBasicType.
658 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
659 // Get core information.
660 StringRef Name = BTy.getName();
661 Buffer.setTag(dwarf::DW_TAG_base_type);
662 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
665 // Add name if not anonymous or intermediate type.
667 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
668 uint64_t Size = BTy.getSizeInBits() >> 3;
669 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
672 /// constructTypeDIE - Construct derived type die from DIDerivedType.
673 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
674 // Get core information.
675 StringRef Name = DTy.getName();
676 uint64_t Size = DTy.getSizeInBits() >> 3;
677 unsigned Tag = DTy.getTag();
679 // FIXME - Workaround for templates.
680 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
684 // Map to main type, void will not have a type.
685 DIType FromTy = DTy.getTypeDerivedFrom();
686 addType(&Buffer, FromTy);
688 // Add name if not anonymous or intermediate type.
690 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
692 // Add size if non-zero (derived types might be zero-sized.)
694 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
696 // Add source line info if available and TyDesc is not a forward declaration.
697 if (!DTy.isForwardDecl())
698 addSourceLine(&Buffer, DTy);
701 /// constructTypeDIE - Construct type DIE from DICompositeType.
702 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
703 // Get core information.
704 StringRef Name = CTy.getName();
706 uint64_t Size = CTy.getSizeInBits() >> 3;
707 unsigned Tag = CTy.getTag();
711 case dwarf::DW_TAG_vector_type:
712 case dwarf::DW_TAG_array_type:
713 constructArrayTypeDIE(Buffer, &CTy);
715 case dwarf::DW_TAG_enumeration_type: {
716 DIArray Elements = CTy.getTypeArray();
718 // Add enumerators to enumeration type.
719 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
721 DIDescriptor Enum(Elements.getElement(i));
722 if (Enum.isEnumerator()) {
723 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
724 Buffer.addChild(ElemDie);
729 case dwarf::DW_TAG_subroutine_type: {
731 DIArray Elements = CTy.getTypeArray();
732 DIDescriptor RTy = Elements.getElement(0);
733 addType(&Buffer, DIType(RTy));
735 bool isPrototyped = true;
737 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
738 DIDescriptor Ty = Elements.getElement(i);
739 if (Ty.isUnspecifiedParameter()) {
740 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
741 Buffer.addChild(Arg);
742 isPrototyped = false;
744 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
745 addType(Arg, DIType(Ty));
746 Buffer.addChild(Arg);
749 // Add prototype flag.
751 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
754 case dwarf::DW_TAG_structure_type:
755 case dwarf::DW_TAG_union_type:
756 case dwarf::DW_TAG_class_type: {
757 // Add elements to structure type.
758 DIArray Elements = CTy.getTypeArray();
760 // A forward struct declared type may not have elements available.
761 unsigned N = Elements.getNumElements();
765 // Add elements to structure type.
766 for (unsigned i = 0; i < N; ++i) {
767 DIDescriptor Element = Elements.getElement(i);
769 if (Element.isSubprogram()) {
770 DISubprogram SP(Element);
771 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
772 if (SP.isProtected())
773 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
774 dwarf::DW_ACCESS_protected);
775 else if (SP.isPrivate())
776 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
777 dwarf::DW_ACCESS_private);
779 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
780 dwarf::DW_ACCESS_public);
782 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
784 else if (Element.isVariable()) {
785 DIVariable DV(Element);
786 ElemDie = new DIE(dwarf::DW_TAG_variable);
787 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
789 addType(ElemDie, DV.getType());
790 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
791 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
792 addSourceLine(ElemDie, DV);
793 } else if (Element.isDerivedType())
794 ElemDie = createMemberDIE(DIDerivedType(Element));
797 Buffer.addChild(ElemDie);
800 if (CTy.isAppleBlockExtension())
801 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
803 unsigned RLang = CTy.getRunTimeLang();
805 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
806 dwarf::DW_FORM_data1, RLang);
808 DICompositeType ContainingType = CTy.getContainingType();
809 if (DIDescriptor(ContainingType).isCompositeType())
810 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
811 getOrCreateTypeDIE(DIType(ContainingType)));
813 DIDescriptor Context = CTy.getContext();
814 addToContextOwner(&Buffer, Context);
817 if (CTy.isObjcClassComplete())
818 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
819 dwarf::DW_FORM_flag, 1);
821 if (Tag == dwarf::DW_TAG_class_type)
822 addTemplateParams(Buffer, CTy.getTemplateParams());
830 // Add name if not anonymous or intermediate type.
832 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
834 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
835 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
837 // Add size if non-zero (derived types might be zero-sized.)
839 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
841 // Add zero size if it is not a forward declaration.
842 if (CTy.isForwardDecl())
843 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
845 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
848 // Add source line info if available.
849 if (!CTy.isForwardDecl())
850 addSourceLine(&Buffer, CTy);
854 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
855 /// for the given DITemplateTypeParameter.
857 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
858 DIE *ParamDIE = getDIE(TP);
862 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
863 addType(ParamDIE, TP.getType());
864 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
868 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
869 /// for the given DITemplateValueParameter.
871 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
872 DIE *ParamDIE = getDIE(TPV);
876 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
877 addType(ParamDIE, TPV.getType());
878 if (!TPV.getName().empty())
879 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
880 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
885 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
886 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
887 DIE *NDie = getDIE(NS);
890 NDie = new DIE(dwarf::DW_TAG_namespace);
892 if (!NS.getName().empty())
893 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
894 addSourceLine(NDie, NS);
895 addToContextOwner(NDie, NS.getContext());
899 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
900 /// printer to not emit usual symbol prefix before the symbol name is used then
901 /// return linkage name after skipping this special LLVM prefix.
902 static StringRef getRealLinkageName(StringRef LinkageName) {
904 if (LinkageName.startswith(StringRef(&One, 1)))
905 return LinkageName.substr(1);
909 /// getOrCreateSubprogramDIE - Create new DIE using SP.
910 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
911 DIE *SPDie = getDIE(SP);
915 SPDie = new DIE(dwarf::DW_TAG_subprogram);
917 // DW_TAG_inlined_subroutine may refer to this DIE.
918 insertDIE(SP, SPDie);
920 // Add to context owner.
921 addToContextOwner(SPDie, SP.getContext());
923 // Add function template parameters.
924 addTemplateParams(*SPDie, SP.getTemplateParams());
926 StringRef LinkageName = SP.getLinkageName();
927 if (!LinkageName.empty())
928 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
929 dwarf::DW_FORM_string,
930 getRealLinkageName(LinkageName));
932 // If this DIE is going to refer declaration info using AT_specification
933 // then there is no need to add other attributes.
934 if (SP.getFunctionDeclaration().isSubprogram())
937 // Constructors and operators for anonymous aggregates do not have names.
938 if (!SP.getName().empty())
939 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
942 addSourceLine(SPDie, SP);
944 if (SP.isPrototyped())
945 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
948 DICompositeType SPTy = SP.getType();
949 DIArray Args = SPTy.getTypeArray();
950 unsigned SPTag = SPTy.getTag();
952 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
953 addType(SPDie, SPTy);
955 addType(SPDie, DIType(Args.getElement(0)));
957 unsigned VK = SP.getVirtuality();
959 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
960 DIEBlock *Block = getDIEBlock();
961 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
962 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
963 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
964 ContainingTypeMap.insert(std::make_pair(SPDie,
965 SP.getContainingType()));
968 if (!SP.isDefinition()) {
969 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
971 // Add arguments. Do not add arguments for subprogram definition. They will
972 // be handled while processing variables.
973 DICompositeType SPTy = SP.getType();
974 DIArray Args = SPTy.getTypeArray();
975 unsigned SPTag = SPTy.getTag();
977 if (SPTag == dwarf::DW_TAG_subroutine_type)
978 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
979 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
980 DIType ATy = DIType(DIType(Args.getElement(i)));
982 if (ATy.isArtificial())
983 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
984 SPDie->addChild(Arg);
988 if (SP.isArtificial())
989 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
991 if (!SP.isLocalToUnit())
992 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
994 if (SP.isOptimized())
995 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
997 if (unsigned isa = Asm->getISAEncoding()) {
998 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1004 // Return const expression if value is a GEP to access merged global
1006 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1007 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1008 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1009 if (!CE || CE->getNumOperands() != 3 ||
1010 CE->getOpcode() != Instruction::GetElementPtr)
1013 // First operand points to a global struct.
1014 Value *Ptr = CE->getOperand(0);
1015 if (!isa<GlobalValue>(Ptr) ||
1016 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1019 // Second operand is zero.
1020 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1021 if (!CI || !CI->isZero())
1024 // Third operand is offset.
1025 if (!isa<ConstantInt>(CE->getOperand(2)))
1031 /// createGlobalVariableDIE - create global variable DIE.
1032 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1033 DIGlobalVariable GV(N);
1035 // Check for pre-existence.
1039 DIType GTy = GV.getType();
1040 DIE *VariableDIE = new DIE(GV.getTag());
1042 bool isGlobalVariable = GV.getGlobal() != NULL;
1045 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1046 GV.getDisplayName());
1047 StringRef LinkageName = GV.getLinkageName();
1048 if (!LinkageName.empty() && isGlobalVariable)
1049 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1050 dwarf::DW_FORM_string,
1051 getRealLinkageName(LinkageName));
1053 addType(VariableDIE, GTy);
1055 // Add scoping info.
1056 if (!GV.isLocalToUnit()) {
1057 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1058 // Expose as global.
1059 addGlobal(GV.getName(), VariableDIE);
1061 // Add line number info.
1062 addSourceLine(VariableDIE, GV);
1064 insertDIE(N, VariableDIE);
1065 // Add to context owner.
1066 DIDescriptor GVContext = GV.getContext();
1067 addToContextOwner(VariableDIE, GVContext);
1069 if (isGlobalVariable) {
1070 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1071 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1072 addLabel(Block, 0, dwarf::DW_FORM_udata,
1073 Asm->Mang->getSymbol(GV.getGlobal()));
1074 // Do not create specification DIE if context is either compile unit
1076 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1077 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1078 // Create specification DIE.
1079 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1080 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1081 dwarf::DW_FORM_ref4, VariableDIE);
1082 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1083 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1085 addDie(VariableSpecDIE);
1087 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1089 } else if (const ConstantInt *CI =
1090 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1091 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1092 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1093 // GV is a merged global.
1094 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1095 Value *Ptr = CE->getOperand(0);
1096 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1097 addLabel(Block, 0, dwarf::DW_FORM_udata,
1098 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1099 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1100 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1101 addUInt(Block, 0, dwarf::DW_FORM_udata,
1102 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1103 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1104 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1110 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1111 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1112 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1113 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1114 int64_t L = SR.getLo();
1115 int64_t H = SR.getHi();
1117 // The L value defines the lower bounds which is typically zero for C/C++. The
1118 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1119 // of the array. If L > H then do not emit DW_AT_lower_bound and
1120 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1121 // array has one element and in such case do not emit lower bound.
1124 Buffer.addChild(DW_Subrange);
1128 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1129 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1130 Buffer.addChild(DW_Subrange);
1133 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1134 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1135 DICompositeType *CTy) {
1136 Buffer.setTag(dwarf::DW_TAG_array_type);
1137 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1138 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1140 // Emit derived type.
1141 addType(&Buffer, CTy->getTypeDerivedFrom());
1142 DIArray Elements = CTy->getTypeArray();
1144 // Get an anonymous type for index type.
1145 DIE *IdxTy = getIndexTyDie();
1147 // Construct an anonymous type for index type.
1148 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1149 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1150 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1151 dwarf::DW_ATE_signed);
1153 setIndexTyDie(IdxTy);
1156 // Add subranges to array type.
1157 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1158 DIDescriptor Element = Elements.getElement(i);
1159 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1160 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1164 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1165 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1166 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1167 StringRef Name = ETy.getName();
1168 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1169 int64_t Value = ETy.getEnumValue();
1170 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1174 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1176 void CompileUnit::constructContainingTypeDIEs() {
1177 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1178 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1179 DIE *SPDie = CI->first;
1180 const MDNode *N = CI->second;
1182 DIE *NDie = getDIE(N);
1183 if (!NDie) continue;
1184 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1188 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1189 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1190 StringRef Name = DV->getName();
1194 // Translate tag to proper Dwarf tag.
1195 unsigned Tag = DV->getTag();
1197 // Define variable debug information entry.
1198 DIE *VariableDie = new DIE(Tag);
1199 DbgVariable *AbsVar = DV->getAbstractVariable();
1200 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1202 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1203 dwarf::DW_FORM_ref4, AbsDIE);
1205 addString(VariableDie, dwarf::DW_AT_name,
1206 dwarf::DW_FORM_string, Name);
1207 addSourceLine(VariableDie, DV->getVariable());
1208 addType(VariableDie, DV->getType());
1211 if (DV->isArtificial())
1212 addUInt(VariableDie, dwarf::DW_AT_artificial,
1213 dwarf::DW_FORM_flag, 1);
1215 if (isScopeAbstract) {
1216 DV->setDIE(VariableDie);
1220 // Add variable address.
1222 unsigned Offset = DV->getDotDebugLocOffset();
1223 if (Offset != ~0U) {
1224 addLabel(VariableDie, dwarf::DW_AT_location,
1225 dwarf::DW_FORM_data4,
1226 Asm->GetTempSymbol("debug_loc", Offset));
1227 DV->setDIE(VariableDie);
1231 // Check if variable is described by a DBG_VALUE instruction.
1232 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1233 bool updated = false;
1234 if (DVInsn->getNumOperands() == 3) {
1235 if (DVInsn->getOperand(0).isReg()) {
1236 const MachineOperand RegOp = DVInsn->getOperand(0);
1237 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1238 if (DVInsn->getOperand(1).isImm() &&
1239 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1240 unsigned FrameReg = 0;
1241 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1243 TFI->getFrameIndexReference(*Asm->MF,
1244 DVInsn->getOperand(1).getImm(),
1246 MachineLocation Location(FrameReg, Offset);
1247 addVariableAddress(DV, VariableDie, Location);
1249 } else if (RegOp.getReg())
1250 addVariableAddress(DV, VariableDie,
1251 MachineLocation(RegOp.getReg()));
1254 else if (DVInsn->getOperand(0).isImm())
1256 addConstantValue(VariableDie, DVInsn->getOperand(0),
1258 else if (DVInsn->getOperand(0).isFPImm())
1260 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1261 else if (DVInsn->getOperand(0).isCImm())
1263 addConstantValue(VariableDie,
1264 DVInsn->getOperand(0).getCImm(),
1265 DV->getType().isUnsignedDIType());
1267 addVariableAddress(DV, VariableDie,
1268 Asm->getDebugValueLocation(DVInsn));
1272 // If variableDie is not updated then DBG_VALUE instruction does not
1273 // have valid variable info.
1277 DV->setDIE(VariableDie);
1280 // .. else use frame index.
1281 int FI = DV->getFrameIndex();
1283 unsigned FrameReg = 0;
1284 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1286 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1287 MachineLocation Location(FrameReg, Offset);
1288 addVariableAddress(DV, VariableDie, Location);
1292 DV->setDIE(VariableDie);
1296 /// createMemberDIE - Create new member DIE.
1297 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1298 DIE *MemberDie = new DIE(DT.getTag());
1299 StringRef Name = DT.getName();
1301 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1303 addType(MemberDie, DT.getTypeDerivedFrom());
1305 addSourceLine(MemberDie, DT);
1307 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1308 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1310 uint64_t Size = DT.getSizeInBits();
1311 uint64_t FieldSize = DT.getOriginalTypeSize();
1313 if (Size != FieldSize) {
1315 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1316 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1318 uint64_t Offset = DT.getOffsetInBits();
1319 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1320 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1321 uint64_t FieldOffset = (HiMark - FieldSize);
1322 Offset -= FieldOffset;
1324 // Maybe we need to work from the other end.
1325 if (Asm->getTargetData().isLittleEndian())
1326 Offset = FieldSize - (Offset + Size);
1327 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1329 // Here WD_AT_data_member_location points to the anonymous
1330 // field that includes this bit field.
1331 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1334 // This is not a bitfield.
1335 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1337 if (DT.getTag() == dwarf::DW_TAG_inheritance
1338 && DT.isVirtual()) {
1340 // For C++, virtual base classes are not at fixed offset. Use following
1341 // expression to extract appropriate offset from vtable.
1342 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1344 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1345 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1346 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1347 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1348 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1349 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1350 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1351 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1353 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1356 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1358 if (DT.isProtected())
1359 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1360 dwarf::DW_ACCESS_protected);
1361 else if (DT.isPrivate())
1362 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1363 dwarf::DW_ACCESS_private);
1364 // Otherwise C++ member and base classes are considered public.
1366 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1367 dwarf::DW_ACCESS_public);
1369 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1370 dwarf::DW_VIRTUALITY_virtual);
1372 // Objective-C properties.
1373 StringRef PropertyName = DT.getObjCPropertyName();
1374 if (!PropertyName.empty()) {
1375 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string,
1377 StringRef GetterName = DT.getObjCPropertyGetterName();
1378 if (!GetterName.empty())
1379 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter,
1380 dwarf::DW_FORM_string, GetterName);
1381 StringRef SetterName = DT.getObjCPropertySetterName();
1382 if (!SetterName.empty())
1383 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter,
1384 dwarf::DW_FORM_string, SetterName);
1385 unsigned PropertyAttributes = 0;
1386 if (DT.isReadOnlyObjCProperty())
1387 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1388 if (DT.isReadWriteObjCProperty())
1389 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1390 if (DT.isAssignObjCProperty())
1391 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1392 if (DT.isRetainObjCProperty())
1393 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1394 if (DT.isCopyObjCProperty())
1395 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1396 if (DT.isNonAtomicObjCProperty())
1397 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1398 if (PropertyAttributes)
1399 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1400 PropertyAttributes);