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, DINameSpace NS) {
196 unsigned Line = NS.getLineNumber();
199 StringRef FN = NS.getFilename();
201 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.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 /// addVariableAddress - Add DW_AT_location attribute for a
208 /// DbgVariable based on provided MachineLocation.
209 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
210 MachineLocation Location) {
211 if (DV->variableHasComplexAddress())
212 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
213 else if (DV->isBlockByrefVariable())
214 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
216 addAddress(Die, dwarf::DW_AT_location, Location);
219 /// addRegisterOp - Add register operand.
220 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
221 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
222 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
224 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
226 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
227 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
231 /// addRegisterOffset - Add register offset.
232 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
234 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
235 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
236 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
237 if (Reg == TRI->getFrameRegister(*Asm->MF))
238 // If variable offset is based in frame register then use fbreg.
239 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
241 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
243 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
244 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
246 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
249 /// addAddress - Add an address attribute to a die based on the location
251 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
252 const MachineLocation &Location) {
253 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
255 if (Location.isReg())
256 addRegisterOp(Block, Location.getReg());
258 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
260 // Now attach the location information to the DIE.
261 addBlock(Die, Attribute, 0, Block);
264 /// addComplexAddress - Start with the address based on the location provided,
265 /// and generate the DWARF information necessary to find the actual variable
266 /// given the extra address information encoded in the DIVariable, starting from
267 /// the starting location. Add the DWARF information to the die.
269 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
271 const MachineLocation &Location) {
272 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
273 unsigned N = DV->getNumAddrElements();
275 if (Location.isReg()) {
276 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
277 // If first address element is OpPlus then emit
278 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
279 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
282 addRegisterOp(Block, Location.getReg());
285 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
288 uint64_t Element = DV->getAddrElement(i);
289 if (Element == DIBuilder::OpPlus) {
290 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
291 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
292 } else if (Element == DIBuilder::OpDeref) {
293 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
294 } else llvm_unreachable("unknown DIBuilder Opcode");
297 // Now attach the location information to the DIE.
298 addBlock(Die, Attribute, 0, Block);
301 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
302 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
303 gives the variable VarName either the struct, or a pointer to the struct, as
304 its type. This is necessary for various behind-the-scenes things the
305 compiler needs to do with by-reference variables in Blocks.
307 However, as far as the original *programmer* is concerned, the variable
308 should still have type 'SomeType', as originally declared.
310 The function getBlockByrefType dives into the __Block_byref_x_VarName
311 struct to find the original type of the variable, which is then assigned to
312 the variable's Debug Information Entry as its real type. So far, so good.
313 However now the debugger will expect the variable VarName to have the type
314 SomeType. So we need the location attribute for the variable to be an
315 expression that explains to the debugger how to navigate through the
316 pointers and struct to find the actual variable of type SomeType.
318 The following function does just that. We start by getting
319 the "normal" location for the variable. This will be the location
320 of either the struct __Block_byref_x_VarName or the pointer to the
321 struct __Block_byref_x_VarName.
323 The struct will look something like:
325 struct __Block_byref_x_VarName {
327 struct __Block_byref_x_VarName *forwarding;
328 ... <various other fields>
330 ... <maybe more fields>
333 If we are given the struct directly (as our starting point) we
334 need to tell the debugger to:
336 1). Add the offset of the forwarding field.
338 2). Follow that pointer to get the real __Block_byref_x_VarName
339 struct to use (the real one may have been copied onto the heap).
341 3). Add the offset for the field VarName, to find the actual variable.
343 If we started with a pointer to the struct, then we need to
344 dereference that pointer first, before the other steps.
345 Translating this into DWARF ops, we will need to append the following
346 to the current location description for the variable:
348 DW_OP_deref -- optional, if we start with a pointer
349 DW_OP_plus_uconst <forward_fld_offset>
351 DW_OP_plus_uconst <varName_fld_offset>
353 That is what this function does. */
355 /// addBlockByrefAddress - Start with the address based on the location
356 /// provided, and generate the DWARF information necessary to find the
357 /// actual Block variable (navigating the Block struct) based on the
358 /// starting location. Add the DWARF information to the die. For
359 /// more information, read large comment just above here.
361 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
363 const MachineLocation &Location) {
364 DIType Ty = DV->getType();
366 unsigned Tag = Ty.getTag();
367 bool isPointer = false;
369 StringRef varName = DV->getName();
371 if (Tag == dwarf::DW_TAG_pointer_type) {
372 DIDerivedType DTy = DIDerivedType(Ty);
373 TmpTy = DTy.getTypeDerivedFrom();
377 DICompositeType blockStruct = DICompositeType(TmpTy);
379 // Find the __forwarding field and the variable field in the __Block_byref
381 DIArray Fields = blockStruct.getTypeArray();
382 DIDescriptor varField = DIDescriptor();
383 DIDescriptor forwardingField = DIDescriptor();
385 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
386 DIDescriptor Element = Fields.getElement(i);
387 DIDerivedType DT = DIDerivedType(Element);
388 StringRef fieldName = DT.getName();
389 if (fieldName == "__forwarding")
390 forwardingField = Element;
391 else if (fieldName == varName)
395 // Get the offsets for the forwarding field and the variable field.
396 unsigned forwardingFieldOffset =
397 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
398 unsigned varFieldOffset =
399 DIDerivedType(varField).getOffsetInBits() >> 3;
401 // Decode the original location, and use that as the start of the byref
402 // variable's location.
403 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
404 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
405 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
407 if (Location.isReg()) {
409 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
411 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
412 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
416 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
418 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
419 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
422 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
425 // If we started with a pointer to the __Block_byref... struct, then
426 // the first thing we need to do is dereference the pointer (DW_OP_deref).
428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
430 // Next add the offset for the '__forwarding' field:
431 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
432 // adding the offset if it's 0.
433 if (forwardingFieldOffset > 0) {
434 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
435 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
438 // Now dereference the __forwarding field to get to the real __Block_byref
439 // struct: DW_OP_deref.
440 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
442 // Now that we've got the real __Block_byref... struct, add the offset
443 // for the variable's field to get to the location of the actual variable:
444 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
445 if (varFieldOffset > 0) {
446 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
447 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
450 // Now attach the location information to the DIE.
451 addBlock(Die, Attribute, 0, Block);
454 /// isTypeSigned - Return true if the type is signed.
455 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
456 if (Ty.isDerivedType())
457 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
458 if (Ty.isBasicType())
459 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
460 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
461 *SizeInBits = Ty.getSizeInBits();
467 /// addConstantValue - Add constant value entry in variable DIE.
468 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
470 assert(MO.isImm() && "Invalid machine operand!");
471 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
473 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
474 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
475 switch (SizeInBits) {
476 case 8: Form = dwarf::DW_FORM_data1; break;
477 case 16: Form = dwarf::DW_FORM_data2; break;
478 case 32: Form = dwarf::DW_FORM_data4; break;
479 case 64: Form = dwarf::DW_FORM_data8; break;
482 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
483 : addUInt(Block, 0, Form, MO.getImm());
485 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
489 /// addConstantFPValue - Add constant value entry in variable DIE.
490 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
491 assert (MO.isFPImm() && "Invalid machine operand!");
492 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
493 APFloat FPImm = MO.getFPImm()->getValueAPF();
495 // Get the raw data form of the floating point.
496 const APInt FltVal = FPImm.bitcastToAPInt();
497 const char *FltPtr = (const char*)FltVal.getRawData();
499 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
500 bool LittleEndian = Asm->getTargetData().isLittleEndian();
501 int Incr = (LittleEndian ? 1 : -1);
502 int Start = (LittleEndian ? 0 : NumBytes - 1);
503 int Stop = (LittleEndian ? NumBytes : -1);
505 // Output the constant to DWARF one byte at a time.
506 for (; Start != Stop; Start += Incr)
507 addUInt(Block, 0, dwarf::DW_FORM_data1,
508 (unsigned char)0xFF & FltPtr[Start]);
510 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
514 /// addConstantValue - Add constant value entry in variable DIE.
515 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
517 unsigned CIBitWidth = CI->getBitWidth();
518 if (CIBitWidth <= 64) {
520 switch (CIBitWidth) {
521 case 8: form = dwarf::DW_FORM_data1; break;
522 case 16: form = dwarf::DW_FORM_data2; break;
523 case 32: form = dwarf::DW_FORM_data4; break;
524 case 64: form = dwarf::DW_FORM_data8; break;
526 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
529 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
531 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
535 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
537 // Get the raw data form of the large APInt.
538 const APInt Val = CI->getValue();
539 const uint64_t *Ptr64 = Val.getRawData();
541 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
542 bool LittleEndian = Asm->getTargetData().isLittleEndian();
544 // Output the constant to DWARF one byte at a time.
545 for (int i = 0; i < NumBytes; i++) {
548 c = Ptr64[i / 8] >> (8 * (i & 7));
550 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
551 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
554 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
558 /// addTemplateParams - Add template parameters in buffer.
559 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
560 // Add template parameters.
561 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
562 DIDescriptor Element = TParams.getElement(i);
563 if (Element.isTemplateTypeParameter())
564 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
565 DITemplateTypeParameter(Element)));
566 else if (Element.isTemplateValueParameter())
567 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
568 DITemplateValueParameter(Element)));
572 /// addToContextOwner - Add Die into the list of its context owner's children.
573 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
574 if (Context.isType()) {
575 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
576 ContextDIE->addChild(Die);
577 } else if (Context.isNameSpace()) {
578 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
579 ContextDIE->addChild(Die);
580 } else if (Context.isSubprogram()) {
581 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
582 ContextDIE->addChild(Die);
583 } else if (DIE *ContextDIE = getDIE(Context))
584 ContextDIE->addChild(Die);
589 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
591 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
595 DIE *TyDIE = getDIE(Ty);
600 TyDIE = new DIE(dwarf::DW_TAG_base_type);
601 insertDIE(Ty, TyDIE);
602 if (Ty.isBasicType())
603 constructTypeDIE(*TyDIE, DIBasicType(Ty));
604 else if (Ty.isCompositeType())
605 constructTypeDIE(*TyDIE, DICompositeType(Ty));
607 assert(Ty.isDerivedType() && "Unknown kind of DIType");
608 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
610 // If this is a named finished type then include it in the list of types
611 // for the accelerator tables.
612 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
613 bool IsImplementation = 0;
614 if (Ty.isCompositeType()) {
615 DICompositeType CT(Ty);
616 // A runtime language of 0 actually means C/C++ and that any
617 // non-negative value is some version of Objective-C/C++.
618 IsImplementation = (CT.getRunTimeLang() == 0) ||
619 CT.isObjcClassComplete();
621 unsigned Flags = IsImplementation ?
622 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
623 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
626 addToContextOwner(TyDIE, Ty.getContext());
630 /// addType - Add a new type attribute to the specified entity.
631 void CompileUnit::addType(DIE *Entity, DIType Ty,
632 unsigned Attribute) {
636 // Check for pre-existence.
637 DIEEntry *Entry = getDIEEntry(Ty);
638 // If it exists then use the existing value.
640 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
645 DIE *Buffer = getOrCreateTypeDIE(Ty);
648 Entry = createDIEEntry(Buffer);
649 insertDIEEntry(Ty, Entry);
650 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
652 // If this is a complete composite type then include it in the
653 // list of global types.
657 /// addGlobalType - Add a new global type to the compile unit.
659 void CompileUnit::addGlobalType(DIType Ty) {
660 DIDescriptor Context = Ty.getContext();
661 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
662 && (!Context || Context.isCompileUnit() || Context.isFile()
663 || Context.isNameSpace()))
664 if (DIEEntry *Entry = getDIEEntry(Ty))
665 GlobalTypes[Ty.getName()] = Entry->getEntry();
668 /// addPubTypes - Add type for pubtypes section.
669 void CompileUnit::addPubTypes(DISubprogram SP) {
670 DICompositeType SPTy = SP.getType();
671 unsigned SPTag = SPTy.getTag();
672 if (SPTag != dwarf::DW_TAG_subroutine_type)
675 DIArray Args = SPTy.getTypeArray();
676 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
677 DIType ATy(Args.getElement(i));
684 /// constructTypeDIE - Construct basic type die from DIBasicType.
685 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
686 // Get core information.
687 StringRef Name = BTy.getName();
688 // Add name if not anonymous or intermediate type.
690 addString(&Buffer, dwarf::DW_AT_name, Name);
692 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
693 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
694 // Unspecified types has only name, nothing else.
698 Buffer.setTag(dwarf::DW_TAG_base_type);
699 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
702 uint64_t Size = BTy.getSizeInBits() >> 3;
703 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
706 /// constructTypeDIE - Construct derived type die from DIDerivedType.
707 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
708 // Get core information.
709 StringRef Name = DTy.getName();
710 uint64_t Size = DTy.getSizeInBits() >> 3;
711 unsigned Tag = DTy.getTag();
713 // FIXME - Workaround for templates.
714 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
718 // Map to main type, void will not have a type.
719 DIType FromTy = DTy.getTypeDerivedFrom();
720 addType(&Buffer, FromTy);
722 // Add name if not anonymous or intermediate type.
724 addString(&Buffer, dwarf::DW_AT_name, Name);
726 // Add size if non-zero (derived types might be zero-sized.)
727 if (Size && Tag != dwarf::DW_TAG_pointer_type)
728 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
730 // Add source line info if available and TyDesc is not a forward declaration.
731 if (!DTy.isForwardDecl())
732 addSourceLine(&Buffer, DTy);
735 /// constructTypeDIE - Construct type DIE from DICompositeType.
736 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
737 // Get core information.
738 StringRef Name = CTy.getName();
740 uint64_t Size = CTy.getSizeInBits() >> 3;
741 unsigned Tag = CTy.getTag();
745 case dwarf::DW_TAG_vector_type:
746 case dwarf::DW_TAG_array_type:
747 constructArrayTypeDIE(Buffer, &CTy);
749 case dwarf::DW_TAG_enumeration_type: {
750 DIArray Elements = CTy.getTypeArray();
752 // Add enumerators to enumeration type.
753 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
755 DIDescriptor Enum(Elements.getElement(i));
756 if (Enum.isEnumerator()) {
757 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
758 Buffer.addChild(ElemDie);
763 case dwarf::DW_TAG_subroutine_type: {
765 DIArray Elements = CTy.getTypeArray();
766 DIDescriptor RTy = Elements.getElement(0);
767 addType(&Buffer, DIType(RTy));
769 bool isPrototyped = true;
771 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
772 DIDescriptor Ty = Elements.getElement(i);
773 if (Ty.isUnspecifiedParameter()) {
774 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
775 Buffer.addChild(Arg);
776 isPrototyped = false;
778 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
779 addType(Arg, DIType(Ty));
780 Buffer.addChild(Arg);
783 // Add prototype flag if we're dealing with a C language and the
784 // function has been prototyped.
786 (Language == dwarf::DW_LANG_C89 ||
787 Language == dwarf::DW_LANG_C99 ||
788 Language == dwarf::DW_LANG_ObjC))
789 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
792 case dwarf::DW_TAG_structure_type:
793 case dwarf::DW_TAG_union_type:
794 case dwarf::DW_TAG_class_type: {
795 // Add elements to structure type.
796 DIArray Elements = CTy.getTypeArray();
798 // A forward struct declared type may not have elements available.
799 unsigned N = Elements.getNumElements();
803 // Add elements to structure type.
804 for (unsigned i = 0; i < N; ++i) {
805 DIDescriptor Element = Elements.getElement(i);
807 if (Element.isSubprogram()) {
808 DISubprogram SP(Element);
809 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
810 if (SP.isProtected())
811 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
812 dwarf::DW_ACCESS_protected);
813 else if (SP.isPrivate())
814 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
815 dwarf::DW_ACCESS_private);
817 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
818 dwarf::DW_ACCESS_public);
820 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
822 else if (Element.isVariable()) {
823 DIVariable DV(Element);
824 ElemDie = new DIE(dwarf::DW_TAG_variable);
825 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
826 addType(ElemDie, DV.getType());
827 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
828 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
829 addSourceLine(ElemDie, DV);
830 } else if (Element.isDerivedType()) {
831 DIDerivedType DDTy(Element);
832 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
833 ElemDie = new DIE(dwarf::DW_TAG_friend);
834 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
836 ElemDie = createMemberDIE(DIDerivedType(Element));
837 } else if (Element.isObjCProperty()) {
838 DIObjCProperty Property(Element);
839 ElemDie = new DIE(Property.getTag());
840 StringRef PropertyName = Property.getObjCPropertyName();
841 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
842 StringRef GetterName = Property.getObjCPropertyGetterName();
843 if (!GetterName.empty())
844 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
845 StringRef SetterName = Property.getObjCPropertySetterName();
846 if (!SetterName.empty())
847 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
848 unsigned PropertyAttributes = 0;
849 if (Property.isReadOnlyObjCProperty())
850 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
851 if (Property.isReadWriteObjCProperty())
852 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
853 if (Property.isAssignObjCProperty())
854 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
855 if (Property.isRetainObjCProperty())
856 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
857 if (Property.isCopyObjCProperty())
858 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
859 if (Property.isNonAtomicObjCProperty())
860 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
861 if (PropertyAttributes)
862 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
865 DIEEntry *Entry = getDIEEntry(Element);
867 Entry = createDIEEntry(ElemDie);
868 insertDIEEntry(Element, Entry);
872 Buffer.addChild(ElemDie);
875 if (CTy.isAppleBlockExtension())
876 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
878 DICompositeType ContainingType = CTy.getContainingType();
879 if (DIDescriptor(ContainingType).isCompositeType())
880 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
881 getOrCreateTypeDIE(DIType(ContainingType)));
883 DIDescriptor Context = CTy.getContext();
884 addToContextOwner(&Buffer, Context);
887 if (CTy.isObjcClassComplete())
888 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
889 dwarf::DW_FORM_flag, 1);
891 // Add template parameters to a class, structure or union types.
892 // FIXME: The support isn't in the metadata for this yet.
893 if (Tag == dwarf::DW_TAG_class_type ||
894 Tag == dwarf::DW_TAG_structure_type ||
895 Tag == dwarf::DW_TAG_union_type)
896 addTemplateParams(Buffer, CTy.getTemplateParams());
904 // Add name if not anonymous or intermediate type.
906 addString(&Buffer, dwarf::DW_AT_name, Name);
908 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
909 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
911 // Add size if non-zero (derived types might be zero-sized.)
913 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
915 // Add zero size if it is not a forward declaration.
916 if (CTy.isForwardDecl())
917 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
919 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
922 // Add source line info if available.
923 if (!CTy.isForwardDecl())
924 addSourceLine(&Buffer, CTy);
926 // No harm in adding the runtime language to the declaration.
927 unsigned RLang = CTy.getRunTimeLang();
929 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
930 dwarf::DW_FORM_data1, RLang);
934 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
935 /// for the given DITemplateTypeParameter.
937 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
938 DIE *ParamDIE = getDIE(TP);
942 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
943 addType(ParamDIE, TP.getType());
944 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
948 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
949 /// for the given DITemplateValueParameter.
951 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
952 DIE *ParamDIE = getDIE(TPV);
956 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
957 addType(ParamDIE, TPV.getType());
958 if (!TPV.getName().empty())
959 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
960 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
965 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
966 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
967 DIE *NDie = getDIE(NS);
970 NDie = new DIE(dwarf::DW_TAG_namespace);
972 if (!NS.getName().empty()) {
973 addString(NDie, dwarf::DW_AT_name, NS.getName());
974 addAccelNamespace(NS.getName(), NDie);
976 addAccelNamespace("(anonymous namespace)", NDie);
977 addSourceLine(NDie, NS);
978 addToContextOwner(NDie, NS.getContext());
982 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
983 /// printer to not emit usual symbol prefix before the symbol name is used then
984 /// return linkage name after skipping this special LLVM prefix.
985 static StringRef getRealLinkageName(StringRef LinkageName) {
987 if (LinkageName.startswith(StringRef(&One, 1)))
988 return LinkageName.substr(1);
992 /// getOrCreateSubprogramDIE - Create new DIE using SP.
993 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
994 DIE *SPDie = getDIE(SP);
998 DISubprogram SPDecl = SP.getFunctionDeclaration();
1000 if (SPDecl.isSubprogram()) {
1001 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1004 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1006 // DW_TAG_inlined_subroutine may refer to this DIE.
1007 insertDIE(SP, SPDie);
1009 // Add to context owner.
1010 addToContextOwner(SPDie, SP.getContext());
1012 // Add function template parameters.
1013 addTemplateParams(*SPDie, SP.getTemplateParams());
1015 // Unfortunately this code needs to stay here to work around
1016 // a bug in older gdbs that requires the linkage name to resolve
1017 // multiple template functions.
1018 StringRef LinkageName = SP.getLinkageName();
1019 if (!LinkageName.empty())
1020 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1021 getRealLinkageName(LinkageName));
1023 // If this DIE is going to refer declaration info using AT_specification
1024 // then there is no need to add other attributes.
1026 // Refer function declaration directly.
1027 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1033 // Constructors and operators for anonymous aggregates do not have names.
1034 if (!SP.getName().empty())
1035 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1037 addSourceLine(SPDie, SP);
1039 // Add the prototype if we have a prototype and we have a C like
1041 if (SP.isPrototyped() &&
1042 (Language == dwarf::DW_LANG_C89 ||
1043 Language == dwarf::DW_LANG_C99 ||
1044 Language == dwarf::DW_LANG_ObjC))
1045 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1048 DICompositeType SPTy = SP.getType();
1049 DIArray Args = SPTy.getTypeArray();
1050 unsigned SPTag = SPTy.getTag();
1052 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1053 addType(SPDie, SPTy);
1055 addType(SPDie, DIType(Args.getElement(0)));
1057 unsigned VK = SP.getVirtuality();
1059 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1060 DIEBlock *Block = getDIEBlock();
1061 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1062 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1063 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1064 ContainingTypeMap.insert(std::make_pair(SPDie,
1065 SP.getContainingType()));
1068 if (!SP.isDefinition()) {
1069 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1071 // Add arguments. Do not add arguments for subprogram definition. They will
1072 // be handled while processing variables.
1073 DICompositeType SPTy = SP.getType();
1074 DIArray Args = SPTy.getTypeArray();
1075 unsigned SPTag = SPTy.getTag();
1077 if (SPTag == dwarf::DW_TAG_subroutine_type)
1078 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1079 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1080 DIType ATy = DIType(DIType(Args.getElement(i)));
1082 if (ATy.isArtificial())
1083 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1084 SPDie->addChild(Arg);
1088 if (SP.isArtificial())
1089 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1091 if (!SP.isLocalToUnit())
1092 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1094 if (SP.isOptimized())
1095 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1097 if (unsigned isa = Asm->getISAEncoding()) {
1098 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1104 // Return const expression if value is a GEP to access merged global
1106 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1107 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1108 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1109 if (!CE || CE->getNumOperands() != 3 ||
1110 CE->getOpcode() != Instruction::GetElementPtr)
1113 // First operand points to a global struct.
1114 Value *Ptr = CE->getOperand(0);
1115 if (!isa<GlobalValue>(Ptr) ||
1116 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1119 // Second operand is zero.
1120 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1121 if (!CI || !CI->isZero())
1124 // Third operand is offset.
1125 if (!isa<ConstantInt>(CE->getOperand(2)))
1131 /// createGlobalVariableDIE - create global variable DIE.
1132 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1133 // Check for pre-existence.
1137 DIGlobalVariable GV(N);
1141 DIE *VariableDIE = new DIE(GV.getTag());
1143 insertDIE(N, VariableDIE);
1146 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1147 StringRef LinkageName = GV.getLinkageName();
1148 bool isGlobalVariable = GV.getGlobal() != NULL;
1149 if (!LinkageName.empty() && isGlobalVariable)
1150 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1151 getRealLinkageName(LinkageName));
1153 DIType GTy = GV.getType();
1154 addType(VariableDIE, GTy);
1156 // Add scoping info.
1157 if (!GV.isLocalToUnit())
1158 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1160 // Add line number info.
1161 addSourceLine(VariableDIE, GV);
1162 // Add to context owner.
1163 DIDescriptor GVContext = GV.getContext();
1164 addToContextOwner(VariableDIE, GVContext);
1166 bool addToAccelTable = false;
1167 DIE *VariableSpecDIE = NULL;
1168 if (isGlobalVariable) {
1169 addToAccelTable = true;
1170 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1171 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1172 addLabel(Block, 0, dwarf::DW_FORM_udata,
1173 Asm->Mang->getSymbol(GV.getGlobal()));
1174 // Do not create specification DIE if context is either compile unit
1176 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1177 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1178 // Create specification DIE.
1179 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1180 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1181 dwarf::DW_FORM_ref4, VariableDIE);
1182 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1183 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1185 addDie(VariableSpecDIE);
1187 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1189 } else if (const ConstantInt *CI =
1190 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1191 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1192 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1193 addToAccelTable = true;
1194 // GV is a merged global.
1195 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1196 Value *Ptr = CE->getOperand(0);
1197 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1198 addLabel(Block, 0, dwarf::DW_FORM_udata,
1199 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1200 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1201 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1202 addUInt(Block, 0, dwarf::DW_FORM_udata,
1203 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1204 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1205 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1208 if (addToAccelTable) {
1209 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1210 addAccelName(GV.getName(), AddrDIE);
1212 // If the linkage name is different than the name, go ahead and output
1213 // that as well into the name table.
1214 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1215 addAccelName(GV.getLinkageName(), AddrDIE);
1221 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1222 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1223 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1224 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1225 uint64_t L = SR.getLo();
1226 uint64_t H = SR.getHi();
1228 // The L value defines the lower bounds which is typically zero for C/C++. The
1229 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1230 // of the array. If L > H then do not emit DW_AT_lower_bound and
1231 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1232 // array has one element and in such case do not emit lower bound.
1235 Buffer.addChild(DW_Subrange);
1239 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1240 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1241 Buffer.addChild(DW_Subrange);
1244 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1245 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1246 DICompositeType *CTy) {
1247 Buffer.setTag(dwarf::DW_TAG_array_type);
1248 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1249 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1251 // Emit derived type.
1252 addType(&Buffer, CTy->getTypeDerivedFrom());
1253 DIArray Elements = CTy->getTypeArray();
1255 // Get an anonymous type for index type.
1256 DIE *IdxTy = getIndexTyDie();
1258 // Construct an anonymous type for index type.
1259 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1260 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1261 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1262 dwarf::DW_ATE_signed);
1264 setIndexTyDie(IdxTy);
1267 // Add subranges to array type.
1268 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1269 DIDescriptor Element = Elements.getElement(i);
1270 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1271 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1275 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1276 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1277 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1278 StringRef Name = ETy.getName();
1279 addString(Enumerator, dwarf::DW_AT_name, Name);
1280 int64_t Value = ETy.getEnumValue();
1281 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1285 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1287 void CompileUnit::constructContainingTypeDIEs() {
1288 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1289 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1290 DIE *SPDie = CI->first;
1291 const MDNode *N = CI->second;
1293 DIE *NDie = getDIE(N);
1294 if (!NDie) continue;
1295 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1299 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1300 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1301 StringRef Name = DV->getName();
1305 // Translate tag to proper Dwarf tag.
1306 unsigned Tag = DV->getTag();
1308 // Define variable debug information entry.
1309 DIE *VariableDie = new DIE(Tag);
1310 DbgVariable *AbsVar = DV->getAbstractVariable();
1311 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1313 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1314 dwarf::DW_FORM_ref4, AbsDIE);
1316 addString(VariableDie, dwarf::DW_AT_name, Name);
1317 addSourceLine(VariableDie, DV->getVariable());
1318 addType(VariableDie, DV->getType());
1321 if (DV->isArtificial())
1322 addUInt(VariableDie, dwarf::DW_AT_artificial,
1323 dwarf::DW_FORM_flag, 1);
1325 if (isScopeAbstract) {
1326 DV->setDIE(VariableDie);
1330 // Add variable address.
1332 unsigned Offset = DV->getDotDebugLocOffset();
1333 if (Offset != ~0U) {
1334 addLabel(VariableDie, dwarf::DW_AT_location,
1335 dwarf::DW_FORM_data4,
1336 Asm->GetTempSymbol("debug_loc", Offset));
1337 DV->setDIE(VariableDie);
1341 // Check if variable is described by a DBG_VALUE instruction.
1342 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1343 bool updated = false;
1344 if (DVInsn->getNumOperands() == 3) {
1345 if (DVInsn->getOperand(0).isReg()) {
1346 const MachineOperand RegOp = DVInsn->getOperand(0);
1347 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1348 if (DVInsn->getOperand(1).isImm() &&
1349 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1350 unsigned FrameReg = 0;
1351 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1353 TFI->getFrameIndexReference(*Asm->MF,
1354 DVInsn->getOperand(1).getImm(),
1356 MachineLocation Location(FrameReg, Offset);
1357 addVariableAddress(DV, VariableDie, Location);
1359 } else if (RegOp.getReg())
1360 addVariableAddress(DV, VariableDie,
1361 MachineLocation(RegOp.getReg()));
1364 else if (DVInsn->getOperand(0).isImm())
1366 addConstantValue(VariableDie, DVInsn->getOperand(0),
1368 else if (DVInsn->getOperand(0).isFPImm())
1370 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1371 else if (DVInsn->getOperand(0).isCImm())
1373 addConstantValue(VariableDie,
1374 DVInsn->getOperand(0).getCImm(),
1375 DV->getType().isUnsignedDIType());
1377 addVariableAddress(DV, VariableDie,
1378 Asm->getDebugValueLocation(DVInsn));
1382 // If variableDie is not updated then DBG_VALUE instruction does not
1383 // have valid variable info.
1387 DV->setDIE(VariableDie);
1390 // .. else use frame index.
1391 int FI = DV->getFrameIndex();
1393 unsigned FrameReg = 0;
1394 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1396 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1397 MachineLocation Location(FrameReg, Offset);
1398 addVariableAddress(DV, VariableDie, Location);
1402 DV->setDIE(VariableDie);
1406 /// createMemberDIE - Create new member DIE.
1407 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1408 DIE *MemberDie = new DIE(DT.getTag());
1409 StringRef Name = DT.getName();
1411 addString(MemberDie, dwarf::DW_AT_name, Name);
1413 addType(MemberDie, DT.getTypeDerivedFrom());
1415 addSourceLine(MemberDie, DT);
1417 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1418 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1420 uint64_t Size = DT.getSizeInBits();
1421 uint64_t FieldSize = DT.getOriginalTypeSize();
1423 if (Size != FieldSize) {
1425 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1426 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1428 uint64_t Offset = DT.getOffsetInBits();
1429 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1430 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1431 uint64_t FieldOffset = (HiMark - FieldSize);
1432 Offset -= FieldOffset;
1434 // Maybe we need to work from the other end.
1435 if (Asm->getTargetData().isLittleEndian())
1436 Offset = FieldSize - (Offset + Size);
1437 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1439 // Here WD_AT_data_member_location points to the anonymous
1440 // field that includes this bit field.
1441 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1444 // This is not a bitfield.
1445 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1447 if (DT.getTag() == dwarf::DW_TAG_inheritance
1448 && DT.isVirtual()) {
1450 // For C++, virtual base classes are not at fixed offset. Use following
1451 // expression to extract appropriate offset from vtable.
1452 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1454 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1455 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1456 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1457 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1458 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1459 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1460 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1461 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1463 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1466 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1468 if (DT.isProtected())
1469 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1470 dwarf::DW_ACCESS_protected);
1471 else if (DT.isPrivate())
1472 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1473 dwarf::DW_ACCESS_private);
1474 // Otherwise C++ member and base classes are considered public.
1476 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1477 dwarf::DW_ACCESS_public);
1479 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1480 dwarf::DW_VIRTUALITY_virtual);
1482 // Objective-C properties.
1483 if (MDNode *PNode = DT.getObjCProperty())
1484 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1485 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1488 // This is only for backward compatibility.
1489 StringRef PropertyName = DT.getObjCPropertyName();
1490 if (!PropertyName.empty()) {
1491 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1492 StringRef GetterName = DT.getObjCPropertyGetterName();
1493 if (!GetterName.empty())
1494 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1495 StringRef SetterName = DT.getObjCPropertySetterName();
1496 if (!SetterName.empty())
1497 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1498 unsigned PropertyAttributes = 0;
1499 if (DT.isReadOnlyObjCProperty())
1500 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1501 if (DT.isReadWriteObjCProperty())
1502 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1503 if (DT.isAssignObjCProperty())
1504 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1505 if (DT.isRetainObjCProperty())
1506 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1507 if (DT.isCopyObjCProperty())
1508 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1509 if (DT.isNonAtomicObjCProperty())
1510 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1511 if (PropertyAttributes)
1512 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1513 PropertyAttributes);