1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf compile unit.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
16 #include "DwarfAccelTable.h"
17 #include "DwarfCompileUnit.h"
18 #include "DwarfDebug.h"
19 #include "llvm/Constants.h"
20 #include "llvm/GlobalVariable.h"
21 #include "llvm/Instructions.h"
22 #include "llvm/Analysis/DIBuilder.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Target/Mangler.h"
25 #include "llvm/Target/TargetData.h"
26 #include "llvm/Target/TargetFrameLowering.h"
27 #include "llvm/Target/TargetMachine.h"
28 #include "llvm/Target/TargetRegisterInfo.h"
29 #include "llvm/ADT/APFloat.h"
30 #include "llvm/Support/ErrorHandling.h"
34 /// CompileUnit - Compile unit constructor.
35 CompileUnit::CompileUnit(unsigned I, unsigned L, DIE *D, AsmPrinter *A,
37 : ID(I), Language(L), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
38 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
41 /// ~CompileUnit - Destructor for compile unit.
42 CompileUnit::~CompileUnit() {
43 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
44 DIEBlocks[j]->~DIEBlock();
47 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
48 /// information entry.
49 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
50 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
54 /// addUInt - Add an unsigned integer attribute data and value.
56 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
57 unsigned Form, uint64_t Integer) {
58 if (!Form) Form = DIEInteger::BestForm(false, Integer);
59 DIEValue *Value = Integer == 1 ?
60 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
61 Die->addValue(Attribute, Form, Value);
64 /// addSInt - Add an signed integer attribute data and value.
66 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
67 unsigned Form, int64_t Integer) {
68 if (!Form) Form = DIEInteger::BestForm(true, Integer);
69 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
70 Die->addValue(Attribute, Form, Value);
73 /// addString - Add a string attribute data and value. We always emit a
74 /// reference to the string pool instead of immediate strings so that DIEs have
75 /// more predictable sizes.
76 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
77 MCSymbol *Symb = DD->getStringPoolEntry(String);
79 if (Asm->needsRelocationsForDwarfStringPool())
80 Value = new (DIEValueAllocator) DIELabel(Symb);
82 MCSymbol *StringPool = DD->getStringPool();
83 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
85 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
88 /// addLabel - Add a Dwarf label attribute data and value.
90 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
91 const MCSymbol *Label) {
92 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
93 Die->addValue(Attribute, Form, Value);
96 /// addDelta - Add a label delta attribute data and value.
98 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
99 const MCSymbol *Hi, const MCSymbol *Lo) {
100 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
101 Die->addValue(Attribute, Form, Value);
104 /// addDIEEntry - Add a DIE attribute data and value.
106 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
108 Die->addValue(Attribute, Form, createDIEEntry(Entry));
111 /// addBlock - Add block data.
113 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
115 Block->ComputeSize(Asm);
116 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
117 Die->addValue(Attribute, Block->BestForm(), Block);
120 /// addSourceLine - Add location information to specified debug information
122 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
127 unsigned Line = V.getLineNumber();
130 unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
131 V.getContext().getDirectory());
132 assert(FileID && "Invalid file id");
133 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
134 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
137 /// addSourceLine - Add location information to specified debug information
139 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
140 // Verify global variable.
144 unsigned Line = G.getLineNumber();
147 unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(), G.getDirectory());
148 assert(FileID && "Invalid file id");
149 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
150 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
153 /// addSourceLine - Add location information to specified debug information
155 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
156 // Verify subprogram.
160 // If the line number is 0, don't add it.
161 unsigned Line = SP.getLineNumber();
165 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
167 assert(FileID && "Invalid file id");
168 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
169 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
172 /// addSourceLine - Add location information to specified debug information
174 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
179 unsigned Line = Ty.getLineNumber();
182 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
184 assert(FileID && "Invalid file id");
185 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
186 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
189 /// addSourceLine - Add location information to specified debug information
191 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
196 unsigned Line = Ty.getLineNumber();
199 DIFile File = Ty.getFile();
200 unsigned FileID = DD->GetOrCreateSourceID(File.getFilename(),
201 File.getDirectory());
202 assert(FileID && "Invalid file id");
203 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
204 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
207 /// addSourceLine - Add location information to specified debug information
209 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
214 unsigned Line = NS.getLineNumber();
217 StringRef FN = NS.getFilename();
219 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
220 assert(FileID && "Invalid file id");
221 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
222 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
225 /// addVariableAddress - Add DW_AT_location attribute for a
226 /// DbgVariable based on provided MachineLocation.
227 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
228 MachineLocation Location) {
229 if (DV->variableHasComplexAddress())
230 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
231 else if (DV->isBlockByrefVariable())
232 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
234 addAddress(Die, dwarf::DW_AT_location, Location);
237 /// addRegisterOp - Add register operand.
238 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
239 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
240 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
242 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
244 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
245 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
249 /// addRegisterOffset - Add register offset.
250 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
252 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
253 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
254 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
255 if (Reg == TRI->getFrameRegister(*Asm->MF))
256 // If variable offset is based in frame register then use fbreg.
257 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
259 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
261 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
262 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
264 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
267 /// addAddress - Add an address attribute to a die based on the location
269 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
270 const MachineLocation &Location) {
271 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
273 if (Location.isReg())
274 addRegisterOp(Block, Location.getReg());
276 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
278 // Now attach the location information to the DIE.
279 addBlock(Die, Attribute, 0, Block);
282 /// addComplexAddress - Start with the address based on the location provided,
283 /// and generate the DWARF information necessary to find the actual variable
284 /// given the extra address information encoded in the DIVariable, starting from
285 /// the starting location. Add the DWARF information to the die.
287 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
289 const MachineLocation &Location) {
290 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
291 unsigned N = DV->getNumAddrElements();
293 if (Location.isReg()) {
294 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
295 // If first address element is OpPlus then emit
296 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
297 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
300 addRegisterOp(Block, Location.getReg());
303 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
306 uint64_t Element = DV->getAddrElement(i);
307 if (Element == DIBuilder::OpPlus) {
308 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
309 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
310 } else if (Element == DIBuilder::OpDeref) {
311 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
312 } else llvm_unreachable("unknown DIBuilder Opcode");
315 // Now attach the location information to the DIE.
316 addBlock(Die, Attribute, 0, Block);
319 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
320 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
321 gives the variable VarName either the struct, or a pointer to the struct, as
322 its type. This is necessary for various behind-the-scenes things the
323 compiler needs to do with by-reference variables in Blocks.
325 However, as far as the original *programmer* is concerned, the variable
326 should still have type 'SomeType', as originally declared.
328 The function getBlockByrefType dives into the __Block_byref_x_VarName
329 struct to find the original type of the variable, which is then assigned to
330 the variable's Debug Information Entry as its real type. So far, so good.
331 However now the debugger will expect the variable VarName to have the type
332 SomeType. So we need the location attribute for the variable to be an
333 expression that explains to the debugger how to navigate through the
334 pointers and struct to find the actual variable of type SomeType.
336 The following function does just that. We start by getting
337 the "normal" location for the variable. This will be the location
338 of either the struct __Block_byref_x_VarName or the pointer to the
339 struct __Block_byref_x_VarName.
341 The struct will look something like:
343 struct __Block_byref_x_VarName {
345 struct __Block_byref_x_VarName *forwarding;
346 ... <various other fields>
348 ... <maybe more fields>
351 If we are given the struct directly (as our starting point) we
352 need to tell the debugger to:
354 1). Add the offset of the forwarding field.
356 2). Follow that pointer to get the real __Block_byref_x_VarName
357 struct to use (the real one may have been copied onto the heap).
359 3). Add the offset for the field VarName, to find the actual variable.
361 If we started with a pointer to the struct, then we need to
362 dereference that pointer first, before the other steps.
363 Translating this into DWARF ops, we will need to append the following
364 to the current location description for the variable:
366 DW_OP_deref -- optional, if we start with a pointer
367 DW_OP_plus_uconst <forward_fld_offset>
369 DW_OP_plus_uconst <varName_fld_offset>
371 That is what this function does. */
373 /// addBlockByrefAddress - Start with the address based on the location
374 /// provided, and generate the DWARF information necessary to find the
375 /// actual Block variable (navigating the Block struct) based on the
376 /// starting location. Add the DWARF information to the die. For
377 /// more information, read large comment just above here.
379 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
381 const MachineLocation &Location) {
382 DIType Ty = DV->getType();
384 unsigned Tag = Ty.getTag();
385 bool isPointer = false;
387 StringRef varName = DV->getName();
389 if (Tag == dwarf::DW_TAG_pointer_type) {
390 DIDerivedType DTy = DIDerivedType(Ty);
391 TmpTy = DTy.getTypeDerivedFrom();
395 DICompositeType blockStruct = DICompositeType(TmpTy);
397 // Find the __forwarding field and the variable field in the __Block_byref
399 DIArray Fields = blockStruct.getTypeArray();
400 DIDescriptor varField = DIDescriptor();
401 DIDescriptor forwardingField = DIDescriptor();
403 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
404 DIDescriptor Element = Fields.getElement(i);
405 DIDerivedType DT = DIDerivedType(Element);
406 StringRef fieldName = DT.getName();
407 if (fieldName == "__forwarding")
408 forwardingField = Element;
409 else if (fieldName == varName)
413 // Get the offsets for the forwarding field and the variable field.
414 unsigned forwardingFieldOffset =
415 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
416 unsigned varFieldOffset =
417 DIDerivedType(varField).getOffsetInBits() >> 3;
419 // Decode the original location, and use that as the start of the byref
420 // variable's location.
421 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
422 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
423 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
425 if (Location.isReg()) {
427 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
429 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
430 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
434 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
436 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
437 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
440 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
443 // If we started with a pointer to the __Block_byref... struct, then
444 // the first thing we need to do is dereference the pointer (DW_OP_deref).
446 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
448 // Next add the offset for the '__forwarding' field:
449 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
450 // adding the offset if it's 0.
451 if (forwardingFieldOffset > 0) {
452 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
453 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
456 // Now dereference the __forwarding field to get to the real __Block_byref
457 // struct: DW_OP_deref.
458 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
460 // Now that we've got the real __Block_byref... struct, add the offset
461 // for the variable's field to get to the location of the actual variable:
462 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
463 if (varFieldOffset > 0) {
464 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
465 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
468 // Now attach the location information to the DIE.
469 addBlock(Die, Attribute, 0, Block);
472 /// isTypeSigned - Return true if the type is signed.
473 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
474 if (Ty.isDerivedType())
475 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
476 if (Ty.isBasicType())
477 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
478 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
479 *SizeInBits = Ty.getSizeInBits();
485 /// addConstantValue - Add constant value entry in variable DIE.
486 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
488 assert(MO.isImm() && "Invalid machine operand!");
489 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
491 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
492 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
493 switch (SizeInBits) {
494 case 8: Form = dwarf::DW_FORM_data1; break;
495 case 16: Form = dwarf::DW_FORM_data2; break;
496 case 32: Form = dwarf::DW_FORM_data4; break;
497 case 64: Form = dwarf::DW_FORM_data8; break;
500 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
501 : addUInt(Block, 0, Form, MO.getImm());
503 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
507 /// addConstantFPValue - Add constant value entry in variable DIE.
508 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
509 assert (MO.isFPImm() && "Invalid machine operand!");
510 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
511 APFloat FPImm = MO.getFPImm()->getValueAPF();
513 // Get the raw data form of the floating point.
514 const APInt FltVal = FPImm.bitcastToAPInt();
515 const char *FltPtr = (const char*)FltVal.getRawData();
517 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
518 bool LittleEndian = Asm->getTargetData().isLittleEndian();
519 int Incr = (LittleEndian ? 1 : -1);
520 int Start = (LittleEndian ? 0 : NumBytes - 1);
521 int Stop = (LittleEndian ? NumBytes : -1);
523 // Output the constant to DWARF one byte at a time.
524 for (; Start != Stop; Start += Incr)
525 addUInt(Block, 0, dwarf::DW_FORM_data1,
526 (unsigned char)0xFF & FltPtr[Start]);
528 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
532 /// addConstantValue - Add constant value entry in variable DIE.
533 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
535 unsigned CIBitWidth = CI->getBitWidth();
536 if (CIBitWidth <= 64) {
538 switch (CIBitWidth) {
539 case 8: form = dwarf::DW_FORM_data1; break;
540 case 16: form = dwarf::DW_FORM_data2; break;
541 case 32: form = dwarf::DW_FORM_data4; break;
542 case 64: form = dwarf::DW_FORM_data8; break;
544 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
547 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
549 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
553 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
555 // Get the raw data form of the large APInt.
556 const APInt Val = CI->getValue();
557 const uint64_t *Ptr64 = Val.getRawData();
559 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
560 bool LittleEndian = Asm->getTargetData().isLittleEndian();
562 // Output the constant to DWARF one byte at a time.
563 for (int i = 0; i < NumBytes; i++) {
566 c = Ptr64[i / 8] >> (8 * (i & 7));
568 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
569 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
572 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
576 /// addTemplateParams - Add template parameters in buffer.
577 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
578 // Add template parameters.
579 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
580 DIDescriptor Element = TParams.getElement(i);
581 if (Element.isTemplateTypeParameter())
582 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
583 DITemplateTypeParameter(Element)));
584 else if (Element.isTemplateValueParameter())
585 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
586 DITemplateValueParameter(Element)));
590 /// addToContextOwner - Add Die into the list of its context owner's children.
591 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
592 if (Context.isType()) {
593 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
594 ContextDIE->addChild(Die);
595 } else if (Context.isNameSpace()) {
596 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
597 ContextDIE->addChild(Die);
598 } else if (Context.isSubprogram()) {
599 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
600 ContextDIE->addChild(Die);
601 } else if (DIE *ContextDIE = getDIE(Context))
602 ContextDIE->addChild(Die);
607 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
609 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
613 DIE *TyDIE = getDIE(Ty);
618 TyDIE = new DIE(dwarf::DW_TAG_base_type);
619 insertDIE(Ty, TyDIE);
620 if (Ty.isBasicType())
621 constructTypeDIE(*TyDIE, DIBasicType(Ty));
622 else if (Ty.isCompositeType())
623 constructTypeDIE(*TyDIE, DICompositeType(Ty));
625 assert(Ty.isDerivedType() && "Unknown kind of DIType");
626 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
628 // If this is a named finished type then include it in the list of types
629 // for the accelerator tables.
630 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
631 bool IsImplementation = 0;
632 if (Ty.isCompositeType()) {
633 DICompositeType CT(Ty);
634 // A runtime language of 0 actually means C/C++ and that any
635 // non-negative value is some version of Objective-C/C++.
636 IsImplementation = (CT.getRunTimeLang() == 0) ||
637 CT.isObjcClassComplete();
639 unsigned Flags = IsImplementation ?
640 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
641 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
644 addToContextOwner(TyDIE, Ty.getContext());
648 /// addType - Add a new type attribute to the specified entity.
649 void CompileUnit::addType(DIE *Entity, DIType Ty,
650 unsigned Attribute) {
654 // Check for pre-existence.
655 DIEEntry *Entry = getDIEEntry(Ty);
656 // If it exists then use the existing value.
658 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
663 DIE *Buffer = getOrCreateTypeDIE(Ty);
666 Entry = createDIEEntry(Buffer);
667 insertDIEEntry(Ty, Entry);
668 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
670 // If this is a complete composite type then include it in the
671 // list of global types.
675 /// addGlobalType - Add a new global type to the compile unit.
677 void CompileUnit::addGlobalType(DIType Ty) {
678 DIDescriptor Context = Ty.getContext();
679 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
680 && (!Context || Context.isCompileUnit() || Context.isFile()
681 || Context.isNameSpace()))
682 if (DIEEntry *Entry = getDIEEntry(Ty))
683 GlobalTypes[Ty.getName()] = Entry->getEntry();
686 /// addPubTypes - Add type for pubtypes section.
687 void CompileUnit::addPubTypes(DISubprogram SP) {
688 DICompositeType SPTy = SP.getType();
689 unsigned SPTag = SPTy.getTag();
690 if (SPTag != dwarf::DW_TAG_subroutine_type)
693 DIArray Args = SPTy.getTypeArray();
694 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
695 DIType ATy(Args.getElement(i));
702 /// constructTypeDIE - Construct basic type die from DIBasicType.
703 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
704 // Get core information.
705 StringRef Name = BTy.getName();
706 // Add name if not anonymous or intermediate type.
708 addString(&Buffer, dwarf::DW_AT_name, Name);
710 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
711 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
712 // Unspecified types has only name, nothing else.
716 Buffer.setTag(dwarf::DW_TAG_base_type);
717 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
720 uint64_t Size = BTy.getSizeInBits() >> 3;
721 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
724 /// constructTypeDIE - Construct derived type die from DIDerivedType.
725 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
726 // Get core information.
727 StringRef Name = DTy.getName();
728 uint64_t Size = DTy.getSizeInBits() >> 3;
729 unsigned Tag = DTy.getTag();
731 // FIXME - Workaround for templates.
732 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
736 // Map to main type, void will not have a type.
737 DIType FromTy = DTy.getTypeDerivedFrom();
738 addType(&Buffer, FromTy);
740 // Add name if not anonymous or intermediate type.
742 addString(&Buffer, dwarf::DW_AT_name, Name);
744 // Add size if non-zero (derived types might be zero-sized.)
745 if (Size && Tag != dwarf::DW_TAG_pointer_type)
746 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
748 // Add source line info if available and TyDesc is not a forward declaration.
749 if (!DTy.isForwardDecl())
750 addSourceLine(&Buffer, DTy);
753 /// constructTypeDIE - Construct type DIE from DICompositeType.
754 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
755 // Get core information.
756 StringRef Name = CTy.getName();
758 uint64_t Size = CTy.getSizeInBits() >> 3;
759 unsigned Tag = CTy.getTag();
763 case dwarf::DW_TAG_vector_type:
764 case dwarf::DW_TAG_array_type:
765 constructArrayTypeDIE(Buffer, &CTy);
767 case dwarf::DW_TAG_enumeration_type: {
768 DIArray Elements = CTy.getTypeArray();
770 // Add enumerators to enumeration type.
771 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
773 DIDescriptor Enum(Elements.getElement(i));
774 if (Enum.isEnumerator()) {
775 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
776 Buffer.addChild(ElemDie);
781 case dwarf::DW_TAG_subroutine_type: {
783 DIArray Elements = CTy.getTypeArray();
784 DIDescriptor RTy = Elements.getElement(0);
785 addType(&Buffer, DIType(RTy));
787 bool isPrototyped = true;
789 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
790 DIDescriptor Ty = Elements.getElement(i);
791 if (Ty.isUnspecifiedParameter()) {
792 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
793 Buffer.addChild(Arg);
794 isPrototyped = false;
796 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
797 addType(Arg, DIType(Ty));
798 Buffer.addChild(Arg);
801 // Add prototype flag if we're dealing with a C language and the
802 // function has been prototyped.
804 (Language == dwarf::DW_LANG_C89 ||
805 Language == dwarf::DW_LANG_C99 ||
806 Language == dwarf::DW_LANG_ObjC))
807 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
810 case dwarf::DW_TAG_structure_type:
811 case dwarf::DW_TAG_union_type:
812 case dwarf::DW_TAG_class_type: {
813 // Add elements to structure type.
814 DIArray Elements = CTy.getTypeArray();
816 // A forward struct declared type may not have elements available.
817 unsigned N = Elements.getNumElements();
821 // Add elements to structure type.
822 for (unsigned i = 0; i < N; ++i) {
823 DIDescriptor Element = Elements.getElement(i);
825 if (Element.isSubprogram()) {
826 DISubprogram SP(Element);
827 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
828 if (SP.isProtected())
829 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
830 dwarf::DW_ACCESS_protected);
831 else if (SP.isPrivate())
832 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
833 dwarf::DW_ACCESS_private);
835 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
836 dwarf::DW_ACCESS_public);
838 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
840 else if (Element.isVariable()) {
841 DIVariable DV(Element);
842 ElemDie = new DIE(dwarf::DW_TAG_variable);
843 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
844 addType(ElemDie, DV.getType());
845 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
846 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
847 addSourceLine(ElemDie, DV);
848 } else if (Element.isDerivedType()) {
849 DIDerivedType DDTy(Element);
850 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
851 ElemDie = new DIE(dwarf::DW_TAG_friend);
852 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
854 ElemDie = createMemberDIE(DIDerivedType(Element));
855 } else if (Element.isObjCProperty()) {
856 DIObjCProperty Property(Element);
857 ElemDie = new DIE(Property.getTag());
858 StringRef PropertyName = Property.getObjCPropertyName();
859 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
860 addType(ElemDie, Property.getType());
861 addSourceLine(ElemDie, Property);
862 StringRef GetterName = Property.getObjCPropertyGetterName();
863 if (!GetterName.empty())
864 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
865 StringRef SetterName = Property.getObjCPropertySetterName();
866 if (!SetterName.empty())
867 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
868 unsigned PropertyAttributes = 0;
869 if (Property.isReadOnlyObjCProperty())
870 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
871 if (Property.isReadWriteObjCProperty())
872 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
873 if (Property.isAssignObjCProperty())
874 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
875 if (Property.isRetainObjCProperty())
876 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
877 if (Property.isCopyObjCProperty())
878 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
879 if (Property.isNonAtomicObjCProperty())
880 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
881 if (PropertyAttributes)
882 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
885 DIEEntry *Entry = getDIEEntry(Element);
887 Entry = createDIEEntry(ElemDie);
888 insertDIEEntry(Element, Entry);
892 Buffer.addChild(ElemDie);
895 if (CTy.isAppleBlockExtension())
896 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
898 DICompositeType ContainingType = CTy.getContainingType();
899 if (DIDescriptor(ContainingType).isCompositeType())
900 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
901 getOrCreateTypeDIE(DIType(ContainingType)));
903 DIDescriptor Context = CTy.getContext();
904 addToContextOwner(&Buffer, Context);
907 if (CTy.isObjcClassComplete())
908 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
909 dwarf::DW_FORM_flag, 1);
911 // Add template parameters to a class, structure or union types.
912 // FIXME: The support isn't in the metadata for this yet.
913 if (Tag == dwarf::DW_TAG_class_type ||
914 Tag == dwarf::DW_TAG_structure_type ||
915 Tag == dwarf::DW_TAG_union_type)
916 addTemplateParams(Buffer, CTy.getTemplateParams());
924 // Add name if not anonymous or intermediate type.
926 addString(&Buffer, dwarf::DW_AT_name, Name);
928 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
929 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
931 // Add size if non-zero (derived types might be zero-sized.)
933 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
935 // Add zero size if it is not a forward declaration.
936 if (CTy.isForwardDecl())
937 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
942 // Add source line info if available.
943 if (!CTy.isForwardDecl())
944 addSourceLine(&Buffer, CTy);
946 // No harm in adding the runtime language to the declaration.
947 unsigned RLang = CTy.getRunTimeLang();
949 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
950 dwarf::DW_FORM_data1, RLang);
954 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
955 /// for the given DITemplateTypeParameter.
957 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
958 DIE *ParamDIE = getDIE(TP);
962 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
963 addType(ParamDIE, TP.getType());
964 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
968 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
969 /// for the given DITemplateValueParameter.
971 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
972 DIE *ParamDIE = getDIE(TPV);
976 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
977 addType(ParamDIE, TPV.getType());
978 if (!TPV.getName().empty())
979 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
980 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
985 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
986 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
987 DIE *NDie = getDIE(NS);
990 NDie = new DIE(dwarf::DW_TAG_namespace);
992 if (!NS.getName().empty()) {
993 addString(NDie, dwarf::DW_AT_name, NS.getName());
994 addAccelNamespace(NS.getName(), NDie);
996 addAccelNamespace("(anonymous namespace)", NDie);
997 addSourceLine(NDie, NS);
998 addToContextOwner(NDie, NS.getContext());
1002 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1003 /// printer to not emit usual symbol prefix before the symbol name is used then
1004 /// return linkage name after skipping this special LLVM prefix.
1005 static StringRef getRealLinkageName(StringRef LinkageName) {
1007 if (LinkageName.startswith(StringRef(&One, 1)))
1008 return LinkageName.substr(1);
1012 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1013 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1014 DIE *SPDie = getDIE(SP);
1018 DISubprogram SPDecl = SP.getFunctionDeclaration();
1019 DIE *DeclDie = NULL;
1020 if (SPDecl.isSubprogram()) {
1021 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1024 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1026 // DW_TAG_inlined_subroutine may refer to this DIE.
1027 insertDIE(SP, SPDie);
1029 // Add to context owner.
1030 addToContextOwner(SPDie, SP.getContext());
1032 // Add function template parameters.
1033 addTemplateParams(*SPDie, SP.getTemplateParams());
1035 // Unfortunately this code needs to stay here to work around
1036 // a bug in older gdbs that requires the linkage name to resolve
1037 // multiple template functions.
1038 StringRef LinkageName = SP.getLinkageName();
1039 if (!LinkageName.empty())
1040 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1041 getRealLinkageName(LinkageName));
1043 // If this DIE is going to refer declaration info using AT_specification
1044 // then there is no need to add other attributes.
1046 // Refer function declaration directly.
1047 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
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, DIE *IndexTy){
1243 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1244 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1245 uint64_t L = SR.getLo();
1246 uint64_t H = SR.getHi();
1248 // The L value defines the lower bounds which is typically zero for C/C++. The
1249 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1250 // of the array. If L > H then do not emit DW_AT_lower_bound and
1251 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1252 // array has one element and in such case do not emit lower bound.
1255 Buffer.addChild(DW_Subrange);
1259 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1260 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1261 Buffer.addChild(DW_Subrange);
1264 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1265 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1266 DICompositeType *CTy) {
1267 Buffer.setTag(dwarf::DW_TAG_array_type);
1268 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1269 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1271 // Emit derived type.
1272 addType(&Buffer, CTy->getTypeDerivedFrom());
1273 DIArray Elements = CTy->getTypeArray();
1275 // Get an anonymous type for index type.
1276 DIE *IdxTy = getIndexTyDie();
1278 // Construct an anonymous type for index type.
1279 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1280 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1281 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1282 dwarf::DW_ATE_signed);
1284 setIndexTyDie(IdxTy);
1287 // Add subranges to array type.
1288 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1289 DIDescriptor Element = Elements.getElement(i);
1290 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1291 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1295 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1296 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1297 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1298 StringRef Name = ETy.getName();
1299 addString(Enumerator, dwarf::DW_AT_name, Name);
1300 int64_t Value = ETy.getEnumValue();
1301 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1305 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1307 void CompileUnit::constructContainingTypeDIEs() {
1308 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1309 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1310 DIE *SPDie = CI->first;
1311 const MDNode *N = CI->second;
1313 DIE *NDie = getDIE(N);
1314 if (!NDie) continue;
1315 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1319 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1320 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1321 StringRef Name = DV->getName();
1325 // Translate tag to proper Dwarf tag.
1326 unsigned Tag = DV->getTag();
1328 // Define variable debug information entry.
1329 DIE *VariableDie = new DIE(Tag);
1330 DbgVariable *AbsVar = DV->getAbstractVariable();
1331 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1333 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1334 dwarf::DW_FORM_ref4, AbsDIE);
1336 addString(VariableDie, dwarf::DW_AT_name, Name);
1337 addSourceLine(VariableDie, DV->getVariable());
1338 addType(VariableDie, DV->getType());
1341 if (DV->isArtificial())
1342 addUInt(VariableDie, dwarf::DW_AT_artificial,
1343 dwarf::DW_FORM_flag, 1);
1345 if (isScopeAbstract) {
1346 DV->setDIE(VariableDie);
1350 // Add variable address.
1352 unsigned Offset = DV->getDotDebugLocOffset();
1353 if (Offset != ~0U) {
1354 addLabel(VariableDie, dwarf::DW_AT_location,
1355 dwarf::DW_FORM_data4,
1356 Asm->GetTempSymbol("debug_loc", Offset));
1357 DV->setDIE(VariableDie);
1361 // Check if variable is described by a DBG_VALUE instruction.
1362 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1363 bool updated = false;
1364 if (DVInsn->getNumOperands() == 3) {
1365 if (DVInsn->getOperand(0).isReg()) {
1366 const MachineOperand RegOp = DVInsn->getOperand(0);
1367 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1368 if (DVInsn->getOperand(1).isImm() &&
1369 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1370 unsigned FrameReg = 0;
1371 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1373 TFI->getFrameIndexReference(*Asm->MF,
1374 DVInsn->getOperand(1).getImm(),
1376 MachineLocation Location(FrameReg, Offset);
1377 addVariableAddress(DV, VariableDie, Location);
1379 } else if (RegOp.getReg())
1380 addVariableAddress(DV, VariableDie,
1381 MachineLocation(RegOp.getReg()));
1384 else if (DVInsn->getOperand(0).isImm())
1386 addConstantValue(VariableDie, DVInsn->getOperand(0),
1388 else if (DVInsn->getOperand(0).isFPImm())
1390 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1391 else if (DVInsn->getOperand(0).isCImm())
1393 addConstantValue(VariableDie,
1394 DVInsn->getOperand(0).getCImm(),
1395 DV->getType().isUnsignedDIType());
1397 addVariableAddress(DV, VariableDie,
1398 Asm->getDebugValueLocation(DVInsn));
1402 // If variableDie is not updated then DBG_VALUE instruction does not
1403 // have valid variable info.
1407 DV->setDIE(VariableDie);
1410 // .. else use frame index.
1411 int FI = DV->getFrameIndex();
1413 unsigned FrameReg = 0;
1414 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1416 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1417 MachineLocation Location(FrameReg, Offset);
1418 addVariableAddress(DV, VariableDie, Location);
1422 DV->setDIE(VariableDie);
1426 /// createMemberDIE - Create new member DIE.
1427 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1428 DIE *MemberDie = new DIE(DT.getTag());
1429 StringRef Name = DT.getName();
1431 addString(MemberDie, dwarf::DW_AT_name, Name);
1433 addType(MemberDie, DT.getTypeDerivedFrom());
1435 addSourceLine(MemberDie, DT);
1437 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1438 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1440 uint64_t Size = DT.getSizeInBits();
1441 uint64_t FieldSize = DT.getOriginalTypeSize();
1443 if (Size != FieldSize) {
1445 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1446 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1448 uint64_t Offset = DT.getOffsetInBits();
1449 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1450 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1451 uint64_t FieldOffset = (HiMark - FieldSize);
1452 Offset -= FieldOffset;
1454 // Maybe we need to work from the other end.
1455 if (Asm->getTargetData().isLittleEndian())
1456 Offset = FieldSize - (Offset + Size);
1457 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1459 // Here WD_AT_data_member_location points to the anonymous
1460 // field that includes this bit field.
1461 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1464 // This is not a bitfield.
1465 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1467 if (DT.getTag() == dwarf::DW_TAG_inheritance
1468 && DT.isVirtual()) {
1470 // For C++, virtual base classes are not at fixed offset. Use following
1471 // expression to extract appropriate offset from vtable.
1472 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1474 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1475 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1476 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1477 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1478 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1479 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1480 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1481 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1483 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1486 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1488 if (DT.isProtected())
1489 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1490 dwarf::DW_ACCESS_protected);
1491 else if (DT.isPrivate())
1492 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1493 dwarf::DW_ACCESS_private);
1494 // Otherwise C++ member and base classes are considered public.
1496 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1497 dwarf::DW_ACCESS_public);
1499 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1500 dwarf::DW_VIRTUALITY_virtual);
1502 // Objective-C properties.
1503 if (MDNode *PNode = DT.getObjCProperty())
1504 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1505 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1508 // This is only for backward compatibility.
1509 StringRef PropertyName = DT.getObjCPropertyName();
1510 if (!PropertyName.empty()) {
1511 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1512 StringRef GetterName = DT.getObjCPropertyGetterName();
1513 if (!GetterName.empty())
1514 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1515 StringRef SetterName = DT.getObjCPropertySetterName();
1516 if (!SetterName.empty())
1517 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1518 unsigned PropertyAttributes = 0;
1519 if (DT.isReadOnlyObjCProperty())
1520 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1521 if (DT.isReadWriteObjCProperty())
1522 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1523 if (DT.isAssignObjCProperty())
1524 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1525 if (DT.isRetainObjCProperty())
1526 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1527 if (DT.isCopyObjCProperty())
1528 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1529 if (DT.isNonAtomicObjCProperty())
1530 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1531 if (PropertyAttributes)
1532 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1533 PropertyAttributes);