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 constructing a 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/DIBuilder.h"
21 #include "llvm/GlobalVariable.h"
22 #include "llvm/Instructions.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 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
424 if (Location.isReg())
425 addRegisterOp(Block, Location.getReg());
427 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
429 // If we started with a pointer to the __Block_byref... struct, then
430 // the first thing we need to do is dereference the pointer (DW_OP_deref).
432 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
434 // Next add the offset for the '__forwarding' field:
435 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
436 // adding the offset if it's 0.
437 if (forwardingFieldOffset > 0) {
438 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
439 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
442 // Now dereference the __forwarding field to get to the real __Block_byref
443 // struct: DW_OP_deref.
444 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
446 // Now that we've got the real __Block_byref... struct, add the offset
447 // for the variable's field to get to the location of the actual variable:
448 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
449 if (varFieldOffset > 0) {
450 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
451 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
454 // Now attach the location information to the DIE.
455 addBlock(Die, Attribute, 0, Block);
458 /// isTypeSigned - Return true if the type is signed.
459 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
460 if (Ty.isDerivedType())
461 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
462 if (Ty.isBasicType())
463 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
464 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
465 *SizeInBits = Ty.getSizeInBits();
471 /// addConstantValue - Add constant value entry in variable DIE.
472 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
474 assert(MO.isImm() && "Invalid machine operand!");
475 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
477 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
478 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
479 switch (SizeInBits) {
480 case 8: Form = dwarf::DW_FORM_data1; break;
481 case 16: Form = dwarf::DW_FORM_data2; break;
482 case 32: Form = dwarf::DW_FORM_data4; break;
483 case 64: Form = dwarf::DW_FORM_data8; break;
486 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
487 : addUInt(Block, 0, Form, MO.getImm());
489 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
493 /// addConstantFPValue - Add constant value entry in variable DIE.
494 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
495 assert (MO.isFPImm() && "Invalid machine operand!");
496 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
497 APFloat FPImm = MO.getFPImm()->getValueAPF();
499 // Get the raw data form of the floating point.
500 const APInt FltVal = FPImm.bitcastToAPInt();
501 const char *FltPtr = (const char*)FltVal.getRawData();
503 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
504 bool LittleEndian = Asm->getTargetData().isLittleEndian();
505 int Incr = (LittleEndian ? 1 : -1);
506 int Start = (LittleEndian ? 0 : NumBytes - 1);
507 int Stop = (LittleEndian ? NumBytes : -1);
509 // Output the constant to DWARF one byte at a time.
510 for (; Start != Stop; Start += Incr)
511 addUInt(Block, 0, dwarf::DW_FORM_data1,
512 (unsigned char)0xFF & FltPtr[Start]);
514 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
518 /// addConstantValue - Add constant value entry in variable DIE.
519 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
521 unsigned CIBitWidth = CI->getBitWidth();
522 if (CIBitWidth <= 64) {
524 switch (CIBitWidth) {
525 case 8: form = dwarf::DW_FORM_data1; break;
526 case 16: form = dwarf::DW_FORM_data2; break;
527 case 32: form = dwarf::DW_FORM_data4; break;
528 case 64: form = dwarf::DW_FORM_data8; break;
530 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
533 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
535 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
539 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
541 // Get the raw data form of the large APInt.
542 const APInt Val = CI->getValue();
543 const uint64_t *Ptr64 = Val.getRawData();
545 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
546 bool LittleEndian = Asm->getTargetData().isLittleEndian();
548 // Output the constant to DWARF one byte at a time.
549 for (int i = 0; i < NumBytes; i++) {
552 c = Ptr64[i / 8] >> (8 * (i & 7));
554 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
555 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
558 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
562 /// addTemplateParams - Add template parameters in buffer.
563 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
564 // Add template parameters.
565 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
566 DIDescriptor Element = TParams.getElement(i);
567 if (Element.isTemplateTypeParameter())
568 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
569 DITemplateTypeParameter(Element)));
570 else if (Element.isTemplateValueParameter())
571 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
572 DITemplateValueParameter(Element)));
576 /// addToContextOwner - Add Die into the list of its context owner's children.
577 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
578 if (Context.isType()) {
579 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
580 ContextDIE->addChild(Die);
581 } else if (Context.isNameSpace()) {
582 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
583 ContextDIE->addChild(Die);
584 } else if (Context.isSubprogram()) {
585 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
586 ContextDIE->addChild(Die);
587 } else if (DIE *ContextDIE = getDIE(Context))
588 ContextDIE->addChild(Die);
593 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
595 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
599 DIE *TyDIE = getDIE(Ty);
604 TyDIE = new DIE(dwarf::DW_TAG_base_type);
605 insertDIE(Ty, TyDIE);
606 if (Ty.isBasicType())
607 constructTypeDIE(*TyDIE, DIBasicType(Ty));
608 else if (Ty.isCompositeType())
609 constructTypeDIE(*TyDIE, DICompositeType(Ty));
611 assert(Ty.isDerivedType() && "Unknown kind of DIType");
612 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
614 // If this is a named finished type then include it in the list of types
615 // for the accelerator tables.
616 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
617 bool IsImplementation = 0;
618 if (Ty.isCompositeType()) {
619 DICompositeType CT(Ty);
620 // A runtime language of 0 actually means C/C++ and that any
621 // non-negative value is some version of Objective-C/C++.
622 IsImplementation = (CT.getRunTimeLang() == 0) ||
623 CT.isObjcClassComplete();
625 unsigned Flags = IsImplementation ?
626 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
627 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
630 addToContextOwner(TyDIE, Ty.getContext());
634 /// addType - Add a new type attribute to the specified entity.
635 void CompileUnit::addType(DIE *Entity, DIType Ty, unsigned Attribute) {
639 // Check for pre-existence.
640 DIEEntry *Entry = getDIEEntry(Ty);
641 // If it exists then use the existing value.
643 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
648 DIE *Buffer = getOrCreateTypeDIE(Ty);
651 Entry = createDIEEntry(Buffer);
652 insertDIEEntry(Ty, Entry);
653 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
655 // If this is a complete composite type then include it in the
656 // list of global types.
660 /// addGlobalType - Add a new global type to the compile unit.
662 void CompileUnit::addGlobalType(DIType Ty) {
663 DIDescriptor Context = Ty.getContext();
664 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
665 && (!Context || Context.isCompileUnit() || Context.isFile()
666 || Context.isNameSpace()))
667 if (DIEEntry *Entry = getDIEEntry(Ty))
668 GlobalTypes[Ty.getName()] = Entry->getEntry();
671 /// addPubTypes - Add type for pubtypes section.
672 void CompileUnit::addPubTypes(DISubprogram SP) {
673 DICompositeType SPTy = SP.getType();
674 unsigned SPTag = SPTy.getTag();
675 if (SPTag != dwarf::DW_TAG_subroutine_type)
678 DIArray Args = SPTy.getTypeArray();
679 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
680 DIType ATy(Args.getElement(i));
687 /// constructTypeDIE - Construct basic type die from DIBasicType.
688 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
689 // Get core information.
690 StringRef Name = BTy.getName();
691 // Add name if not anonymous or intermediate type.
693 addString(&Buffer, dwarf::DW_AT_name, Name);
695 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
696 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
697 // Unspecified types has only name, nothing else.
701 Buffer.setTag(dwarf::DW_TAG_base_type);
702 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
705 uint64_t Size = BTy.getSizeInBits() >> 3;
706 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
709 /// constructTypeDIE - Construct derived type die from DIDerivedType.
710 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
711 // Get core information.
712 StringRef Name = DTy.getName();
713 uint64_t Size = DTy.getSizeInBits() >> 3;
714 unsigned Tag = DTy.getTag();
716 // FIXME - Workaround for templates.
717 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
721 // Map to main type, void will not have a type.
722 DIType FromTy = DTy.getTypeDerivedFrom();
723 addType(&Buffer, FromTy);
725 // Add name if not anonymous or intermediate type.
727 addString(&Buffer, dwarf::DW_AT_name, Name);
729 // Add size if non-zero (derived types might be zero-sized.)
730 if (Size && Tag != dwarf::DW_TAG_pointer_type)
731 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
733 // Add source line info if available and TyDesc is not a forward declaration.
734 if (!DTy.isForwardDecl())
735 addSourceLine(&Buffer, DTy);
738 /// constructTypeDIE - Construct type DIE from DICompositeType.
739 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
740 // Get core information.
741 StringRef Name = CTy.getName();
743 uint64_t Size = CTy.getSizeInBits() >> 3;
744 unsigned Tag = CTy.getTag();
748 case dwarf::DW_TAG_vector_type:
749 case dwarf::DW_TAG_array_type:
750 constructArrayTypeDIE(Buffer, &CTy);
752 case dwarf::DW_TAG_enumeration_type: {
753 DIArray Elements = CTy.getTypeArray();
755 // Add enumerators to enumeration type.
756 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
758 DIDescriptor Enum(Elements.getElement(i));
759 if (Enum.isEnumerator()) {
760 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
761 Buffer.addChild(ElemDie);
764 DIType DTy = CTy.getTypeDerivedFrom();
766 addType(&Buffer, DTy);
767 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
771 case dwarf::DW_TAG_subroutine_type: {
773 DIArray Elements = CTy.getTypeArray();
774 DIDescriptor RTy = Elements.getElement(0);
775 addType(&Buffer, DIType(RTy));
777 bool isPrototyped = true;
779 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
780 DIDescriptor Ty = Elements.getElement(i);
781 if (Ty.isUnspecifiedParameter()) {
782 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
783 Buffer.addChild(Arg);
784 isPrototyped = false;
786 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
787 addType(Arg, DIType(Ty));
788 Buffer.addChild(Arg);
791 // Add prototype flag if we're dealing with a C language and the
792 // function has been prototyped.
794 (Language == dwarf::DW_LANG_C89 ||
795 Language == dwarf::DW_LANG_C99 ||
796 Language == dwarf::DW_LANG_ObjC))
797 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
800 case dwarf::DW_TAG_structure_type:
801 case dwarf::DW_TAG_union_type:
802 case dwarf::DW_TAG_class_type: {
803 // Add elements to structure type.
804 DIArray Elements = CTy.getTypeArray();
806 // A forward struct declared type may not have elements available.
807 unsigned N = Elements.getNumElements();
811 // Add elements to structure type.
812 for (unsigned i = 0; i < N; ++i) {
813 DIDescriptor Element = Elements.getElement(i);
815 if (Element.isSubprogram()) {
816 DISubprogram SP(Element);
817 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
818 if (SP.isProtected())
819 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
820 dwarf::DW_ACCESS_protected);
821 else if (SP.isPrivate())
822 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
823 dwarf::DW_ACCESS_private);
825 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
826 dwarf::DW_ACCESS_public);
828 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
830 else if (Element.isVariable()) {
831 DIVariable DV(Element);
832 ElemDie = new DIE(dwarf::DW_TAG_variable);
833 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
834 addType(ElemDie, DV.getType());
835 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
836 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
837 addSourceLine(ElemDie, DV);
838 } else if (Element.isDerivedType()) {
839 DIDerivedType DDTy(Element);
840 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
841 ElemDie = new DIE(dwarf::DW_TAG_friend);
842 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
844 ElemDie = createMemberDIE(DIDerivedType(Element));
845 } else if (Element.isObjCProperty()) {
846 DIObjCProperty Property(Element);
847 ElemDie = new DIE(Property.getTag());
848 StringRef PropertyName = Property.getObjCPropertyName();
849 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
850 addType(ElemDie, Property.getType());
851 addSourceLine(ElemDie, Property);
852 StringRef GetterName = Property.getObjCPropertyGetterName();
853 if (!GetterName.empty())
854 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
855 StringRef SetterName = Property.getObjCPropertySetterName();
856 if (!SetterName.empty())
857 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
858 unsigned PropertyAttributes = 0;
859 if (Property.isReadOnlyObjCProperty())
860 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
861 if (Property.isReadWriteObjCProperty())
862 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
863 if (Property.isAssignObjCProperty())
864 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
865 if (Property.isRetainObjCProperty())
866 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
867 if (Property.isCopyObjCProperty())
868 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
869 if (Property.isNonAtomicObjCProperty())
870 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
871 if (PropertyAttributes)
872 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
875 DIEEntry *Entry = getDIEEntry(Element);
877 Entry = createDIEEntry(ElemDie);
878 insertDIEEntry(Element, Entry);
882 Buffer.addChild(ElemDie);
885 if (CTy.isAppleBlockExtension())
886 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
888 DICompositeType ContainingType = CTy.getContainingType();
889 if (DIDescriptor(ContainingType).isCompositeType())
890 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
891 getOrCreateTypeDIE(DIType(ContainingType)));
893 DIDescriptor Context = CTy.getContext();
894 addToContextOwner(&Buffer, Context);
897 if (CTy.isObjcClassComplete())
898 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
899 dwarf::DW_FORM_flag, 1);
901 // Add template parameters to a class, structure or union types.
902 // FIXME: The support isn't in the metadata for this yet.
903 if (Tag == dwarf::DW_TAG_class_type ||
904 Tag == dwarf::DW_TAG_structure_type ||
905 Tag == dwarf::DW_TAG_union_type)
906 addTemplateParams(Buffer, CTy.getTemplateParams());
914 // Add name if not anonymous or intermediate type.
916 addString(&Buffer, dwarf::DW_AT_name, Name);
918 if (Tag == dwarf::DW_TAG_enumeration_type ||
919 Tag == dwarf::DW_TAG_class_type ||
920 Tag == dwarf::DW_TAG_structure_type ||
921 Tag == dwarf::DW_TAG_union_type) {
922 // Add size if non-zero (derived types might be zero-sized.)
923 // TODO: Do we care about size for enum forward declarations?
925 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
926 else if (!CTy.isForwardDecl())
927 // Add zero size if it is not a forward declaration.
928 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
930 // If we're a forward decl, say so.
931 if (CTy.isForwardDecl())
932 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
934 // Add source line info if available.
935 if (!CTy.isForwardDecl())
936 addSourceLine(&Buffer, CTy);
938 // No harm in adding the runtime language to the declaration.
939 unsigned RLang = CTy.getRunTimeLang();
941 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
942 dwarf::DW_FORM_data1, RLang);
946 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
947 /// for the given DITemplateTypeParameter.
949 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
950 DIE *ParamDIE = getDIE(TP);
954 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
955 addType(ParamDIE, TP.getType());
956 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
960 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
961 /// for the given DITemplateValueParameter.
963 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){
964 DIE *ParamDIE = getDIE(TPV);
968 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
969 addType(ParamDIE, TPV.getType());
970 if (!TPV.getName().empty())
971 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
972 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
977 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
978 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
979 DIE *NDie = getDIE(NS);
982 NDie = new DIE(dwarf::DW_TAG_namespace);
984 if (!NS.getName().empty()) {
985 addString(NDie, dwarf::DW_AT_name, NS.getName());
986 addAccelNamespace(NS.getName(), NDie);
988 addAccelNamespace("(anonymous namespace)", NDie);
989 addSourceLine(NDie, NS);
990 addToContextOwner(NDie, NS.getContext());
994 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
995 /// printer to not emit usual symbol prefix before the symbol name is used then
996 /// return linkage name after skipping this special LLVM prefix.
997 static StringRef getRealLinkageName(StringRef LinkageName) {
999 if (LinkageName.startswith(StringRef(&One, 1)))
1000 return LinkageName.substr(1);
1004 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1005 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1006 DIE *SPDie = getDIE(SP);
1010 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1012 // DW_TAG_inlined_subroutine may refer to this DIE.
1013 insertDIE(SP, SPDie);
1015 DISubprogram SPDecl = SP.getFunctionDeclaration();
1016 DIE *DeclDie = NULL;
1017 if (SPDecl.isSubprogram()) {
1018 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1021 // Add to context owner.
1022 addToContextOwner(SPDie, SP.getContext());
1024 // Add function template parameters.
1025 addTemplateParams(*SPDie, SP.getTemplateParams());
1027 // Unfortunately this code needs to stay here instead of below the
1028 // AT_specification code in order to work around a bug in older
1029 // gdbs that requires the linkage name to resolve multiple template
1031 // TODO: Remove this set of code when we get rid of the old gdb
1033 StringRef LinkageName = SP.getLinkageName();
1034 if (!LinkageName.empty() && DD->useDarwinGDBCompat())
1035 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1036 getRealLinkageName(LinkageName));
1038 // If this DIE is going to refer declaration info using AT_specification
1039 // then there is no need to add other attributes.
1041 // Refer function declaration directly.
1042 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1048 // Add the linkage name if we have one.
1049 if (!LinkageName.empty() && !DD->useDarwinGDBCompat())
1050 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1051 getRealLinkageName(LinkageName));
1053 // Constructors and operators for anonymous aggregates do not have names.
1054 if (!SP.getName().empty())
1055 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1057 addSourceLine(SPDie, SP);
1059 // Add the prototype if we have a prototype and we have a C like
1061 if (SP.isPrototyped() &&
1062 (Language == dwarf::DW_LANG_C89 ||
1063 Language == dwarf::DW_LANG_C99 ||
1064 Language == dwarf::DW_LANG_ObjC))
1065 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1068 DICompositeType SPTy = SP.getType();
1069 DIArray Args = SPTy.getTypeArray();
1070 unsigned SPTag = SPTy.getTag();
1072 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1073 addType(SPDie, SPTy);
1075 addType(SPDie, DIType(Args.getElement(0)));
1077 unsigned VK = SP.getVirtuality();
1079 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1080 DIEBlock *Block = getDIEBlock();
1081 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1082 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1083 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1084 ContainingTypeMap.insert(std::make_pair(SPDie,
1085 SP.getContainingType()));
1088 if (!SP.isDefinition()) {
1089 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1091 // Add arguments. Do not add arguments for subprogram definition. They will
1092 // be handled while processing variables.
1093 DICompositeType SPTy = SP.getType();
1094 DIArray Args = SPTy.getTypeArray();
1095 unsigned SPTag = SPTy.getTag();
1097 if (SPTag == dwarf::DW_TAG_subroutine_type)
1098 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1099 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1100 DIType ATy = DIType(DIType(Args.getElement(i)));
1102 if (ATy.isArtificial())
1103 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1104 SPDie->addChild(Arg);
1108 if (SP.isArtificial())
1109 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1111 if (!SP.isLocalToUnit())
1112 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1114 if (SP.isOptimized())
1115 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1117 if (unsigned isa = Asm->getISAEncoding()) {
1118 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1124 // Return const expression if value is a GEP to access merged global
1126 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1127 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1128 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1129 if (!CE || CE->getNumOperands() != 3 ||
1130 CE->getOpcode() != Instruction::GetElementPtr)
1133 // First operand points to a global struct.
1134 Value *Ptr = CE->getOperand(0);
1135 if (!isa<GlobalValue>(Ptr) ||
1136 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1139 // Second operand is zero.
1140 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1141 if (!CI || !CI->isZero())
1144 // Third operand is offset.
1145 if (!isa<ConstantInt>(CE->getOperand(2)))
1151 /// createGlobalVariableDIE - create global variable DIE.
1152 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1153 // Check for pre-existence.
1157 DIGlobalVariable GV(N);
1161 DIE *VariableDIE = new DIE(GV.getTag());
1163 insertDIE(N, VariableDIE);
1166 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1167 StringRef LinkageName = GV.getLinkageName();
1168 bool isGlobalVariable = GV.getGlobal() != NULL;
1169 if (!LinkageName.empty() && isGlobalVariable)
1170 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1171 getRealLinkageName(LinkageName));
1173 DIType GTy = GV.getType();
1174 addType(VariableDIE, GTy);
1176 // Add scoping info.
1177 if (!GV.isLocalToUnit())
1178 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1180 // Add line number info.
1181 addSourceLine(VariableDIE, GV);
1182 // Add to context owner.
1183 DIDescriptor GVContext = GV.getContext();
1184 addToContextOwner(VariableDIE, GVContext);
1186 bool addToAccelTable = false;
1187 DIE *VariableSpecDIE = NULL;
1188 if (isGlobalVariable) {
1189 addToAccelTable = true;
1190 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1191 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1192 addLabel(Block, 0, dwarf::DW_FORM_udata,
1193 Asm->Mang->getSymbol(GV.getGlobal()));
1194 // Do not create specification DIE if context is either compile unit
1196 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1197 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1198 // Create specification DIE.
1199 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1200 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1201 dwarf::DW_FORM_ref4, VariableDIE);
1202 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1203 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1205 addDie(VariableSpecDIE);
1207 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1209 } else if (const ConstantInt *CI =
1210 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1211 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1212 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1213 addToAccelTable = true;
1214 // GV is a merged global.
1215 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1216 Value *Ptr = CE->getOperand(0);
1217 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1218 addLabel(Block, 0, dwarf::DW_FORM_udata,
1219 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1220 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1221 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1222 addUInt(Block, 0, dwarf::DW_FORM_udata,
1223 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1224 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1225 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1228 if (addToAccelTable) {
1229 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1230 addAccelName(GV.getName(), AddrDIE);
1232 // If the linkage name is different than the name, go ahead and output
1233 // that as well into the name table.
1234 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1235 addAccelName(GV.getLinkageName(), AddrDIE);
1241 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1242 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1244 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1245 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1246 uint64_t L = SR.getLo();
1247 uint64_t H = SR.getHi();
1249 // The L value defines the lower bounds which is typically zero for C/C++. The
1250 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1251 // of the array. If L > H then do not emit DW_AT_lower_bound and
1252 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1253 // array has one element and in such case do not emit lower bound.
1256 Buffer.addChild(DW_Subrange);
1260 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1261 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1262 Buffer.addChild(DW_Subrange);
1265 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1266 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1267 DICompositeType *CTy) {
1268 Buffer.setTag(dwarf::DW_TAG_array_type);
1269 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1270 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1272 // Emit derived type.
1273 addType(&Buffer, CTy->getTypeDerivedFrom());
1274 DIArray Elements = CTy->getTypeArray();
1276 // Get an anonymous type for index type.
1277 DIE *IdxTy = getIndexTyDie();
1279 // Construct an anonymous type for index type.
1280 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1281 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1282 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1283 dwarf::DW_ATE_signed);
1285 setIndexTyDie(IdxTy);
1288 // Add subranges to array type.
1289 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1290 DIDescriptor Element = Elements.getElement(i);
1291 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1292 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1296 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1297 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1298 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1299 StringRef Name = ETy.getName();
1300 addString(Enumerator, dwarf::DW_AT_name, Name);
1301 int64_t Value = ETy.getEnumValue();
1302 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1306 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1308 void CompileUnit::constructContainingTypeDIEs() {
1309 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1310 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1311 DIE *SPDie = CI->first;
1312 const MDNode *N = CI->second;
1314 DIE *NDie = getDIE(N);
1315 if (!NDie) continue;
1316 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1320 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1321 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1322 StringRef Name = DV->getName();
1326 // Translate tag to proper Dwarf tag.
1327 unsigned Tag = DV->getTag();
1329 // Define variable debug information entry.
1330 DIE *VariableDie = new DIE(Tag);
1331 DbgVariable *AbsVar = DV->getAbstractVariable();
1332 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1334 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1335 dwarf::DW_FORM_ref4, AbsDIE);
1337 addString(VariableDie, dwarf::DW_AT_name, Name);
1338 addSourceLine(VariableDie, DV->getVariable());
1339 addType(VariableDie, DV->getType());
1342 if (DV->isArtificial())
1343 addUInt(VariableDie, dwarf::DW_AT_artificial,
1344 dwarf::DW_FORM_flag, 1);
1346 if (isScopeAbstract) {
1347 DV->setDIE(VariableDie);
1351 // Add variable address.
1353 unsigned Offset = DV->getDotDebugLocOffset();
1354 if (Offset != ~0U) {
1355 addLabel(VariableDie, dwarf::DW_AT_location,
1356 dwarf::DW_FORM_data4,
1357 Asm->GetTempSymbol("debug_loc", Offset));
1358 DV->setDIE(VariableDie);
1362 // Check if variable is described by a DBG_VALUE instruction.
1363 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1364 bool updated = false;
1365 if (DVInsn->getNumOperands() == 3) {
1366 if (DVInsn->getOperand(0).isReg()) {
1367 const MachineOperand RegOp = DVInsn->getOperand(0);
1368 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1369 if (DVInsn->getOperand(1).isImm() &&
1370 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1371 unsigned FrameReg = 0;
1372 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1374 TFI->getFrameIndexReference(*Asm->MF,
1375 DVInsn->getOperand(1).getImm(),
1377 MachineLocation Location(FrameReg, Offset);
1378 addVariableAddress(DV, VariableDie, Location);
1380 } else if (RegOp.getReg())
1381 addVariableAddress(DV, VariableDie,
1382 MachineLocation(RegOp.getReg()));
1385 else if (DVInsn->getOperand(0).isImm())
1387 addConstantValue(VariableDie, DVInsn->getOperand(0),
1389 else if (DVInsn->getOperand(0).isFPImm())
1391 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1392 else if (DVInsn->getOperand(0).isCImm())
1394 addConstantValue(VariableDie,
1395 DVInsn->getOperand(0).getCImm(),
1396 DV->getType().isUnsignedDIType());
1398 addVariableAddress(DV, VariableDie,
1399 Asm->getDebugValueLocation(DVInsn));
1403 // If variableDie is not updated then DBG_VALUE instruction does not
1404 // have valid variable info.
1408 DV->setDIE(VariableDie);
1411 // .. else use frame index.
1412 int FI = DV->getFrameIndex();
1414 unsigned FrameReg = 0;
1415 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1417 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1418 MachineLocation Location(FrameReg, Offset);
1419 addVariableAddress(DV, VariableDie, Location);
1423 DV->setDIE(VariableDie);
1427 /// createMemberDIE - Create new member DIE.
1428 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1429 DIE *MemberDie = new DIE(DT.getTag());
1430 StringRef Name = DT.getName();
1432 addString(MemberDie, dwarf::DW_AT_name, Name);
1434 addType(MemberDie, DT.getTypeDerivedFrom());
1436 addSourceLine(MemberDie, DT);
1438 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1439 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1441 uint64_t Size = DT.getSizeInBits();
1442 uint64_t FieldSize = DT.getOriginalTypeSize();
1444 if (Size != FieldSize) {
1446 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1447 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1449 uint64_t Offset = DT.getOffsetInBits();
1450 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1451 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1452 uint64_t FieldOffset = (HiMark - FieldSize);
1453 Offset -= FieldOffset;
1455 // Maybe we need to work from the other end.
1456 if (Asm->getTargetData().isLittleEndian())
1457 Offset = FieldSize - (Offset + Size);
1458 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1460 // Here WD_AT_data_member_location points to the anonymous
1461 // field that includes this bit field.
1462 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1465 // This is not a bitfield.
1466 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1468 if (DT.getTag() == dwarf::DW_TAG_inheritance
1469 && DT.isVirtual()) {
1471 // For C++, virtual base classes are not at fixed offset. Use following
1472 // expression to extract appropriate offset from vtable.
1473 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1475 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1476 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1477 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1478 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1479 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1480 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1481 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1482 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1484 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1487 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1489 if (DT.isProtected())
1490 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1491 dwarf::DW_ACCESS_protected);
1492 else if (DT.isPrivate())
1493 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1494 dwarf::DW_ACCESS_private);
1495 // Otherwise C++ member and base classes are considered public.
1497 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1498 dwarf::DW_ACCESS_public);
1500 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1501 dwarf::DW_VIRTUALITY_virtual);
1503 // Objective-C properties.
1504 if (MDNode *PNode = DT.getObjCProperty())
1505 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1506 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1509 // This is only for backward compatibility.
1510 StringRef PropertyName = DT.getObjCPropertyName();
1511 if (!PropertyName.empty()) {
1512 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1513 StringRef GetterName = DT.getObjCPropertyGetterName();
1514 if (!GetterName.empty())
1515 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1516 StringRef SetterName = DT.getObjCPropertySetterName();
1517 if (!SetterName.empty())
1518 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1519 unsigned PropertyAttributes = 0;
1520 if (DT.isReadOnlyObjCProperty())
1521 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1522 if (DT.isReadWriteObjCProperty())
1523 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1524 if (DT.isAssignObjCProperty())
1525 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1526 if (DT.isRetainObjCProperty())
1527 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1528 if (DT.isCopyObjCProperty())
1529 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1530 if (DT.isNonAtomicObjCProperty())
1531 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1532 if (PropertyAttributes)
1533 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1534 PropertyAttributes);