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