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.
159 // If the line number is 0, don't add it.
160 if (SP.getLineNumber() == 0)
163 unsigned Line = SP.getLineNumber();
164 if (!SP.getContext().Verify())
166 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
168 assert(FileID && "Invalid file id");
169 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
170 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
173 /// addSourceLine - Add location information to specified debug information
175 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
180 unsigned Line = Ty.getLineNumber();
181 if (Line == 0 || !Ty.getContext().Verify())
183 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
185 assert(FileID && "Invalid file id");
186 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
187 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
190 /// addSourceLine - Add location information to specified debug information
192 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
197 unsigned Line = NS.getLineNumber();
200 StringRef FN = NS.getFilename();
202 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
203 assert(FileID && "Invalid file id");
204 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
205 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
208 /// addVariableAddress - Add DW_AT_location attribute for a
209 /// DbgVariable based on provided MachineLocation.
210 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
211 MachineLocation Location) {
212 if (DV->variableHasComplexAddress())
213 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
214 else if (DV->isBlockByrefVariable())
215 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
217 addAddress(Die, dwarf::DW_AT_location, Location);
220 /// addRegisterOp - Add register operand.
221 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
222 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
223 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
225 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
227 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
228 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
232 /// addRegisterOffset - Add register offset.
233 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
235 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
236 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
237 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
238 if (Reg == TRI->getFrameRegister(*Asm->MF))
239 // If variable offset is based in frame register then use fbreg.
240 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
242 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
244 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
245 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
247 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
250 /// addAddress - Add an address attribute to a die based on the location
252 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
253 const MachineLocation &Location) {
254 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
256 if (Location.isReg())
257 addRegisterOp(Block, Location.getReg());
259 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
261 // Now attach the location information to the DIE.
262 addBlock(Die, Attribute, 0, Block);
265 /// addComplexAddress - Start with the address based on the location provided,
266 /// and generate the DWARF information necessary to find the actual variable
267 /// given the extra address information encoded in the DIVariable, starting from
268 /// the starting location. Add the DWARF information to the die.
270 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
272 const MachineLocation &Location) {
273 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
274 unsigned N = DV->getNumAddrElements();
276 if (Location.isReg()) {
277 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
278 // If first address element is OpPlus then emit
279 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
280 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
283 addRegisterOp(Block, Location.getReg());
286 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
289 uint64_t Element = DV->getAddrElement(i);
290 if (Element == DIBuilder::OpPlus) {
291 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
292 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
293 } else if (Element == DIBuilder::OpDeref) {
294 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
295 } else llvm_unreachable("unknown DIBuilder Opcode");
298 // Now attach the location information to the DIE.
299 addBlock(Die, Attribute, 0, Block);
302 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
303 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
304 gives the variable VarName either the struct, or a pointer to the struct, as
305 its type. This is necessary for various behind-the-scenes things the
306 compiler needs to do with by-reference variables in Blocks.
308 However, as far as the original *programmer* is concerned, the variable
309 should still have type 'SomeType', as originally declared.
311 The function getBlockByrefType dives into the __Block_byref_x_VarName
312 struct to find the original type of the variable, which is then assigned to
313 the variable's Debug Information Entry as its real type. So far, so good.
314 However now the debugger will expect the variable VarName to have the type
315 SomeType. So we need the location attribute for the variable to be an
316 expression that explains to the debugger how to navigate through the
317 pointers and struct to find the actual variable of type SomeType.
319 The following function does just that. We start by getting
320 the "normal" location for the variable. This will be the location
321 of either the struct __Block_byref_x_VarName or the pointer to the
322 struct __Block_byref_x_VarName.
324 The struct will look something like:
326 struct __Block_byref_x_VarName {
328 struct __Block_byref_x_VarName *forwarding;
329 ... <various other fields>
331 ... <maybe more fields>
334 If we are given the struct directly (as our starting point) we
335 need to tell the debugger to:
337 1). Add the offset of the forwarding field.
339 2). Follow that pointer to get the real __Block_byref_x_VarName
340 struct to use (the real one may have been copied onto the heap).
342 3). Add the offset for the field VarName, to find the actual variable.
344 If we started with a pointer to the struct, then we need to
345 dereference that pointer first, before the other steps.
346 Translating this into DWARF ops, we will need to append the following
347 to the current location description for the variable:
349 DW_OP_deref -- optional, if we start with a pointer
350 DW_OP_plus_uconst <forward_fld_offset>
352 DW_OP_plus_uconst <varName_fld_offset>
354 That is what this function does. */
356 /// addBlockByrefAddress - Start with the address based on the location
357 /// provided, and generate the DWARF information necessary to find the
358 /// actual Block variable (navigating the Block struct) based on the
359 /// starting location. Add the DWARF information to the die. For
360 /// more information, read large comment just above here.
362 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
364 const MachineLocation &Location) {
365 DIType Ty = DV->getType();
367 unsigned Tag = Ty.getTag();
368 bool isPointer = false;
370 StringRef varName = DV->getName();
372 if (Tag == dwarf::DW_TAG_pointer_type) {
373 DIDerivedType DTy = DIDerivedType(Ty);
374 TmpTy = DTy.getTypeDerivedFrom();
378 DICompositeType blockStruct = DICompositeType(TmpTy);
380 // Find the __forwarding field and the variable field in the __Block_byref
382 DIArray Fields = blockStruct.getTypeArray();
383 DIDescriptor varField = DIDescriptor();
384 DIDescriptor forwardingField = DIDescriptor();
386 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
387 DIDescriptor Element = Fields.getElement(i);
388 DIDerivedType DT = DIDerivedType(Element);
389 StringRef fieldName = DT.getName();
390 if (fieldName == "__forwarding")
391 forwardingField = Element;
392 else if (fieldName == varName)
396 // Get the offsets for the forwarding field and the variable field.
397 unsigned forwardingFieldOffset =
398 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
399 unsigned varFieldOffset =
400 DIDerivedType(varField).getOffsetInBits() >> 3;
402 // Decode the original location, and use that as the start of the byref
403 // variable's location.
404 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
405 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
406 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
408 if (Location.isReg()) {
410 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
412 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
413 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
417 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
419 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
420 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
423 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
426 // If we started with a pointer to the __Block_byref... struct, then
427 // the first thing we need to do is dereference the pointer (DW_OP_deref).
429 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
431 // Next add the offset for the '__forwarding' field:
432 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
433 // adding the offset if it's 0.
434 if (forwardingFieldOffset > 0) {
435 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
436 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
439 // Now dereference the __forwarding field to get to the real __Block_byref
440 // struct: DW_OP_deref.
441 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
443 // Now that we've got the real __Block_byref... struct, add the offset
444 // for the variable's field to get to the location of the actual variable:
445 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
446 if (varFieldOffset > 0) {
447 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
448 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
451 // Now attach the location information to the DIE.
452 addBlock(Die, Attribute, 0, Block);
455 /// isTypeSigned - Return true if the type is signed.
456 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
457 if (Ty.isDerivedType())
458 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
459 if (Ty.isBasicType())
460 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
461 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
462 *SizeInBits = Ty.getSizeInBits();
468 /// addConstantValue - Add constant value entry in variable DIE.
469 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
471 assert(MO.isImm() && "Invalid machine operand!");
472 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
474 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
475 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
476 switch (SizeInBits) {
477 case 8: Form = dwarf::DW_FORM_data1; break;
478 case 16: Form = dwarf::DW_FORM_data2; break;
479 case 32: Form = dwarf::DW_FORM_data4; break;
480 case 64: Form = dwarf::DW_FORM_data8; break;
483 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
484 : addUInt(Block, 0, Form, MO.getImm());
486 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
490 /// addConstantFPValue - Add constant value entry in variable DIE.
491 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
492 assert (MO.isFPImm() && "Invalid machine operand!");
493 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
494 APFloat FPImm = MO.getFPImm()->getValueAPF();
496 // Get the raw data form of the floating point.
497 const APInt FltVal = FPImm.bitcastToAPInt();
498 const char *FltPtr = (const char*)FltVal.getRawData();
500 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
501 bool LittleEndian = Asm->getTargetData().isLittleEndian();
502 int Incr = (LittleEndian ? 1 : -1);
503 int Start = (LittleEndian ? 0 : NumBytes - 1);
504 int Stop = (LittleEndian ? NumBytes : -1);
506 // Output the constant to DWARF one byte at a time.
507 for (; Start != Stop; Start += Incr)
508 addUInt(Block, 0, dwarf::DW_FORM_data1,
509 (unsigned char)0xFF & FltPtr[Start]);
511 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
515 /// addConstantValue - Add constant value entry in variable DIE.
516 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
518 unsigned CIBitWidth = CI->getBitWidth();
519 if (CIBitWidth <= 64) {
521 switch (CIBitWidth) {
522 case 8: form = dwarf::DW_FORM_data1; break;
523 case 16: form = dwarf::DW_FORM_data2; break;
524 case 32: form = dwarf::DW_FORM_data4; break;
525 case 64: form = dwarf::DW_FORM_data8; break;
527 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
530 addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
532 addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
536 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
538 // Get the raw data form of the large APInt.
539 const APInt Val = CI->getValue();
540 const uint64_t *Ptr64 = Val.getRawData();
542 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
543 bool LittleEndian = Asm->getTargetData().isLittleEndian();
545 // Output the constant to DWARF one byte at a time.
546 for (int i = 0; i < NumBytes; i++) {
549 c = Ptr64[i / 8] >> (8 * (i & 7));
551 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
552 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
555 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
559 /// addTemplateParams - Add template parameters in buffer.
560 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
561 // Add template parameters.
562 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
563 DIDescriptor Element = TParams.getElement(i);
564 if (Element.isTemplateTypeParameter())
565 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
566 DITemplateTypeParameter(Element)));
567 else if (Element.isTemplateValueParameter())
568 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
569 DITemplateValueParameter(Element)));
573 /// addToContextOwner - Add Die into the list of its context owner's children.
574 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
575 if (Context.isType()) {
576 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
577 ContextDIE->addChild(Die);
578 } else if (Context.isNameSpace()) {
579 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
580 ContextDIE->addChild(Die);
581 } else if (Context.isSubprogram()) {
582 DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
583 ContextDIE->addChild(Die);
584 } else if (DIE *ContextDIE = getDIE(Context))
585 ContextDIE->addChild(Die);
590 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
592 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
596 DIE *TyDIE = getDIE(Ty);
601 TyDIE = new DIE(dwarf::DW_TAG_base_type);
602 insertDIE(Ty, TyDIE);
603 if (Ty.isBasicType())
604 constructTypeDIE(*TyDIE, DIBasicType(Ty));
605 else if (Ty.isCompositeType())
606 constructTypeDIE(*TyDIE, DICompositeType(Ty));
608 assert(Ty.isDerivedType() && "Unknown kind of DIType");
609 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
611 // If this is a named finished type then include it in the list of types
612 // for the accelerator tables.
613 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
614 bool IsImplementation = 0;
615 if (Ty.isCompositeType()) {
616 DICompositeType CT(Ty);
617 // A runtime language of 0 actually means C/C++ and that any
618 // non-negative value is some version of Objective-C/C++.
619 IsImplementation = (CT.getRunTimeLang() == 0) ||
620 CT.isObjcClassComplete();
622 unsigned Flags = IsImplementation ?
623 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
624 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
627 addToContextOwner(TyDIE, Ty.getContext());
631 /// addType - Add a new type attribute to the specified entity.
632 void CompileUnit::addType(DIE *Entity, DIType Ty) {
636 // Check for pre-existence.
637 DIEEntry *Entry = getDIEEntry(Ty);
638 // If it exists then use the existing value.
640 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
645 DIE *Buffer = getOrCreateTypeDIE(Ty);
648 Entry = createDIEEntry(Buffer);
649 insertDIEEntry(Ty, Entry);
650 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
652 // If this is a complete composite type then include it in the
653 // list of global types.
657 /// addGlobalType - Add a new global type to the compile unit.
659 void CompileUnit::addGlobalType(DIType Ty) {
660 DIDescriptor Context = Ty.getContext();
661 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
662 && (!Context || Context.isCompileUnit() || Context.isFile()
663 || Context.isNameSpace()))
664 if (DIEEntry *Entry = getDIEEntry(Ty))
665 GlobalTypes[Ty.getName()] = Entry->getEntry();
668 /// addPubTypes - Add type for pubtypes section.
669 void CompileUnit::addPubTypes(DISubprogram SP) {
670 DICompositeType SPTy = SP.getType();
671 unsigned SPTag = SPTy.getTag();
672 if (SPTag != dwarf::DW_TAG_subroutine_type)
675 DIArray Args = SPTy.getTypeArray();
676 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
677 DIType ATy(Args.getElement(i));
684 /// constructTypeDIE - Construct basic type die from DIBasicType.
685 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
686 // Get core information.
687 StringRef Name = BTy.getName();
688 // Add name if not anonymous or intermediate type.
690 addString(&Buffer, dwarf::DW_AT_name, Name);
692 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
693 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
694 // Unspecified types has only name, nothing else.
698 Buffer.setTag(dwarf::DW_TAG_base_type);
699 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
702 uint64_t Size = BTy.getSizeInBits() >> 3;
703 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
706 /// constructTypeDIE - Construct derived type die from DIDerivedType.
707 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
708 // Get core information.
709 StringRef Name = DTy.getName();
710 uint64_t Size = DTy.getSizeInBits() >> 3;
711 unsigned Tag = DTy.getTag();
713 // FIXME - Workaround for templates.
714 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
718 // Map to main type, void will not have a type.
719 DIType FromTy = DTy.getTypeDerivedFrom();
720 addType(&Buffer, FromTy);
722 // Add name if not anonymous or intermediate type.
724 addString(&Buffer, dwarf::DW_AT_name, Name);
726 // Add size if non-zero (derived types might be zero-sized.)
727 if (Size && Tag != dwarf::DW_TAG_pointer_type)
728 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
730 // Add source line info if available and TyDesc is not a forward declaration.
731 if (!DTy.isForwardDecl())
732 addSourceLine(&Buffer, DTy);
735 /// constructTypeDIE - Construct type DIE from DICompositeType.
736 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
737 // Get core information.
738 StringRef Name = CTy.getName();
740 uint64_t Size = CTy.getSizeInBits() >> 3;
741 unsigned Tag = CTy.getTag();
745 case dwarf::DW_TAG_vector_type:
746 case dwarf::DW_TAG_array_type:
747 constructArrayTypeDIE(Buffer, &CTy);
749 case dwarf::DW_TAG_enumeration_type: {
750 DIArray Elements = CTy.getTypeArray();
752 // Add enumerators to enumeration type.
753 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
755 DIDescriptor Enum(Elements.getElement(i));
756 if (Enum.isEnumerator()) {
757 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
758 Buffer.addChild(ElemDie);
763 case dwarf::DW_TAG_subroutine_type: {
765 DIArray Elements = CTy.getTypeArray();
766 DIDescriptor RTy = Elements.getElement(0);
767 addType(&Buffer, DIType(RTy));
769 bool isPrototyped = true;
771 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
772 DIDescriptor Ty = Elements.getElement(i);
773 if (Ty.isUnspecifiedParameter()) {
774 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
775 Buffer.addChild(Arg);
776 isPrototyped = false;
778 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
779 addType(Arg, DIType(Ty));
780 Buffer.addChild(Arg);
783 // Add prototype flag if we're dealing with a C language and the
784 // function has been prototyped.
786 (Language == dwarf::DW_LANG_C89 ||
787 Language == dwarf::DW_LANG_C99 ||
788 Language == dwarf::DW_LANG_ObjC))
789 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
792 case dwarf::DW_TAG_structure_type:
793 case dwarf::DW_TAG_union_type:
794 case dwarf::DW_TAG_class_type: {
795 // Add elements to structure type.
796 DIArray Elements = CTy.getTypeArray();
798 // A forward struct declared type may not have elements available.
799 unsigned N = Elements.getNumElements();
803 // Add elements to structure type.
804 for (unsigned i = 0; i < N; ++i) {
805 DIDescriptor Element = Elements.getElement(i);
807 if (Element.isSubprogram()) {
808 DISubprogram SP(Element);
809 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
810 if (SP.isProtected())
811 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
812 dwarf::DW_ACCESS_protected);
813 else if (SP.isPrivate())
814 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
815 dwarf::DW_ACCESS_private);
817 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
818 dwarf::DW_ACCESS_public);
820 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
822 else if (Element.isVariable()) {
823 DIVariable DV(Element);
824 ElemDie = new DIE(dwarf::DW_TAG_variable);
825 addString(ElemDie, dwarf::DW_AT_name, DV.getName());
826 addType(ElemDie, DV.getType());
827 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
828 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
829 addSourceLine(ElemDie, DV);
830 } else if (Element.isDerivedType())
831 ElemDie = createMemberDIE(DIDerivedType(Element));
832 else if (Element.isObjCProperty()) {
833 DIObjCProperty Property(Element);
834 ElemDie = new DIE(Property.getTag());
835 StringRef PropertyName = Property.getObjCPropertyName();
836 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
837 StringRef GetterName = Property.getObjCPropertyGetterName();
838 if (!GetterName.empty())
839 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
840 StringRef SetterName = Property.getObjCPropertySetterName();
841 if (!SetterName.empty())
842 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
843 unsigned PropertyAttributes = 0;
844 if (Property.isReadOnlyObjCProperty())
845 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
846 if (Property.isReadWriteObjCProperty())
847 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
848 if (Property.isAssignObjCProperty())
849 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
850 if (Property.isRetainObjCProperty())
851 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
852 if (Property.isCopyObjCProperty())
853 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
854 if (Property.isNonAtomicObjCProperty())
855 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
856 if (PropertyAttributes)
857 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
860 DIEEntry *Entry = getDIEEntry(Element);
862 Entry = createDIEEntry(ElemDie);
863 insertDIEEntry(Element, Entry);
867 Buffer.addChild(ElemDie);
870 if (CTy.isAppleBlockExtension())
871 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
873 DICompositeType ContainingType = CTy.getContainingType();
874 if (DIDescriptor(ContainingType).isCompositeType())
875 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
876 getOrCreateTypeDIE(DIType(ContainingType)));
878 DIDescriptor Context = CTy.getContext();
879 addToContextOwner(&Buffer, Context);
882 if (CTy.isObjcClassComplete())
883 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
884 dwarf::DW_FORM_flag, 1);
886 // Add template parameters to a class, structure or union types.
887 // FIXME: The support isn't in the metadata for this yet.
888 if (Tag == dwarf::DW_TAG_class_type ||
889 Tag == dwarf::DW_TAG_structure_type ||
890 Tag == dwarf::DW_TAG_union_type)
891 addTemplateParams(Buffer, CTy.getTemplateParams());
899 // Add name if not anonymous or intermediate type.
901 addString(&Buffer, dwarf::DW_AT_name, Name);
903 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
904 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
906 // Add size if non-zero (derived types might be zero-sized.)
908 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
910 // Add zero size if it is not a forward declaration.
911 if (CTy.isForwardDecl())
912 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
914 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
917 // Add source line info if available.
918 if (!CTy.isForwardDecl())
919 addSourceLine(&Buffer, CTy);
921 // No harm in adding the runtime language to the declaration.
922 unsigned RLang = CTy.getRunTimeLang();
924 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
925 dwarf::DW_FORM_data1, RLang);
929 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
930 /// for the given DITemplateTypeParameter.
932 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
933 DIE *ParamDIE = getDIE(TP);
937 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
938 addType(ParamDIE, TP.getType());
939 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
943 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
944 /// for the given DITemplateValueParameter.
946 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
947 DIE *ParamDIE = getDIE(TPV);
951 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
952 addType(ParamDIE, TPV.getType());
953 if (!TPV.getName().empty())
954 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
955 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
960 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
961 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
962 DIE *NDie = getDIE(NS);
965 NDie = new DIE(dwarf::DW_TAG_namespace);
967 if (!NS.getName().empty()) {
968 addString(NDie, dwarf::DW_AT_name, NS.getName());
969 addAccelNamespace(NS.getName(), NDie);
971 addAccelNamespace("(anonymous namespace)", NDie);
972 addSourceLine(NDie, NS);
973 addToContextOwner(NDie, NS.getContext());
977 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
978 /// printer to not emit usual symbol prefix before the symbol name is used then
979 /// return linkage name after skipping this special LLVM prefix.
980 static StringRef getRealLinkageName(StringRef LinkageName) {
982 if (LinkageName.startswith(StringRef(&One, 1)))
983 return LinkageName.substr(1);
987 /// getOrCreateSubprogramDIE - Create new DIE using SP.
988 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
989 DIE *SPDie = getDIE(SP);
993 DISubprogram SPDecl = SP.getFunctionDeclaration();
995 if (SPDecl.isSubprogram()) {
996 DeclDie = getOrCreateSubprogramDIE(SPDecl);
999 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1001 // DW_TAG_inlined_subroutine may refer to this DIE.
1002 insertDIE(SP, SPDie);
1004 // Add to context owner.
1005 addToContextOwner(SPDie, SP.getContext());
1007 // Add function template parameters.
1008 addTemplateParams(*SPDie, SP.getTemplateParams());
1010 // If this DIE is going to refer declaration info using AT_specification
1011 // then there is no need to add other attributes.
1013 // Refer function declaration directly.
1014 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1020 StringRef LinkageName = SP.getLinkageName();
1021 if (!LinkageName.empty())
1022 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1023 getRealLinkageName(LinkageName));
1025 // Constructors and operators for anonymous aggregates do not have names.
1026 if (!SP.getName().empty())
1027 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1029 addSourceLine(SPDie, SP);
1031 // Add the prototype if we have a prototype and we have a C like
1033 if (SP.isPrototyped() &&
1034 (Language == dwarf::DW_LANG_C89 ||
1035 Language == dwarf::DW_LANG_C99 ||
1036 Language == dwarf::DW_LANG_ObjC))
1037 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1040 DICompositeType SPTy = SP.getType();
1041 DIArray Args = SPTy.getTypeArray();
1042 unsigned SPTag = SPTy.getTag();
1044 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1045 addType(SPDie, SPTy);
1047 addType(SPDie, DIType(Args.getElement(0)));
1049 unsigned VK = SP.getVirtuality();
1051 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1052 DIEBlock *Block = getDIEBlock();
1053 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1054 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1055 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1056 ContainingTypeMap.insert(std::make_pair(SPDie,
1057 SP.getContainingType()));
1060 if (!SP.isDefinition()) {
1061 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1063 // Add arguments. Do not add arguments for subprogram definition. They will
1064 // be handled while processing variables.
1065 DICompositeType SPTy = SP.getType();
1066 DIArray Args = SPTy.getTypeArray();
1067 unsigned SPTag = SPTy.getTag();
1069 if (SPTag == dwarf::DW_TAG_subroutine_type)
1070 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1071 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1072 DIType ATy = DIType(DIType(Args.getElement(i)));
1074 if (ATy.isArtificial())
1075 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1076 SPDie->addChild(Arg);
1080 if (SP.isArtificial())
1081 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1083 if (!SP.isLocalToUnit())
1084 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1086 if (SP.isOptimized())
1087 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1089 if (unsigned isa = Asm->getISAEncoding()) {
1090 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1096 // Return const expression if value is a GEP to access merged global
1098 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1099 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1100 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1101 if (!CE || CE->getNumOperands() != 3 ||
1102 CE->getOpcode() != Instruction::GetElementPtr)
1105 // First operand points to a global struct.
1106 Value *Ptr = CE->getOperand(0);
1107 if (!isa<GlobalValue>(Ptr) ||
1108 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1111 // Second operand is zero.
1112 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1113 if (!CI || !CI->isZero())
1116 // Third operand is offset.
1117 if (!isa<ConstantInt>(CE->getOperand(2)))
1123 /// createGlobalVariableDIE - create global variable DIE.
1124 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1125 // Check for pre-existence.
1129 DIGlobalVariable GV(N);
1133 DIE *VariableDIE = new DIE(GV.getTag());
1135 insertDIE(N, VariableDIE);
1138 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1139 StringRef LinkageName = GV.getLinkageName();
1140 bool isGlobalVariable = GV.getGlobal() != NULL;
1141 if (!LinkageName.empty() && isGlobalVariable)
1142 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1143 getRealLinkageName(LinkageName));
1145 DIType GTy = GV.getType();
1146 addType(VariableDIE, GTy);
1148 // Add scoping info.
1149 if (!GV.isLocalToUnit())
1150 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1152 // Add line number info.
1153 addSourceLine(VariableDIE, GV);
1154 // Add to context owner.
1155 DIDescriptor GVContext = GV.getContext();
1156 addToContextOwner(VariableDIE, GVContext);
1158 bool addToAccelTable = false;
1159 DIE *VariableSpecDIE = NULL;
1160 if (isGlobalVariable) {
1161 addToAccelTable = true;
1162 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1163 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1164 addLabel(Block, 0, dwarf::DW_FORM_udata,
1165 Asm->Mang->getSymbol(GV.getGlobal()));
1166 // Do not create specification DIE if context is either compile unit
1168 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1169 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1170 // Create specification DIE.
1171 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1172 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1173 dwarf::DW_FORM_ref4, VariableDIE);
1174 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1175 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1177 addDie(VariableSpecDIE);
1179 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1181 } else if (const ConstantInt *CI =
1182 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1183 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1184 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1185 addToAccelTable = true;
1186 // GV is a merged global.
1187 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1188 Value *Ptr = CE->getOperand(0);
1189 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1190 addLabel(Block, 0, dwarf::DW_FORM_udata,
1191 Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1192 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1193 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1194 addUInt(Block, 0, dwarf::DW_FORM_udata,
1195 Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1196 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1197 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1200 if (addToAccelTable) {
1201 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1202 addAccelName(GV.getName(), AddrDIE);
1204 // If the linkage name is different than the name, go ahead and output
1205 // that as well into the name table.
1206 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1207 addAccelName(GV.getLinkageName(), AddrDIE);
1213 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1214 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1215 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1216 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1217 uint64_t L = SR.getLo();
1218 uint64_t H = SR.getHi();
1220 // The L value defines the lower bounds which is typically zero for C/C++. The
1221 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1222 // of the array. If L > H then do not emit DW_AT_lower_bound and
1223 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1224 // array has one element and in such case do not emit lower bound.
1227 Buffer.addChild(DW_Subrange);
1231 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1232 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1233 Buffer.addChild(DW_Subrange);
1236 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1237 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1238 DICompositeType *CTy) {
1239 Buffer.setTag(dwarf::DW_TAG_array_type);
1240 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1241 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1243 // Emit derived type.
1244 addType(&Buffer, CTy->getTypeDerivedFrom());
1245 DIArray Elements = CTy->getTypeArray();
1247 // Get an anonymous type for index type.
1248 DIE *IdxTy = getIndexTyDie();
1250 // Construct an anonymous type for index type.
1251 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1252 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1253 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1254 dwarf::DW_ATE_signed);
1256 setIndexTyDie(IdxTy);
1259 // Add subranges to array type.
1260 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1261 DIDescriptor Element = Elements.getElement(i);
1262 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1263 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1267 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1268 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1269 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1270 StringRef Name = ETy.getName();
1271 addString(Enumerator, dwarf::DW_AT_name, Name);
1272 int64_t Value = ETy.getEnumValue();
1273 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1277 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1279 void CompileUnit::constructContainingTypeDIEs() {
1280 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1281 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1282 DIE *SPDie = CI->first;
1283 const MDNode *N = CI->second;
1285 DIE *NDie = getDIE(N);
1286 if (!NDie) continue;
1287 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1291 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1292 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1293 StringRef Name = DV->getName();
1297 // Translate tag to proper Dwarf tag.
1298 unsigned Tag = DV->getTag();
1300 // Define variable debug information entry.
1301 DIE *VariableDie = new DIE(Tag);
1302 DbgVariable *AbsVar = DV->getAbstractVariable();
1303 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1305 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1306 dwarf::DW_FORM_ref4, AbsDIE);
1308 addString(VariableDie, dwarf::DW_AT_name, Name);
1309 addSourceLine(VariableDie, DV->getVariable());
1310 addType(VariableDie, DV->getType());
1313 if (DV->isArtificial())
1314 addUInt(VariableDie, dwarf::DW_AT_artificial,
1315 dwarf::DW_FORM_flag, 1);
1317 if (isScopeAbstract) {
1318 DV->setDIE(VariableDie);
1322 // Add variable address.
1324 unsigned Offset = DV->getDotDebugLocOffset();
1325 if (Offset != ~0U) {
1326 addLabel(VariableDie, dwarf::DW_AT_location,
1327 dwarf::DW_FORM_data4,
1328 Asm->GetTempSymbol("debug_loc", Offset));
1329 DV->setDIE(VariableDie);
1333 // Check if variable is described by a DBG_VALUE instruction.
1334 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1335 bool updated = false;
1336 if (DVInsn->getNumOperands() == 3) {
1337 if (DVInsn->getOperand(0).isReg()) {
1338 const MachineOperand RegOp = DVInsn->getOperand(0);
1339 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1340 if (DVInsn->getOperand(1).isImm() &&
1341 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1342 unsigned FrameReg = 0;
1343 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1345 TFI->getFrameIndexReference(*Asm->MF,
1346 DVInsn->getOperand(1).getImm(),
1348 MachineLocation Location(FrameReg, Offset);
1349 addVariableAddress(DV, VariableDie, Location);
1351 } else if (RegOp.getReg())
1352 addVariableAddress(DV, VariableDie,
1353 MachineLocation(RegOp.getReg()));
1356 else if (DVInsn->getOperand(0).isImm())
1358 addConstantValue(VariableDie, DVInsn->getOperand(0),
1360 else if (DVInsn->getOperand(0).isFPImm())
1362 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1363 else if (DVInsn->getOperand(0).isCImm())
1365 addConstantValue(VariableDie,
1366 DVInsn->getOperand(0).getCImm(),
1367 DV->getType().isUnsignedDIType());
1369 addVariableAddress(DV, VariableDie,
1370 Asm->getDebugValueLocation(DVInsn));
1374 // If variableDie is not updated then DBG_VALUE instruction does not
1375 // have valid variable info.
1379 DV->setDIE(VariableDie);
1382 // .. else use frame index.
1383 int FI = DV->getFrameIndex();
1385 unsigned FrameReg = 0;
1386 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1388 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1389 MachineLocation Location(FrameReg, Offset);
1390 addVariableAddress(DV, VariableDie, Location);
1394 DV->setDIE(VariableDie);
1398 /// createMemberDIE - Create new member DIE.
1399 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1400 DIE *MemberDie = new DIE(DT.getTag());
1401 StringRef Name = DT.getName();
1403 addString(MemberDie, dwarf::DW_AT_name, Name);
1405 addType(MemberDie, DT.getTypeDerivedFrom());
1407 addSourceLine(MemberDie, DT);
1409 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1410 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1412 uint64_t Size = DT.getSizeInBits();
1413 uint64_t FieldSize = DT.getOriginalTypeSize();
1415 if (Size != FieldSize) {
1417 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1418 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1420 uint64_t Offset = DT.getOffsetInBits();
1421 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1422 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1423 uint64_t FieldOffset = (HiMark - FieldSize);
1424 Offset -= FieldOffset;
1426 // Maybe we need to work from the other end.
1427 if (Asm->getTargetData().isLittleEndian())
1428 Offset = FieldSize - (Offset + Size);
1429 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1431 // Here WD_AT_data_member_location points to the anonymous
1432 // field that includes this bit field.
1433 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1436 // This is not a bitfield.
1437 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1439 if (DT.getTag() == dwarf::DW_TAG_inheritance
1440 && DT.isVirtual()) {
1442 // For C++, virtual base classes are not at fixed offset. Use following
1443 // expression to extract appropriate offset from vtable.
1444 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1446 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1447 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1448 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1449 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1450 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1451 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1452 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1453 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1455 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1458 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1460 if (DT.isProtected())
1461 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1462 dwarf::DW_ACCESS_protected);
1463 else if (DT.isPrivate())
1464 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1465 dwarf::DW_ACCESS_private);
1466 // Otherwise C++ member and base classes are considered public.
1468 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1469 dwarf::DW_ACCESS_public);
1471 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1472 dwarf::DW_VIRTUALITY_virtual);
1474 // Objective-C properties.
1475 if (MDNode *PNode = DT.getObjCProperty())
1476 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1477 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1480 // This is only for backward compatibility.
1481 StringRef PropertyName = DT.getObjCPropertyName();
1482 if (!PropertyName.empty()) {
1483 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1484 StringRef GetterName = DT.getObjCPropertyGetterName();
1485 if (!GetterName.empty())
1486 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1487 StringRef SetterName = DT.getObjCPropertySetterName();
1488 if (!SetterName.empty())
1489 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1490 unsigned PropertyAttributes = 0;
1491 if (DT.isReadOnlyObjCProperty())
1492 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1493 if (DT.isReadWriteObjCProperty())
1494 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1495 if (DT.isAssignObjCProperty())
1496 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1497 if (DT.isRetainObjCProperty())
1498 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1499 if (DT.isCopyObjCProperty())
1500 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1501 if (DT.isNonAtomicObjCProperty())
1502 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1503 if (PropertyAttributes)
1504 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1505 PropertyAttributes);