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 "DwarfCompileUnit.h"
17 #include "DwarfDebug.h"
18 #include "llvm/Constants.h"
19 #include "llvm/Analysis/DIBuilder.h"
20 #include "llvm/Target/TargetData.h"
21 #include "llvm/Target/TargetFrameLowering.h"
22 #include "llvm/Target/TargetMachine.h"
23 #include "llvm/Target/TargetRegisterInfo.h"
24 #include "llvm/ADT/APFloat.h"
25 #include "llvm/Support/ErrorHandling.h"
29 /// CompileUnit - Compile unit constructor.
30 CompileUnit::CompileUnit(unsigned I, DIE *D, AsmPrinter *A, DwarfDebug *DW)
31 : ID(I), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
32 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
35 /// ~CompileUnit - Destructor for compile unit.
36 CompileUnit::~CompileUnit() {
37 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
38 DIEBlocks[j]->~DIEBlock();
41 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
42 /// information entry.
43 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
44 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
48 /// addUInt - Add an unsigned integer attribute data and value.
50 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
51 unsigned Form, uint64_t Integer) {
52 if (!Form) Form = DIEInteger::BestForm(false, Integer);
53 DIEValue *Value = Integer == 1 ?
54 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
55 Die->addValue(Attribute, Form, Value);
58 /// addSInt - Add an signed integer attribute data and value.
60 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
61 unsigned Form, int64_t Integer) {
62 if (!Form) Form = DIEInteger::BestForm(true, Integer);
63 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
64 Die->addValue(Attribute, Form, Value);
67 /// addString - Add a string attribute data and value. DIEString only
68 /// keeps string reference.
69 void CompileUnit::addString(DIE *Die, unsigned Attribute, unsigned Form,
71 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
72 Die->addValue(Attribute, Form, Value);
75 /// addLabel - Add a Dwarf label attribute data and value.
77 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
78 const MCSymbol *Label) {
79 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
80 Die->addValue(Attribute, Form, Value);
83 /// addDelta - Add a label delta attribute data and value.
85 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
86 const MCSymbol *Hi, const MCSymbol *Lo) {
87 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
88 Die->addValue(Attribute, Form, Value);
91 /// addDIEEntry - Add a DIE attribute data and value.
93 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
95 Die->addValue(Attribute, Form, createDIEEntry(Entry));
99 /// addBlock - Add block data.
101 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
103 Block->ComputeSize(Asm);
104 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
105 Die->addValue(Attribute, Block->BestForm(), Block);
108 /// addSourceLine - Add location information to specified debug information
110 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
115 unsigned Line = V.getLineNumber();
118 unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
119 V.getContext().getDirectory());
120 assert(FileID && "Invalid file id");
121 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
122 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
125 /// addSourceLine - Add location information to specified debug information
127 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
128 // Verify global variable.
132 unsigned Line = G.getLineNumber();
135 unsigned FileID = DD->GetOrCreateSourceID(G.getContext().getFilename(),
136 G.getContext().getDirectory());
137 assert(FileID && "Invalid file id");
138 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
139 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
142 /// addSourceLine - Add location information to specified debug information
144 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
145 // Verify subprogram.
148 // If the line number is 0, don't add it.
149 if (SP.getLineNumber() == 0)
152 unsigned Line = SP.getLineNumber();
153 if (!SP.getContext().Verify())
155 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(), SP.getDirectory());
156 assert(FileID && "Invalid file id");
157 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
158 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
161 /// addSourceLine - Add location information to specified debug information
163 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
168 unsigned Line = Ty.getLineNumber();
169 if (Line == 0 || !Ty.getContext().Verify())
171 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(), Ty.getDirectory());
172 assert(FileID && "Invalid file id");
173 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
174 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
177 /// addSourceLine - Add location information to specified debug information
179 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
184 unsigned Line = NS.getLineNumber();
187 StringRef FN = NS.getFilename();
189 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
190 assert(FileID && "Invalid file id");
191 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
192 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
195 /// addVariableAddress - Add DW_AT_location attribute for a
196 /// DbgVariable based on provided MachineLocation.
197 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
198 MachineLocation Location) {
199 if (DV->variableHasComplexAddress())
200 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
201 else if (DV->isBlockByrefVariable())
202 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
204 addAddress(Die, dwarf::DW_AT_location, Location);
207 /// addRegisterOp - Add register operand.
208 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
209 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
210 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
212 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
214 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
215 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
219 /// addRegisterOffset - Add register offset.
220 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
222 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
223 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
224 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
225 if (Reg == TRI->getFrameRegister(*Asm->MF))
226 // If variable offset is based in frame register then use fbreg.
227 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
229 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
231 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
232 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
234 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
237 /// addAddress - Add an address attribute to a die based on the location
239 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
240 const MachineLocation &Location) {
241 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
243 if (Location.isReg())
244 addRegisterOp(Block, Location.getReg());
246 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
248 // Now attach the location information to the DIE.
249 addBlock(Die, Attribute, 0, Block);
252 /// addComplexAddress - Start with the address based on the location provided,
253 /// and generate the DWARF information necessary to find the actual variable
254 /// given the extra address information encoded in the DIVariable, starting from
255 /// the starting location. Add the DWARF information to the die.
257 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
259 const MachineLocation &Location) {
260 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
261 unsigned N = DV->getNumAddrElements();
263 if (Location.isReg()) {
264 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
265 // If first address element is OpPlus then emit
266 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
267 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
270 addRegisterOp(Block, Location.getReg());
273 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
276 uint64_t Element = DV->getAddrElement(i);
277 if (Element == DIBuilder::OpPlus) {
278 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
279 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
280 } else if (Element == DIBuilder::OpDeref) {
281 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
282 } else llvm_unreachable("unknown DIBuilder Opcode");
285 // Now attach the location information to the DIE.
286 addBlock(Die, Attribute, 0, Block);
289 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
290 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
291 gives the variable VarName either the struct, or a pointer to the struct, as
292 its type. This is necessary for various behind-the-scenes things the
293 compiler needs to do with by-reference variables in Blocks.
295 However, as far as the original *programmer* is concerned, the variable
296 should still have type 'SomeType', as originally declared.
298 The function getBlockByrefType dives into the __Block_byref_x_VarName
299 struct to find the original type of the variable, which is then assigned to
300 the variable's Debug Information Entry as its real type. So far, so good.
301 However now the debugger will expect the variable VarName to have the type
302 SomeType. So we need the location attribute for the variable to be an
303 expression that explains to the debugger how to navigate through the
304 pointers and struct to find the actual variable of type SomeType.
306 The following function does just that. We start by getting
307 the "normal" location for the variable. This will be the location
308 of either the struct __Block_byref_x_VarName or the pointer to the
309 struct __Block_byref_x_VarName.
311 The struct will look something like:
313 struct __Block_byref_x_VarName {
315 struct __Block_byref_x_VarName *forwarding;
316 ... <various other fields>
318 ... <maybe more fields>
321 If we are given the struct directly (as our starting point) we
322 need to tell the debugger to:
324 1). Add the offset of the forwarding field.
326 2). Follow that pointer to get the real __Block_byref_x_VarName
327 struct to use (the real one may have been copied onto the heap).
329 3). Add the offset for the field VarName, to find the actual variable.
331 If we started with a pointer to the struct, then we need to
332 dereference that pointer first, before the other steps.
333 Translating this into DWARF ops, we will need to append the following
334 to the current location description for the variable:
336 DW_OP_deref -- optional, if we start with a pointer
337 DW_OP_plus_uconst <forward_fld_offset>
339 DW_OP_plus_uconst <varName_fld_offset>
341 That is what this function does. */
343 /// addBlockByrefAddress - Start with the address based on the location
344 /// provided, and generate the DWARF information necessary to find the
345 /// actual Block variable (navigating the Block struct) based on the
346 /// starting location. Add the DWARF information to the die. For
347 /// more information, read large comment just above here.
349 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
351 const MachineLocation &Location) {
352 DIType Ty = DV->getType();
354 unsigned Tag = Ty.getTag();
355 bool isPointer = false;
357 StringRef varName = DV->getName();
359 if (Tag == dwarf::DW_TAG_pointer_type) {
360 DIDerivedType DTy = DIDerivedType(Ty);
361 TmpTy = DTy.getTypeDerivedFrom();
365 DICompositeType blockStruct = DICompositeType(TmpTy);
367 // Find the __forwarding field and the variable field in the __Block_byref
369 DIArray Fields = blockStruct.getTypeArray();
370 DIDescriptor varField = DIDescriptor();
371 DIDescriptor forwardingField = DIDescriptor();
373 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
374 DIDescriptor Element = Fields.getElement(i);
375 DIDerivedType DT = DIDerivedType(Element);
376 StringRef fieldName = DT.getName();
377 if (fieldName == "__forwarding")
378 forwardingField = Element;
379 else if (fieldName == varName)
383 // Get the offsets for the forwarding field and the variable field.
384 unsigned forwardingFieldOffset =
385 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
386 unsigned varFieldOffset =
387 DIDerivedType(varField).getOffsetInBits() >> 3;
389 // Decode the original location, and use that as the start of the byref
390 // variable's location.
391 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
392 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
393 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
395 if (Location.isReg()) {
397 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
399 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
400 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
404 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
406 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
407 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
410 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
413 // If we started with a pointer to the __Block_byref... struct, then
414 // the first thing we need to do is dereference the pointer (DW_OP_deref).
416 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
418 // Next add the offset for the '__forwarding' field:
419 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
420 // adding the offset if it's 0.
421 if (forwardingFieldOffset > 0) {
422 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
423 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
426 // Now dereference the __forwarding field to get to the real __Block_byref
427 // struct: DW_OP_deref.
428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
430 // Now that we've got the real __Block_byref... struct, add the offset
431 // for the variable's field to get to the location of the actual variable:
432 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
433 if (varFieldOffset > 0) {
434 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
435 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
438 // Now attach the location information to the DIE.
439 addBlock(Die, Attribute, 0, Block);
442 /// addConstantValue - Add constant value entry in variable DIE.
443 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
445 assert (MO.isImm() && "Invalid machine operand!");
446 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
447 unsigned Imm = MO.getImm();
448 unsigned form = dwarf::DW_FORM_udata;
449 switch (Ty.getSizeInBits()) {
450 case 8: form = dwarf::DW_FORM_data1; break;
451 case 16: form = dwarf::DW_FORM_data2; break;
452 case 32: form = dwarf::DW_FORM_data4; break;
453 case 64: form = dwarf::DW_FORM_data8; break;
456 addUInt(Block, 0, form, Imm);
457 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
461 /// addConstantFPValue - Add constant value entry in variable DIE.
462 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
463 assert (MO.isFPImm() && "Invalid machine operand!");
464 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
465 APFloat FPImm = MO.getFPImm()->getValueAPF();
467 // Get the raw data form of the floating point.
468 const APInt FltVal = FPImm.bitcastToAPInt();
469 const char *FltPtr = (const char*)FltVal.getRawData();
471 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
472 bool LittleEndian = Asm->getTargetData().isLittleEndian();
473 int Incr = (LittleEndian ? 1 : -1);
474 int Start = (LittleEndian ? 0 : NumBytes - 1);
475 int Stop = (LittleEndian ? NumBytes : -1);
477 // Output the constant to DWARF one byte at a time.
478 for (; Start != Stop; Start += Incr)
479 addUInt(Block, 0, dwarf::DW_FORM_data1,
480 (unsigned char)0xFF & FltPtr[Start]);
482 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
486 /// addConstantValue - Add constant value entry in variable DIE.
487 bool CompileUnit::addConstantValue(DIE *Die, ConstantInt *CI,
489 if (CI->getBitWidth() <= 64) {
491 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
494 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
499 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
501 // Get the raw data form of the large APInt.
502 const APInt Val = CI->getValue();
503 const char *Ptr = (const char*)Val.getRawData();
505 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
506 bool LittleEndian = Asm->getTargetData().isLittleEndian();
507 int Incr = (LittleEndian ? 1 : -1);
508 int Start = (LittleEndian ? 0 : NumBytes - 1);
509 int Stop = (LittleEndian ? NumBytes : -1);
511 // Output the constant to DWARF one byte at a time.
512 for (; Start != Stop; Start += Incr)
513 addUInt(Block, 0, dwarf::DW_FORM_data1,
514 (unsigned char)0xFF & Ptr[Start]);
516 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
520 /// addTemplateParams - Add template parameters in buffer.
521 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
522 // Add template parameters.
523 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
524 DIDescriptor Element = TParams.getElement(i);
525 if (Element.isTemplateTypeParameter())
526 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
527 DITemplateTypeParameter(Element)));
528 else if (Element.isTemplateValueParameter())
529 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
530 DITemplateValueParameter(Element)));
534 /// addToContextOwner - Add Die into the list of its context owner's children.
535 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
536 if (Context.isType()) {
537 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
538 ContextDIE->addChild(Die);
539 } else if (Context.isNameSpace()) {
540 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
541 ContextDIE->addChild(Die);
542 } else if (Context.isSubprogram()) {
543 DIE *ContextDIE = DD->createSubprogramDIE(DISubprogram(Context));
544 ContextDIE->addChild(Die);
545 } else if (DIE *ContextDIE = getDIE(Context))
546 ContextDIE->addChild(Die);
551 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
553 DIE *CompileUnit::getOrCreateTypeDIE(DIType Ty) {
554 DIE *TyDIE = getDIE(Ty);
559 TyDIE = new DIE(dwarf::DW_TAG_base_type);
560 insertDIE(Ty, TyDIE);
561 if (Ty.isBasicType())
562 constructTypeDIE(*TyDIE, DIBasicType(Ty));
563 else if (Ty.isCompositeType())
564 constructTypeDIE(*TyDIE, DICompositeType(Ty));
566 assert(Ty.isDerivedType() && "Unknown kind of DIType");
567 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
570 addToContextOwner(TyDIE, Ty.getContext());
574 /// addType - Add a new type attribute to the specified entity.
575 void CompileUnit::addType(DIE *Entity, DIType Ty) {
579 // Check for pre-existence.
580 DIEEntry *Entry = getDIEEntry(Ty);
581 // If it exists then use the existing value.
583 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
588 DIE *Buffer = getOrCreateTypeDIE(Ty);
591 Entry = createDIEEntry(Buffer);
592 insertDIEEntry(Ty, Entry);
594 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
597 /// addPubTypes - Add type for pubtypes section.
598 void CompileUnit::addPubTypes(DISubprogram SP) {
599 DICompositeType SPTy = SP.getType();
600 unsigned SPTag = SPTy.getTag();
601 if (SPTag != dwarf::DW_TAG_subroutine_type)
604 DIArray Args = SPTy.getTypeArray();
605 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
606 DIType ATy(Args.getElement(i));
609 DICompositeType CATy = getDICompositeType(ATy);
610 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
611 && !CATy.isForwardDecl()) {
612 if (DIEEntry *Entry = getDIEEntry(CATy))
613 addGlobalType(CATy.getName(), Entry->getEntry());
618 /// constructTypeDIE - Construct basic type die from DIBasicType.
619 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
620 // Get core information.
621 StringRef Name = BTy.getName();
622 Buffer.setTag(dwarf::DW_TAG_base_type);
623 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
626 // Add name if not anonymous or intermediate type.
628 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
629 uint64_t Size = BTy.getSizeInBits() >> 3;
630 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
633 /// constructTypeDIE - Construct derived type die from DIDerivedType.
634 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
635 // Get core information.
636 StringRef Name = DTy.getName();
637 uint64_t Size = DTy.getSizeInBits() >> 3;
638 unsigned Tag = DTy.getTag();
640 // FIXME - Workaround for templates.
641 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
645 // Map to main type, void will not have a type.
646 DIType FromTy = DTy.getTypeDerivedFrom();
647 addType(&Buffer, FromTy);
649 // Add name if not anonymous or intermediate type.
651 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
653 // Add size if non-zero (derived types might be zero-sized.)
655 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
657 // Add source line info if available and TyDesc is not a forward declaration.
658 if (!DTy.isForwardDecl())
659 addSourceLine(&Buffer, DTy);
662 /// constructTypeDIE - Construct type DIE from DICompositeType.
663 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
664 // Get core information.
665 StringRef Name = CTy.getName();
667 uint64_t Size = CTy.getSizeInBits() >> 3;
668 unsigned Tag = CTy.getTag();
672 case dwarf::DW_TAG_vector_type:
673 case dwarf::DW_TAG_array_type:
674 constructArrayTypeDIE(Buffer, &CTy);
676 case dwarf::DW_TAG_enumeration_type: {
677 DIArray Elements = CTy.getTypeArray();
679 // Add enumerators to enumeration type.
680 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
682 DIDescriptor Enum(Elements.getElement(i));
683 if (Enum.isEnumerator()) {
684 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
685 Buffer.addChild(ElemDie);
690 case dwarf::DW_TAG_subroutine_type: {
692 DIArray Elements = CTy.getTypeArray();
693 DIDescriptor RTy = Elements.getElement(0);
694 addType(&Buffer, DIType(RTy));
696 bool isPrototyped = true;
698 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
699 DIDescriptor Ty = Elements.getElement(i);
700 if (Ty.isUnspecifiedParameter()) {
701 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
702 Buffer.addChild(Arg);
703 isPrototyped = false;
705 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
706 addType(Arg, DIType(Ty));
707 Buffer.addChild(Arg);
710 // Add prototype flag.
712 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
715 case dwarf::DW_TAG_structure_type:
716 case dwarf::DW_TAG_union_type:
717 case dwarf::DW_TAG_class_type: {
718 // Add elements to structure type.
719 DIArray Elements = CTy.getTypeArray();
721 // A forward struct declared type may not have elements available.
722 unsigned N = Elements.getNumElements();
726 // Add elements to structure type.
727 for (unsigned i = 0; i < N; ++i) {
728 DIDescriptor Element = Elements.getElement(i);
730 if (Element.isSubprogram()) {
731 DISubprogram SP(Element);
732 ElemDie = DD->createSubprogramDIE(DISubprogram(Element));
733 if (SP.isProtected())
734 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
735 dwarf::DW_ACCESS_protected);
736 else if (SP.isPrivate())
737 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
738 dwarf::DW_ACCESS_private);
740 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
741 dwarf::DW_ACCESS_public);
743 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
745 else if (Element.isVariable()) {
746 DIVariable DV(Element);
747 ElemDie = new DIE(dwarf::DW_TAG_variable);
748 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
750 addType(ElemDie, DV.getType());
751 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
752 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
753 addSourceLine(ElemDie, DV);
754 } else if (Element.isDerivedType())
755 ElemDie = createMemberDIE(DIDerivedType(Element));
758 Buffer.addChild(ElemDie);
761 if (CTy.isAppleBlockExtension())
762 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
764 unsigned RLang = CTy.getRunTimeLang();
766 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
767 dwarf::DW_FORM_data1, RLang);
769 DICompositeType ContainingType = CTy.getContainingType();
770 if (DIDescriptor(ContainingType).isCompositeType())
771 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
772 getOrCreateTypeDIE(DIType(ContainingType)));
774 DIDescriptor Context = CTy.getContext();
775 addToContextOwner(&Buffer, Context);
778 if (CTy.isObjcClassComplete())
779 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
780 dwarf::DW_FORM_flag, 1);
782 if (Tag == dwarf::DW_TAG_class_type)
783 addTemplateParams(Buffer, CTy.getTemplateParams());
791 // Add name if not anonymous or intermediate type.
793 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
795 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
796 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
798 // Add size if non-zero (derived types might be zero-sized.)
800 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
802 // Add zero size if it is not a forward declaration.
803 if (CTy.isForwardDecl())
804 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
806 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
809 // Add source line info if available.
810 if (!CTy.isForwardDecl())
811 addSourceLine(&Buffer, CTy);
815 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
816 /// for the given DITemplateTypeParameter.
818 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
819 DIE *ParamDIE = getDIE(TP);
823 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
824 addType(ParamDIE, TP.getType());
825 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
829 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
830 /// for the given DITemplateValueParameter.
832 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
833 DIE *ParamDIE = getDIE(TPV);
837 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
838 addType(ParamDIE, TPV.getType());
839 if (!TPV.getName().empty())
840 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
841 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
846 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
847 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
848 DIE *NDie = getDIE(NS);
851 NDie = new DIE(dwarf::DW_TAG_namespace);
853 if (!NS.getName().empty())
854 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
855 addSourceLine(NDie, NS);
856 addToContextOwner(NDie, NS.getContext());
860 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
861 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
862 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
863 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
864 int64_t L = SR.getLo();
865 int64_t H = SR.getHi();
867 // The L value defines the lower bounds which is typically zero for C/C++. The
868 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
869 // of the array. If L > H then do not emit DW_AT_lower_bound and
870 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
871 // array has one element and in such case do not emit lower bound.
874 Buffer.addChild(DW_Subrange);
878 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
879 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
880 Buffer.addChild(DW_Subrange);
883 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
884 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
885 DICompositeType *CTy) {
886 Buffer.setTag(dwarf::DW_TAG_array_type);
887 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
888 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
890 // Emit derived type.
891 addType(&Buffer, CTy->getTypeDerivedFrom());
892 DIArray Elements = CTy->getTypeArray();
894 // Get an anonymous type for index type.
895 DIE *IdxTy = getIndexTyDie();
897 // Construct an anonymous type for index type.
898 IdxTy = new DIE(dwarf::DW_TAG_base_type);
899 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
900 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
901 dwarf::DW_ATE_signed);
903 setIndexTyDie(IdxTy);
906 // Add subranges to array type.
907 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
908 DIDescriptor Element = Elements.getElement(i);
909 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
910 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
914 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
915 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
916 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
917 StringRef Name = ETy.getName();
918 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
919 int64_t Value = ETy.getEnumValue();
920 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
924 /// createMemberDIE - Create new member DIE.
925 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
926 DIE *MemberDie = new DIE(DT.getTag());
927 StringRef Name = DT.getName();
929 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
931 addType(MemberDie, DT.getTypeDerivedFrom());
933 addSourceLine(MemberDie, DT);
935 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
936 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
938 uint64_t Size = DT.getSizeInBits();
939 uint64_t FieldSize = DT.getOriginalTypeSize();
941 if (Size != FieldSize) {
943 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
944 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
946 uint64_t Offset = DT.getOffsetInBits();
947 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
948 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
949 uint64_t FieldOffset = (HiMark - FieldSize);
950 Offset -= FieldOffset;
952 // Maybe we need to work from the other end.
953 if (Asm->getTargetData().isLittleEndian())
954 Offset = FieldSize - (Offset + Size);
955 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
957 // Here WD_AT_data_member_location points to the anonymous
958 // field that includes this bit field.
959 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
962 // This is not a bitfield.
963 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
965 if (DT.getTag() == dwarf::DW_TAG_inheritance
968 // For C++, virtual base classes are not at fixed offset. Use following
969 // expression to extract appropriate offset from vtable.
970 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
972 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
973 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
974 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
975 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
976 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
977 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
978 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
979 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
981 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
984 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
986 if (DT.isProtected())
987 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
988 dwarf::DW_ACCESS_protected);
989 else if (DT.isPrivate())
990 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
991 dwarf::DW_ACCESS_private);
992 // Otherwise C++ member and base classes are considered public.
993 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
994 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
995 dwarf::DW_ACCESS_public);
997 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
998 dwarf::DW_VIRTUALITY_virtual);
1000 // Objective-C properties.
1001 StringRef PropertyName = DT.getObjCPropertyName();
1002 if (!PropertyName.empty()) {
1003 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string,
1005 StringRef GetterName = DT.getObjCPropertyGetterName();
1006 if (!GetterName.empty())
1007 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter,
1008 dwarf::DW_FORM_string, GetterName);
1009 StringRef SetterName = DT.getObjCPropertySetterName();
1010 if (!SetterName.empty())
1011 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter,
1012 dwarf::DW_FORM_string, SetterName);
1013 unsigned PropertyAttributes = 0;
1014 if (DT.isReadOnlyObjCProperty())
1015 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1016 if (DT.isReadWriteObjCProperty())
1017 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1018 if (DT.isAssignObjCProperty())
1019 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1020 if (DT.isRetainObjCProperty())
1021 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1022 if (DT.isCopyObjCProperty())
1023 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1024 if (DT.isNonAtomicObjCProperty())
1025 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1026 if (PropertyAttributes)
1027 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1028 PropertyAttributes);