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 form = dwarf::DW_FORM_udata;
448 switch (Ty.getSizeInBits()) {
449 case 8: form = dwarf::DW_FORM_data1; break;
450 case 16: form = dwarf::DW_FORM_data2; break;
451 case 32: form = dwarf::DW_FORM_data4; break;
452 case 64: form = dwarf::DW_FORM_data8; break;
458 (BTy.getEncoding() == dwarf::DW_ATE_signed
459 || BTy.getEncoding() == dwarf::DW_ATE_signed_char))
460 addSInt(Block, 0, form, MO.getImm());
462 addUInt(Block, 0, form, MO.getImm());
464 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
468 /// addConstantFPValue - Add constant value entry in variable DIE.
469 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
470 assert (MO.isFPImm() && "Invalid machine operand!");
471 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
472 APFloat FPImm = MO.getFPImm()->getValueAPF();
474 // Get the raw data form of the floating point.
475 const APInt FltVal = FPImm.bitcastToAPInt();
476 const char *FltPtr = (const char*)FltVal.getRawData();
478 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
479 bool LittleEndian = Asm->getTargetData().isLittleEndian();
480 int Incr = (LittleEndian ? 1 : -1);
481 int Start = (LittleEndian ? 0 : NumBytes - 1);
482 int Stop = (LittleEndian ? NumBytes : -1);
484 // Output the constant to DWARF one byte at a time.
485 for (; Start != Stop; Start += Incr)
486 addUInt(Block, 0, dwarf::DW_FORM_data1,
487 (unsigned char)0xFF & FltPtr[Start]);
489 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
493 /// addConstantValue - Add constant value entry in variable DIE.
494 bool CompileUnit::addConstantValue(DIE *Die, ConstantInt *CI,
496 unsigned CIBitWidth = CI->getBitWidth();
497 if (CIBitWidth <= 64) {
499 switch (CIBitWidth) {
500 case 8: form = dwarf::DW_FORM_data1; break;
501 case 16: form = dwarf::DW_FORM_data2; break;
502 case 32: form = dwarf::DW_FORM_data4; break;
503 case 64: form = dwarf::DW_FORM_data8; break;
505 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
508 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
510 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
514 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
516 // Get the raw data form of the large APInt.
517 const APInt Val = CI->getValue();
518 const char *Ptr = (const char*)Val.getRawData();
520 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
521 bool LittleEndian = Asm->getTargetData().isLittleEndian();
522 int Incr = (LittleEndian ? 1 : -1);
523 int Start = (LittleEndian ? 0 : NumBytes - 1);
524 int Stop = (LittleEndian ? NumBytes : -1);
526 // Output the constant to DWARF one byte at a time.
527 for (; Start != Stop; Start += Incr)
528 addUInt(Block, 0, dwarf::DW_FORM_data1,
529 (unsigned char)0xFF & Ptr[Start]);
531 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
535 /// addTemplateParams - Add template parameters in buffer.
536 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
537 // Add template parameters.
538 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
539 DIDescriptor Element = TParams.getElement(i);
540 if (Element.isTemplateTypeParameter())
541 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
542 DITemplateTypeParameter(Element)));
543 else if (Element.isTemplateValueParameter())
544 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
545 DITemplateValueParameter(Element)));
549 /// addToContextOwner - Add Die into the list of its context owner's children.
550 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
551 if (Context.isType()) {
552 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
553 ContextDIE->addChild(Die);
554 } else if (Context.isNameSpace()) {
555 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
556 ContextDIE->addChild(Die);
557 } else if (Context.isSubprogram()) {
558 DIE *ContextDIE = DD->createSubprogramDIE(DISubprogram(Context));
559 ContextDIE->addChild(Die);
560 } else if (DIE *ContextDIE = getDIE(Context))
561 ContextDIE->addChild(Die);
566 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
568 DIE *CompileUnit::getOrCreateTypeDIE(DIType Ty) {
569 DIE *TyDIE = getDIE(Ty);
574 TyDIE = new DIE(dwarf::DW_TAG_base_type);
575 insertDIE(Ty, TyDIE);
576 if (Ty.isBasicType())
577 constructTypeDIE(*TyDIE, DIBasicType(Ty));
578 else if (Ty.isCompositeType())
579 constructTypeDIE(*TyDIE, DICompositeType(Ty));
581 assert(Ty.isDerivedType() && "Unknown kind of DIType");
582 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
585 addToContextOwner(TyDIE, Ty.getContext());
589 /// addType - Add a new type attribute to the specified entity.
590 void CompileUnit::addType(DIE *Entity, DIType Ty) {
594 // Check for pre-existence.
595 DIEEntry *Entry = getDIEEntry(Ty);
596 // If it exists then use the existing value.
598 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
603 DIE *Buffer = getOrCreateTypeDIE(Ty);
606 Entry = createDIEEntry(Buffer);
607 insertDIEEntry(Ty, Entry);
608 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
610 // If this is a complete composite type then include it in the
611 // list of global types.
612 DIDescriptor Context = Ty.getContext();
613 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
614 && (Context.isCompileUnit() || Context.isFile() || Context.isNameSpace()))
615 addGlobalType(Ty.getName(), Entry->getEntry());
618 /// addPubTypes - Add type for pubtypes section.
619 void CompileUnit::addPubTypes(DISubprogram SP) {
620 DICompositeType SPTy = SP.getType();
621 unsigned SPTag = SPTy.getTag();
622 if (SPTag != dwarf::DW_TAG_subroutine_type)
625 DIArray Args = SPTy.getTypeArray();
626 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
627 DIType ATy(Args.getElement(i));
630 DICompositeType CATy = getDICompositeType(ATy);
631 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
632 && !CATy.isForwardDecl()) {
633 if (DIEEntry *Entry = getDIEEntry(CATy))
634 addGlobalType(CATy.getName(), Entry->getEntry());
639 /// constructTypeDIE - Construct basic type die from DIBasicType.
640 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
641 // Get core information.
642 StringRef Name = BTy.getName();
643 Buffer.setTag(dwarf::DW_TAG_base_type);
644 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
647 // Add name if not anonymous or intermediate type.
649 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
650 uint64_t Size = BTy.getSizeInBits() >> 3;
651 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
654 /// constructTypeDIE - Construct derived type die from DIDerivedType.
655 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
656 // Get core information.
657 StringRef Name = DTy.getName();
658 uint64_t Size = DTy.getSizeInBits() >> 3;
659 unsigned Tag = DTy.getTag();
661 // FIXME - Workaround for templates.
662 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
666 // Map to main type, void will not have a type.
667 DIType FromTy = DTy.getTypeDerivedFrom();
668 addType(&Buffer, FromTy);
670 // Add name if not anonymous or intermediate type.
672 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
674 // Add size if non-zero (derived types might be zero-sized.)
676 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
678 // Add source line info if available and TyDesc is not a forward declaration.
679 if (!DTy.isForwardDecl())
680 addSourceLine(&Buffer, DTy);
683 /// constructTypeDIE - Construct type DIE from DICompositeType.
684 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
685 // Get core information.
686 StringRef Name = CTy.getName();
688 uint64_t Size = CTy.getSizeInBits() >> 3;
689 unsigned Tag = CTy.getTag();
693 case dwarf::DW_TAG_vector_type:
694 case dwarf::DW_TAG_array_type:
695 constructArrayTypeDIE(Buffer, &CTy);
697 case dwarf::DW_TAG_enumeration_type: {
698 DIArray Elements = CTy.getTypeArray();
700 // Add enumerators to enumeration type.
701 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
703 DIDescriptor Enum(Elements.getElement(i));
704 if (Enum.isEnumerator()) {
705 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
706 Buffer.addChild(ElemDie);
711 case dwarf::DW_TAG_subroutine_type: {
713 DIArray Elements = CTy.getTypeArray();
714 DIDescriptor RTy = Elements.getElement(0);
715 addType(&Buffer, DIType(RTy));
717 bool isPrototyped = true;
719 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
720 DIDescriptor Ty = Elements.getElement(i);
721 if (Ty.isUnspecifiedParameter()) {
722 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
723 Buffer.addChild(Arg);
724 isPrototyped = false;
726 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
727 addType(Arg, DIType(Ty));
728 Buffer.addChild(Arg);
731 // Add prototype flag.
733 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
736 case dwarf::DW_TAG_structure_type:
737 case dwarf::DW_TAG_union_type:
738 case dwarf::DW_TAG_class_type: {
739 // Add elements to structure type.
740 DIArray Elements = CTy.getTypeArray();
742 // A forward struct declared type may not have elements available.
743 unsigned N = Elements.getNumElements();
747 // Add elements to structure type.
748 for (unsigned i = 0; i < N; ++i) {
749 DIDescriptor Element = Elements.getElement(i);
751 if (Element.isSubprogram()) {
752 DISubprogram SP(Element);
753 ElemDie = DD->createSubprogramDIE(DISubprogram(Element));
754 if (SP.isProtected())
755 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
756 dwarf::DW_ACCESS_protected);
757 else if (SP.isPrivate())
758 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
759 dwarf::DW_ACCESS_private);
761 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
762 dwarf::DW_ACCESS_public);
764 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
766 else if (Element.isVariable()) {
767 DIVariable DV(Element);
768 ElemDie = new DIE(dwarf::DW_TAG_variable);
769 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
771 addType(ElemDie, DV.getType());
772 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
773 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
774 addSourceLine(ElemDie, DV);
775 } else if (Element.isDerivedType())
776 ElemDie = createMemberDIE(DIDerivedType(Element));
779 Buffer.addChild(ElemDie);
782 if (CTy.isAppleBlockExtension())
783 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
785 unsigned RLang = CTy.getRunTimeLang();
787 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
788 dwarf::DW_FORM_data1, RLang);
790 DICompositeType ContainingType = CTy.getContainingType();
791 if (DIDescriptor(ContainingType).isCompositeType())
792 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
793 getOrCreateTypeDIE(DIType(ContainingType)));
795 DIDescriptor Context = CTy.getContext();
796 addToContextOwner(&Buffer, Context);
799 if (CTy.isObjcClassComplete())
800 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
801 dwarf::DW_FORM_flag, 1);
803 if (Tag == dwarf::DW_TAG_class_type)
804 addTemplateParams(Buffer, CTy.getTemplateParams());
812 // Add name if not anonymous or intermediate type.
814 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
816 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
817 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
819 // Add size if non-zero (derived types might be zero-sized.)
821 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
823 // Add zero size if it is not a forward declaration.
824 if (CTy.isForwardDecl())
825 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
827 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
830 // Add source line info if available.
831 if (!CTy.isForwardDecl())
832 addSourceLine(&Buffer, CTy);
836 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
837 /// for the given DITemplateTypeParameter.
839 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
840 DIE *ParamDIE = getDIE(TP);
844 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
845 addType(ParamDIE, TP.getType());
846 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
850 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
851 /// for the given DITemplateValueParameter.
853 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
854 DIE *ParamDIE = getDIE(TPV);
858 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
859 addType(ParamDIE, TPV.getType());
860 if (!TPV.getName().empty())
861 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
862 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
867 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
868 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
869 DIE *NDie = getDIE(NS);
872 NDie = new DIE(dwarf::DW_TAG_namespace);
874 if (!NS.getName().empty())
875 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
876 addSourceLine(NDie, NS);
877 addToContextOwner(NDie, NS.getContext());
881 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
882 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
883 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
884 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
885 int64_t L = SR.getLo();
886 int64_t H = SR.getHi();
888 // The L value defines the lower bounds which is typically zero for C/C++. The
889 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
890 // of the array. If L > H then do not emit DW_AT_lower_bound and
891 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
892 // array has one element and in such case do not emit lower bound.
895 Buffer.addChild(DW_Subrange);
899 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
900 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
901 Buffer.addChild(DW_Subrange);
904 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
905 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
906 DICompositeType *CTy) {
907 Buffer.setTag(dwarf::DW_TAG_array_type);
908 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
909 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
911 // Emit derived type.
912 addType(&Buffer, CTy->getTypeDerivedFrom());
913 DIArray Elements = CTy->getTypeArray();
915 // Get an anonymous type for index type.
916 DIE *IdxTy = getIndexTyDie();
918 // Construct an anonymous type for index type.
919 IdxTy = new DIE(dwarf::DW_TAG_base_type);
920 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
921 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
922 dwarf::DW_ATE_signed);
924 setIndexTyDie(IdxTy);
927 // Add subranges to array type.
928 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
929 DIDescriptor Element = Elements.getElement(i);
930 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
931 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
935 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
936 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
937 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
938 StringRef Name = ETy.getName();
939 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
940 int64_t Value = ETy.getEnumValue();
941 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
945 /// createMemberDIE - Create new member DIE.
946 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
947 DIE *MemberDie = new DIE(DT.getTag());
948 StringRef Name = DT.getName();
950 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
952 addType(MemberDie, DT.getTypeDerivedFrom());
954 addSourceLine(MemberDie, DT);
956 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
957 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
959 uint64_t Size = DT.getSizeInBits();
960 uint64_t FieldSize = DT.getOriginalTypeSize();
962 if (Size != FieldSize) {
964 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
965 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
967 uint64_t Offset = DT.getOffsetInBits();
968 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
969 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
970 uint64_t FieldOffset = (HiMark - FieldSize);
971 Offset -= FieldOffset;
973 // Maybe we need to work from the other end.
974 if (Asm->getTargetData().isLittleEndian())
975 Offset = FieldSize - (Offset + Size);
976 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
978 // Here WD_AT_data_member_location points to the anonymous
979 // field that includes this bit field.
980 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
983 // This is not a bitfield.
984 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
986 if (DT.getTag() == dwarf::DW_TAG_inheritance
989 // For C++, virtual base classes are not at fixed offset. Use following
990 // expression to extract appropriate offset from vtable.
991 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
993 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
994 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
995 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
996 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
997 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
998 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
999 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1000 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1002 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1005 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1007 if (DT.isProtected())
1008 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1009 dwarf::DW_ACCESS_protected);
1010 else if (DT.isPrivate())
1011 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1012 dwarf::DW_ACCESS_private);
1013 // Otherwise C++ member and base classes are considered public.
1014 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1015 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1016 dwarf::DW_ACCESS_public);
1018 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1019 dwarf::DW_VIRTUALITY_virtual);
1021 // Objective-C properties.
1022 StringRef PropertyName = DT.getObjCPropertyName();
1023 if (!PropertyName.empty()) {
1024 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string,
1026 StringRef GetterName = DT.getObjCPropertyGetterName();
1027 if (!GetterName.empty())
1028 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter,
1029 dwarf::DW_FORM_string, GetterName);
1030 StringRef SetterName = DT.getObjCPropertySetterName();
1031 if (!SetterName.empty())
1032 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter,
1033 dwarf::DW_FORM_string, SetterName);
1034 unsigned PropertyAttributes = 0;
1035 if (DT.isReadOnlyObjCProperty())
1036 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1037 if (DT.isReadWriteObjCProperty())
1038 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1039 if (DT.isAssignObjCProperty())
1040 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1041 if (DT.isRetainObjCProperty())
1042 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1043 if (DT.isCopyObjCProperty())
1044 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1045 if (DT.isNonAtomicObjCProperty())
1046 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1047 if (PropertyAttributes)
1048 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1049 PropertyAttributes);