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 instead of below the
1036 // AT_specification code in order to work around a bug in older
1037 // gdbs that requires the linkage name to resolve multiple template
1039 StringRef LinkageName = SP.getLinkageName();
1040 if (!LinkageName.empty())
1041 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1042 getRealLinkageName(LinkageName));
1044 // If this DIE is going to refer declaration info using AT_specification
1045 // then there is no need to add other attributes.
1047 // Refer function declaration directly.
1048 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1054 // Constructors and operators for anonymous aggregates do not have names.
1055 if (!SP.getName().empty())
1056 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1058 addSourceLine(SPDie, SP);
1060 // Add the prototype if we have a prototype and we have a C like
1062 if (SP.isPrototyped() &&
1063 (Language == dwarf::DW_LANG_C89 ||
1064 Language == dwarf::DW_LANG_C99 ||
1065 Language == dwarf::DW_LANG_ObjC))
1066 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1069 DICompositeType SPTy = SP.getType();
1070 DIArray Args = SPTy.getTypeArray();
1071 unsigned SPTag = SPTy.getTag();
1073 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1074 addType(SPDie, SPTy);
1076 addType(SPDie, DIType(Args.getElement(0)));
1078 unsigned VK = SP.getVirtuality();
1080 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1081 DIEBlock *Block = getDIEBlock();
1082 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1083 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1084 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1085 ContainingTypeMap.insert(std::make_pair(SPDie,
1086 SP.getContainingType()));
1089 if (!SP.isDefinition()) {
1090 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1092 // Add arguments. Do not add arguments for subprogram definition. They will
1093 // be handled while processing variables.
1094 DICompositeType SPTy = SP.getType();
1095 DIArray Args = SPTy.getTypeArray();
1096 unsigned SPTag = SPTy.getTag();
1098 if (SPTag == dwarf::DW_TAG_subroutine_type)
1099 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1100 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1101 DIType ATy = DIType(DIType(Args.getElement(i)));
1103 if (ATy.isArtificial())
1104 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1105 SPDie->addChild(Arg);
1109 if (SP.isArtificial())
1110 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1112 if (!SP.isLocalToUnit())
1113 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1115 if (SP.isOptimized())
1116 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1118 if (unsigned isa = Asm->getISAEncoding()) {
1119 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1125 // Return const expression if value is a GEP to access merged global
1127 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1128 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1129 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1130 if (!CE || CE->getNumOperands() != 3 ||
1131 CE->getOpcode() != Instruction::GetElementPtr)
1134 // First operand points to a global struct.
1135 Value *Ptr = CE->getOperand(0);
1136 if (!isa<GlobalValue>(Ptr) ||
1137 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1140 // Second operand is zero.
1141 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1142 if (!CI || !CI->isZero())
1145 // Third operand is offset.
1146 if (!isa<ConstantInt>(CE->getOperand(2)))
1152 /// createGlobalVariableDIE - create global variable DIE.
1153 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1154 // Check for pre-existence.
1158 DIGlobalVariable GV(N);
1162 DIE *VariableDIE = new DIE(GV.getTag());
1164 insertDIE(N, VariableDIE);
1167 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1168 StringRef LinkageName = GV.getLinkageName();
1169 bool isGlobalVariable = GV.getGlobal() != NULL;
1170 if (!LinkageName.empty() && isGlobalVariable)
1171 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1172 getRealLinkageName(LinkageName));
1174 DIType GTy = GV.getType();
1175 addType(VariableDIE, GTy);
1177 // Add scoping info.
1178 if (!GV.isLocalToUnit())
1179 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181 // Add line number info.
1182 addSourceLine(VariableDIE, GV);
1183 // Add to context owner.
1184 DIDescriptor GVContext = GV.getContext();
1185 addToContextOwner(VariableDIE, GVContext);
1187 bool addToAccelTable = false;
1188 DIE *VariableSpecDIE = NULL;
1189 if (isGlobalVariable) {
1190 addToAccelTable = true;
1191 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1192 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1193 addLabel(Block, 0, dwarf::DW_FORM_udata,
1194 Asm->Mang->getSymbol(GV.getGlobal()));
1195 // Do not create specification DIE if context is either compile unit
1197 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1198 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1199 // Create specification DIE.
1200 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1201 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1202 dwarf::DW_FORM_ref4, VariableDIE);
1203 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1204 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1206 addDie(VariableSpecDIE);
1208 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1210 } else if (const ConstantInt *CI =
1211 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1212 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1213 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1214 addToAccelTable = true;
1215 // GV is a merged global.
1216 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1217 Value *Ptr = CE->getOperand(0);
1218 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1219 addLabel(Block, 0, dwarf::DW_FORM_udata,
1220 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1221 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1222 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1223 addUInt(Block, 0, dwarf::DW_FORM_udata,
1224 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1225 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1226 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1229 if (addToAccelTable) {
1230 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1231 addAccelName(GV.getName(), AddrDIE);
1233 // If the linkage name is different than the name, go ahead and output
1234 // that as well into the name table.
1235 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1236 addAccelName(GV.getLinkageName(), AddrDIE);
1242 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1243 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
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);