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 constructing a dwarf compile unit.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
16 #include "DwarfCompileUnit.h"
17 #include "DwarfAccelTable.h"
18 #include "DwarfDebug.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/DIBuilder.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/Support/Debug.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
35 /// CompileUnit - Compile unit constructor.
36 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
37 DwarfDebug *DW, DwarfUnits *DWU)
38 : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0),
40 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
44 /// ~CompileUnit - Destructor for compile unit.
45 CompileUnit::~CompileUnit() {
46 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
47 DIEBlocks[j]->~DIEBlock();
50 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
51 /// information entry.
52 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
53 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
57 /// getDefaultLowerBound - Return the default lower bound for an array. If the
58 /// DWARF version doesn't handle the language, return -1.
59 int64_t CompileUnit::getDefaultLowerBound() const {
60 switch (DICompileUnit(Node).getLanguage()) {
64 case dwarf::DW_LANG_C89:
65 case dwarf::DW_LANG_C99:
66 case dwarf::DW_LANG_C:
67 case dwarf::DW_LANG_C_plus_plus:
68 case dwarf::DW_LANG_ObjC:
69 case dwarf::DW_LANG_ObjC_plus_plus:
72 case dwarf::DW_LANG_Fortran77:
73 case dwarf::DW_LANG_Fortran90:
74 case dwarf::DW_LANG_Fortran95:
77 // The languages below have valid values only if the DWARF version >= 4.
78 case dwarf::DW_LANG_Java:
79 case dwarf::DW_LANG_Python:
80 case dwarf::DW_LANG_UPC:
81 case dwarf::DW_LANG_D:
82 if (dwarf::DWARF_VERSION >= 4)
86 case dwarf::DW_LANG_Ada83:
87 case dwarf::DW_LANG_Ada95:
88 case dwarf::DW_LANG_Cobol74:
89 case dwarf::DW_LANG_Cobol85:
90 case dwarf::DW_LANG_Modula2:
91 case dwarf::DW_LANG_Pascal83:
92 case dwarf::DW_LANG_PLI:
93 if (dwarf::DWARF_VERSION >= 4)
101 /// addFlag - Add a flag that is true.
102 void CompileUnit::addFlag(DIE *Die, uint16_t Attribute) {
103 if (DD->getDwarfVersion() >= 4)
104 Die->addValue(Attribute, dwarf::DW_FORM_flag_present,
107 addUInt(Die, Attribute, dwarf::DW_FORM_flag, 1);
110 /// addUInt - Add an unsigned integer attribute data and value.
112 void CompileUnit::addUInt(DIE *Die, uint16_t Attribute,
113 uint16_t Form, uint64_t Integer) {
114 if (!Form) Form = DIEInteger::BestForm(false, Integer);
115 DIEValue *Value = Integer == 1 ?
116 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
117 Die->addValue(Attribute, Form, Value);
120 /// addSInt - Add an signed integer attribute data and value.
122 void CompileUnit::addSInt(DIE *Die, uint16_t Attribute,
123 uint16_t Form, int64_t Integer) {
124 if (!Form) Form = DIEInteger::BestForm(true, Integer);
125 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
126 Die->addValue(Attribute, Form, Value);
129 /// addString - Add a string attribute data and value. We always emit a
130 /// reference to the string pool instead of immediate strings so that DIEs have
131 /// more predictable sizes. In the case of split dwarf we emit an index
132 /// into another table which gets us the static offset into the string
134 void CompileUnit::addString(DIE *Die, uint16_t Attribute, StringRef String) {
137 if (!DD->useSplitDwarf()) {
138 MCSymbol *Symb = DU->getStringPoolEntry(String);
139 if (Asm->needsRelocationsForDwarfStringPool())
140 Value = new (DIEValueAllocator) DIELabel(Symb);
142 MCSymbol *StringPool = DU->getStringPoolSym();
143 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
145 Form = dwarf::DW_FORM_strp;
147 unsigned idx = DU->getStringPoolIndex(String);
148 Value = new (DIEValueAllocator) DIEInteger(idx);
149 Form = dwarf::DW_FORM_GNU_str_index;
151 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
152 Die->addValue(Attribute, Form, Str);
155 /// addLocalString - Add a string attribute data and value. This is guaranteed
156 /// to be in the local string pool instead of indirected.
157 void CompileUnit::addLocalString(DIE *Die, uint16_t Attribute,
159 MCSymbol *Symb = DU->getStringPoolEntry(String);
161 if (Asm->needsRelocationsForDwarfStringPool())
162 Value = new (DIEValueAllocator) DIELabel(Symb);
164 MCSymbol *StringPool = DU->getStringPoolSym();
165 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
167 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
170 /// addExpr - Add a Dwarf expression attribute data and value.
172 void CompileUnit::addExpr(DIE *Die, uint16_t Attribute, uint16_t Form,
173 const MCExpr *Expr) {
174 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
175 Die->addValue(Attribute, Form, Value);
178 /// addLabel - Add a Dwarf label attribute data and value.
180 void CompileUnit::addLabel(DIE *Die, uint16_t Attribute, uint16_t Form,
181 const MCSymbol *Label) {
182 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
183 Die->addValue(Attribute, Form, Value);
186 /// addLabelAddress - Add a dwarf label attribute data and value using
187 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
189 void CompileUnit::addLabelAddress(DIE *Die, uint16_t Attribute,
191 if (!DD->useSplitDwarf()) {
193 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
194 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
196 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
197 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
200 unsigned idx = DU->getAddrPoolIndex(Label);
201 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
202 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
206 /// addOpAddress - Add a dwarf op address data and value using the
207 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
209 void CompileUnit::addOpAddress(DIE *Die, const MCSymbol *Sym) {
210 if (!DD->useSplitDwarf()) {
211 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
212 addLabel(Die, 0, dwarf::DW_FORM_udata, Sym);
214 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
215 addUInt(Die, 0, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
219 /// addDelta - Add a label delta attribute data and value.
221 void CompileUnit::addDelta(DIE *Die, uint16_t Attribute, uint16_t Form,
222 const MCSymbol *Hi, const MCSymbol *Lo) {
223 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
224 Die->addValue(Attribute, Form, Value);
227 /// addDIEEntry - Add a DIE attribute data and value.
229 void CompileUnit::addDIEEntry(DIE *Die, uint16_t Attribute, uint16_t Form,
231 Die->addValue(Attribute, Form, createDIEEntry(Entry));
234 /// addBlock - Add block data.
236 void CompileUnit::addBlock(DIE *Die, uint16_t Attribute, uint16_t Form,
238 Block->ComputeSize(Asm);
239 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
240 Die->addValue(Attribute, Block->BestForm(), Block);
243 /// addSourceLine - Add location information to specified debug information
245 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
250 unsigned Line = V.getLineNumber();
253 unsigned FileID = DD->getOrCreateSourceID(V.getContext().getFilename(),
254 V.getContext().getDirectory(),
256 assert(FileID && "Invalid file id");
257 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
258 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
261 /// addSourceLine - Add location information to specified debug information
263 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
264 // Verify global variable.
265 if (!G.isGlobalVariable())
268 unsigned Line = G.getLineNumber();
271 unsigned FileID = DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(),
273 assert(FileID && "Invalid file id");
274 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
275 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
278 /// addSourceLine - Add location information to specified debug information
280 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
281 // Verify subprogram.
282 if (!SP.isSubprogram())
285 // If the line number is 0, don't add it.
286 unsigned Line = SP.getLineNumber();
290 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(),
291 SP.getDirectory(), getUniqueID());
292 assert(FileID && "Invalid file id");
293 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
294 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
297 /// addSourceLine - Add location information to specified debug information
299 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
304 unsigned Line = Ty.getLineNumber();
307 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(),
308 Ty.getDirectory(), getUniqueID());
309 assert(FileID && "Invalid file id");
310 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
311 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
314 /// addSourceLine - Add location information to specified debug information
316 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
318 if (!Ty.isObjCProperty())
321 unsigned Line = Ty.getLineNumber();
324 DIFile File = Ty.getFile();
325 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
326 File.getDirectory(), getUniqueID());
327 assert(FileID && "Invalid file id");
328 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
329 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
332 /// addSourceLine - Add location information to specified debug information
334 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
339 unsigned Line = NS.getLineNumber();
342 StringRef FN = NS.getFilename();
344 unsigned FileID = DD->getOrCreateSourceID(FN, NS.getDirectory(),
346 assert(FileID && "Invalid file id");
347 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
348 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
351 /// addVariableAddress - Add DW_AT_location attribute for a
352 /// DbgVariable based on provided MachineLocation.
353 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
354 MachineLocation Location) {
355 if (DV.variableHasComplexAddress())
356 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
357 else if (DV.isBlockByrefVariable())
358 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
360 addAddress(Die, dwarf::DW_AT_location, Location,
361 DV.getVariable().isIndirect());
364 /// addRegisterOp - Add register operand.
365 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
366 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
367 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
369 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
371 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
372 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
376 /// addRegisterOffset - Add register offset.
377 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
379 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
380 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
381 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
382 if (Reg == TRI->getFrameRegister(*Asm->MF))
383 // If variable offset is based in frame register then use fbreg.
384 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
386 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
388 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
389 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
391 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
394 /// addAddress - Add an address attribute to a die based on the location
396 void CompileUnit::addAddress(DIE *Die, uint16_t Attribute,
397 const MachineLocation &Location, bool Indirect) {
398 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
400 if (Location.isReg() && !Indirect)
401 addRegisterOp(Block, Location.getReg());
403 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
404 if (Indirect && !Location.isReg()) {
405 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
409 // Now attach the location information to the DIE.
410 addBlock(Die, Attribute, 0, Block);
413 /// addComplexAddress - Start with the address based on the location provided,
414 /// and generate the DWARF information necessary to find the actual variable
415 /// given the extra address information encoded in the DIVariable, starting from
416 /// the starting location. Add the DWARF information to the die.
418 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
420 const MachineLocation &Location) {
421 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
422 unsigned N = DV.getNumAddrElements();
424 if (Location.isReg()) {
425 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
426 // If first address element is OpPlus then emit
427 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
428 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
431 addRegisterOp(Block, Location.getReg());
434 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
437 uint64_t Element = DV.getAddrElement(i);
438 if (Element == DIBuilder::OpPlus) {
439 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
440 addUInt(Block, 0, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
441 } else if (Element == DIBuilder::OpDeref) {
442 if (!Location.isReg())
443 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
444 } else llvm_unreachable("unknown DIBuilder Opcode");
447 // Now attach the location information to the DIE.
448 addBlock(Die, Attribute, 0, Block);
451 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
452 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
453 gives the variable VarName either the struct, or a pointer to the struct, as
454 its type. This is necessary for various behind-the-scenes things the
455 compiler needs to do with by-reference variables in Blocks.
457 However, as far as the original *programmer* is concerned, the variable
458 should still have type 'SomeType', as originally declared.
460 The function getBlockByrefType dives into the __Block_byref_x_VarName
461 struct to find the original type of the variable, which is then assigned to
462 the variable's Debug Information Entry as its real type. So far, so good.
463 However now the debugger will expect the variable VarName to have the type
464 SomeType. So we need the location attribute for the variable to be an
465 expression that explains to the debugger how to navigate through the
466 pointers and struct to find the actual variable of type SomeType.
468 The following function does just that. We start by getting
469 the "normal" location for the variable. This will be the location
470 of either the struct __Block_byref_x_VarName or the pointer to the
471 struct __Block_byref_x_VarName.
473 The struct will look something like:
475 struct __Block_byref_x_VarName {
477 struct __Block_byref_x_VarName *forwarding;
478 ... <various other fields>
480 ... <maybe more fields>
483 If we are given the struct directly (as our starting point) we
484 need to tell the debugger to:
486 1). Add the offset of the forwarding field.
488 2). Follow that pointer to get the real __Block_byref_x_VarName
489 struct to use (the real one may have been copied onto the heap).
491 3). Add the offset for the field VarName, to find the actual variable.
493 If we started with a pointer to the struct, then we need to
494 dereference that pointer first, before the other steps.
495 Translating this into DWARF ops, we will need to append the following
496 to the current location description for the variable:
498 DW_OP_deref -- optional, if we start with a pointer
499 DW_OP_plus_uconst <forward_fld_offset>
501 DW_OP_plus_uconst <varName_fld_offset>
503 That is what this function does. */
505 /// addBlockByrefAddress - Start with the address based on the location
506 /// provided, and generate the DWARF information necessary to find the
507 /// actual Block variable (navigating the Block struct) based on the
508 /// starting location. Add the DWARF information to the die. For
509 /// more information, read large comment just above here.
511 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
513 const MachineLocation &Location) {
514 DIType Ty = DV.getType();
516 uint16_t Tag = Ty.getTag();
517 bool isPointer = false;
519 StringRef varName = DV.getName();
521 if (Tag == dwarf::DW_TAG_pointer_type) {
522 DIDerivedType DTy = DIDerivedType(Ty);
523 TmpTy = DTy.getTypeDerivedFrom();
527 DICompositeType blockStruct = DICompositeType(TmpTy);
529 // Find the __forwarding field and the variable field in the __Block_byref
531 DIArray Fields = blockStruct.getTypeArray();
532 DIDescriptor varField = DIDescriptor();
533 DIDescriptor forwardingField = DIDescriptor();
535 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
536 DIDescriptor Element = Fields.getElement(i);
537 DIDerivedType DT = DIDerivedType(Element);
538 StringRef fieldName = DT.getName();
539 if (fieldName == "__forwarding")
540 forwardingField = Element;
541 else if (fieldName == varName)
545 // Get the offsets for the forwarding field and the variable field.
546 unsigned forwardingFieldOffset =
547 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
548 unsigned varFieldOffset =
549 DIDerivedType(varField).getOffsetInBits() >> 3;
551 // Decode the original location, and use that as the start of the byref
552 // variable's location.
553 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
555 if (Location.isReg())
556 addRegisterOp(Block, Location.getReg());
558 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
560 // If we started with a pointer to the __Block_byref... struct, then
561 // the first thing we need to do is dereference the pointer (DW_OP_deref).
563 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
565 // Next add the offset for the '__forwarding' field:
566 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
567 // adding the offset if it's 0.
568 if (forwardingFieldOffset > 0) {
569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
570 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
573 // Now dereference the __forwarding field to get to the real __Block_byref
574 // struct: DW_OP_deref.
575 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
577 // Now that we've got the real __Block_byref... struct, add the offset
578 // for the variable's field to get to the location of the actual variable:
579 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
580 if (varFieldOffset > 0) {
581 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
582 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
585 // Now attach the location information to the DIE.
586 addBlock(Die, Attribute, 0, Block);
589 /// isTypeSigned - Return true if the type is signed.
590 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
591 if (Ty.isDerivedType())
592 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
593 if (Ty.isBasicType())
594 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
595 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
596 *SizeInBits = Ty.getSizeInBits();
602 /// addConstantValue - Add constant value entry in variable DIE.
603 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
605 // FIXME: This is a bit conservative/simple - it emits negative values at
606 // their maximum bit width which is a bit unfortunate (& doesn't prefer
607 // udata/sdata over dataN as suggested by the DWARF spec)
608 assert(MO.isImm() && "Invalid machine operand!");
610 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
613 // If we're a signed constant definitely use sdata.
614 if (SignedConstant) {
615 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
619 // Else use data for now unless it's larger than we can deal with.
620 switch (SizeInBits) {
622 Form = dwarf::DW_FORM_data1;
625 Form = dwarf::DW_FORM_data2;
628 Form = dwarf::DW_FORM_data4;
631 Form = dwarf::DW_FORM_data8;
634 Form = dwarf::DW_FORM_udata;
635 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
638 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
641 /// addConstantFPValue - Add constant value entry in variable DIE.
642 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
643 assert (MO.isFPImm() && "Invalid machine operand!");
644 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
645 APFloat FPImm = MO.getFPImm()->getValueAPF();
647 // Get the raw data form of the floating point.
648 const APInt FltVal = FPImm.bitcastToAPInt();
649 const char *FltPtr = (const char*)FltVal.getRawData();
651 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
652 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
653 int Incr = (LittleEndian ? 1 : -1);
654 int Start = (LittleEndian ? 0 : NumBytes - 1);
655 int Stop = (LittleEndian ? NumBytes : -1);
657 // Output the constant to DWARF one byte at a time.
658 for (; Start != Stop; Start += Incr)
659 addUInt(Block, 0, dwarf::DW_FORM_data1,
660 (unsigned char)0xFF & FltPtr[Start]);
662 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
665 /// addConstantFPValue - Add constant value entry in variable DIE.
666 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
667 // Pass this down to addConstantValue as an unsigned bag of bits.
668 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
671 /// addConstantValue - Add constant value entry in variable DIE.
672 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
674 addConstantValue(Die, CI->getValue(), Unsigned);
677 // addConstantValue - Add constant value entry in variable DIE.
678 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
679 unsigned CIBitWidth = Val.getBitWidth();
680 if (CIBitWidth <= 64) {
681 // If we're a signed constant definitely use sdata.
683 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
688 // Else use data for now unless it's larger than we can deal with.
690 switch (CIBitWidth) {
692 Form = dwarf::DW_FORM_data1;
695 Form = dwarf::DW_FORM_data2;
698 Form = dwarf::DW_FORM_data4;
701 Form = dwarf::DW_FORM_data8;
704 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
708 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
712 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
714 // Get the raw data form of the large APInt.
715 const uint64_t *Ptr64 = Val.getRawData();
717 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
718 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
720 // Output the constant to DWARF one byte at a time.
721 for (int i = 0; i < NumBytes; i++) {
724 c = Ptr64[i / 8] >> (8 * (i & 7));
726 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
727 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
730 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
733 /// addTemplateParams - Add template parameters into buffer.
734 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
735 // Add template parameters.
736 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
737 DIDescriptor Element = TParams.getElement(i);
738 if (Element.isTemplateTypeParameter())
739 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
740 DITemplateTypeParameter(Element)));
741 else if (Element.isTemplateValueParameter())
742 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
743 DITemplateValueParameter(Element)));
747 /// getOrCreateContextDIE - Get context owner's DIE.
748 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) {
749 if (Context.isType())
750 return getOrCreateTypeDIE(DIType(Context));
751 else if (Context.isNameSpace())
752 return getOrCreateNameSpace(DINameSpace(Context));
753 else if (Context.isSubprogram())
754 return getOrCreateSubprogramDIE(DISubprogram(Context));
756 return getDIE(Context);
759 /// addToContextOwner - Add Die into the list of its context owner's children.
760 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
761 if (DIE *ContextDIE = getOrCreateContextDIE(Context))
762 ContextDIE->addChild(Die);
767 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
769 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
773 DIE *TyDIE = getDIE(Ty);
778 TyDIE = new DIE(dwarf::DW_TAG_base_type);
779 insertDIE(Ty, TyDIE);
780 if (Ty.isBasicType())
781 constructTypeDIE(*TyDIE, DIBasicType(Ty));
782 else if (Ty.isCompositeType())
783 constructTypeDIE(*TyDIE, DICompositeType(Ty));
785 assert(Ty.isDerivedType() && "Unknown kind of DIType");
786 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
788 // If this is a named finished type then include it in the list of types
789 // for the accelerator tables.
790 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
791 bool IsImplementation = 0;
792 if (Ty.isCompositeType()) {
793 DICompositeType CT(Ty);
794 // A runtime language of 0 actually means C/C++ and that any
795 // non-negative value is some version of Objective-C/C++.
796 IsImplementation = (CT.getRunTimeLang() == 0) ||
797 CT.isObjcClassComplete();
799 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
800 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
803 addToContextOwner(TyDIE, DD->resolve(Ty.getContext()));
807 /// addType - Add a new type attribute to the specified entity.
808 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
809 assert(Ty && "Trying to add a type that doesn't exist?");
811 // Check for pre-existence.
812 DIEEntry *Entry = getDIEEntry(Ty);
813 // If it exists then use the existing value.
815 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
820 DIE *Buffer = getOrCreateTypeDIE(Ty);
823 Entry = createDIEEntry(Buffer);
824 insertDIEEntry(Ty, Entry);
825 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
827 // If this is a complete composite type then include it in the
828 // list of global types.
832 /// addGlobalType - Add a new global type to the compile unit.
834 void CompileUnit::addGlobalType(DIType Ty) {
835 DIDescriptor Context = DD->resolve(Ty.getContext());
836 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
837 && (!Context || Context.isCompileUnit() || Context.isFile()
838 || Context.isNameSpace()))
839 if (DIEEntry *Entry = getDIEEntry(Ty))
840 GlobalTypes[Ty.getName()] = Entry->getEntry();
843 /// addPubTypes - Add type for pubtypes section.
844 void CompileUnit::addPubTypes(DISubprogram SP) {
845 DICompositeType SPTy = SP.getType();
846 uint16_t SPTag = SPTy.getTag();
847 if (SPTag != dwarf::DW_TAG_subroutine_type)
850 DIArray Args = SPTy.getTypeArray();
851 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
852 DIType ATy(Args.getElement(i));
859 /// constructTypeDIE - Construct basic type die from DIBasicType.
860 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
861 // Get core information.
862 StringRef Name = BTy.getName();
863 // Add name if not anonymous or intermediate type.
865 addString(&Buffer, dwarf::DW_AT_name, Name);
867 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
868 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
869 // An unspecified type only has a name attribute.
873 Buffer.setTag(dwarf::DW_TAG_base_type);
874 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
877 uint64_t Size = BTy.getSizeInBits() >> 3;
878 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
881 /// constructTypeDIE - Construct derived type die from DIDerivedType.
882 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
883 // Get core information.
884 StringRef Name = DTy.getName();
885 uint64_t Size = DTy.getSizeInBits() >> 3;
886 uint16_t Tag = DTy.getTag();
888 // FIXME - Workaround for templates.
889 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
893 // Map to main type, void will not have a type.
894 DIType FromTy = DTy.getTypeDerivedFrom();
896 addType(&Buffer, FromTy);
898 // Add name if not anonymous or intermediate type.
900 addString(&Buffer, dwarf::DW_AT_name, Name);
902 // Add size if non-zero (derived types might be zero-sized.)
903 if (Size && Tag != dwarf::DW_TAG_pointer_type)
904 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
906 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
907 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
908 getOrCreateTypeDIE(DD->resolve(DTy.getClassType())));
909 // Add source line info if available and TyDesc is not a forward declaration.
910 if (!DTy.isForwardDecl())
911 addSourceLine(&Buffer, DTy);
914 /// Return true if the type is appropriately scoped to be contained inside
915 /// its own type unit.
916 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
917 DIScope Parent = DD->resolve(Ty.getContext());
919 // Don't generate a hash for anything scoped inside a function.
920 if (Parent.isSubprogram())
922 Parent = DD->resolve(Parent.getContext());
927 /// Return true if the type should be split out into a type unit.
928 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
929 uint16_t Tag = CTy.getTag();
932 case dwarf::DW_TAG_structure_type:
933 case dwarf::DW_TAG_union_type:
934 case dwarf::DW_TAG_enumeration_type:
935 case dwarf::DW_TAG_class_type:
936 // If this is a class, structure, union, or enumeration type
937 // that is not a declaration, is a type definition, and not scoped
938 // inside a function then separate this out as a type unit.
939 if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy, DD))
947 /// constructTypeDIE - Construct type DIE from DICompositeType.
948 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
949 // Get core information.
950 StringRef Name = CTy.getName();
952 uint64_t Size = CTy.getSizeInBits() >> 3;
953 uint16_t Tag = CTy.getTag();
957 case dwarf::DW_TAG_array_type:
958 constructArrayTypeDIE(Buffer, &CTy);
960 case dwarf::DW_TAG_enumeration_type: {
961 DIArray Elements = CTy.getTypeArray();
963 // Add enumerators to enumeration type.
964 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
966 DIDescriptor Enum(Elements.getElement(i));
967 if (Enum.isEnumerator()) {
968 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
969 Buffer.addChild(ElemDie);
972 DIType DTy = CTy.getTypeDerivedFrom();
974 addType(&Buffer, DTy);
975 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
979 case dwarf::DW_TAG_subroutine_type: {
980 // Add return type. A void return won't have a type.
981 DIArray Elements = CTy.getTypeArray();
982 DIDescriptor RTy = Elements.getElement(0);
984 addType(&Buffer, DIType(RTy));
986 bool isPrototyped = true;
988 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
989 DIDescriptor Ty = Elements.getElement(i);
990 if (Ty.isUnspecifiedParameter()) {
991 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
992 Buffer.addChild(Arg);
993 isPrototyped = false;
995 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
996 addType(Arg, DIType(Ty));
997 if (DIType(Ty).isArtificial())
998 addFlag(Arg, dwarf::DW_AT_artificial);
999 Buffer.addChild(Arg);
1002 // Add prototype flag if we're dealing with a C language and the
1003 // function has been prototyped.
1004 uint16_t Language = DICompileUnit(Node).getLanguage();
1006 (Language == dwarf::DW_LANG_C89 ||
1007 Language == dwarf::DW_LANG_C99 ||
1008 Language == dwarf::DW_LANG_ObjC))
1009 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1012 case dwarf::DW_TAG_structure_type:
1013 case dwarf::DW_TAG_union_type:
1014 case dwarf::DW_TAG_class_type: {
1015 // Add elements to structure type.
1016 DIArray Elements = CTy.getTypeArray();
1017 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1018 DIDescriptor Element = Elements.getElement(i);
1019 DIE *ElemDie = NULL;
1020 if (Element.isSubprogram()) {
1021 DISubprogram SP(Element);
1022 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1023 if (SP.isProtected())
1024 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1025 dwarf::DW_ACCESS_protected);
1026 else if (SP.isPrivate())
1027 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1028 dwarf::DW_ACCESS_private);
1030 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1031 dwarf::DW_ACCESS_public);
1032 if (SP.isExplicit())
1033 addFlag(ElemDie, dwarf::DW_AT_explicit);
1034 } else if (Element.isDerivedType()) {
1035 DIDerivedType DDTy(Element);
1036 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1037 ElemDie = new DIE(dwarf::DW_TAG_friend);
1038 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1039 } else if (DDTy.isStaticMember())
1040 ElemDie = createStaticMemberDIE(DDTy);
1042 ElemDie = createMemberDIE(DDTy);
1043 } else if (Element.isObjCProperty()) {
1044 DIObjCProperty Property(Element);
1045 ElemDie = new DIE(Property.getTag());
1046 StringRef PropertyName = Property.getObjCPropertyName();
1047 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1048 addType(ElemDie, Property.getType());
1049 addSourceLine(ElemDie, Property);
1050 StringRef GetterName = Property.getObjCPropertyGetterName();
1051 if (!GetterName.empty())
1052 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1053 StringRef SetterName = Property.getObjCPropertySetterName();
1054 if (!SetterName.empty())
1055 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1056 unsigned PropertyAttributes = 0;
1057 if (Property.isReadOnlyObjCProperty())
1058 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1059 if (Property.isReadWriteObjCProperty())
1060 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1061 if (Property.isAssignObjCProperty())
1062 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1063 if (Property.isRetainObjCProperty())
1064 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1065 if (Property.isCopyObjCProperty())
1066 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1067 if (Property.isNonAtomicObjCProperty())
1068 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1069 if (PropertyAttributes)
1070 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1071 PropertyAttributes);
1073 DIEEntry *Entry = getDIEEntry(Element);
1075 Entry = createDIEEntry(ElemDie);
1076 insertDIEEntry(Element, Entry);
1080 Buffer.addChild(ElemDie);
1083 if (CTy.isAppleBlockExtension())
1084 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1086 DICompositeType ContainingType(DD->resolve(CTy.getContainingType()));
1087 if (DIDescriptor(ContainingType).isCompositeType())
1088 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1089 getOrCreateTypeDIE(DIType(ContainingType)));
1091 addToContextOwner(&Buffer, DD->resolve(CTy.getContext()));
1093 if (CTy.isObjcClassComplete())
1094 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1096 // Add template parameters to a class, structure or union types.
1097 // FIXME: The support isn't in the metadata for this yet.
1098 if (Tag == dwarf::DW_TAG_class_type ||
1099 Tag == dwarf::DW_TAG_structure_type ||
1100 Tag == dwarf::DW_TAG_union_type)
1101 addTemplateParams(Buffer, CTy.getTemplateParams());
1109 // Add name if not anonymous or intermediate type.
1111 addString(&Buffer, dwarf::DW_AT_name, Name);
1113 if (Tag == dwarf::DW_TAG_enumeration_type ||
1114 Tag == dwarf::DW_TAG_class_type ||
1115 Tag == dwarf::DW_TAG_structure_type ||
1116 Tag == dwarf::DW_TAG_union_type) {
1117 // Add size if non-zero (derived types might be zero-sized.)
1118 // TODO: Do we care about size for enum forward declarations?
1120 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1121 else if (!CTy.isForwardDecl())
1122 // Add zero size if it is not a forward declaration.
1123 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1125 // If we're a forward decl, say so.
1126 if (CTy.isForwardDecl())
1127 addFlag(&Buffer, dwarf::DW_AT_declaration);
1129 // Add source line info if available.
1130 if (!CTy.isForwardDecl())
1131 addSourceLine(&Buffer, CTy);
1133 // No harm in adding the runtime language to the declaration.
1134 unsigned RLang = CTy.getRunTimeLang();
1136 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1137 dwarf::DW_FORM_data1, RLang);
1139 // If this is a type applicable to a type unit it then add it to the
1140 // list of types we'll compute a hash for later.
1141 if (shouldCreateTypeUnit(CTy, DD))
1142 DD->addTypeUnitType(&Buffer);
1145 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1146 /// for the given DITemplateTypeParameter.
1148 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1149 DIE *ParamDIE = getDIE(TP);
1153 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1154 // Add the type if it exists, it could be void and therefore no type.
1156 addType(ParamDIE, TP.getType());
1157 if (!TP.getName().empty())
1158 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1162 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1163 /// for the given DITemplateValueParameter.
1165 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1166 DIE *ParamDIE = getDIE(VP);
1170 ParamDIE = new DIE(VP.getTag());
1172 // Add the type if there is one, template template and template parameter
1173 // packs will not have a type.
1175 addType(ParamDIE, VP.getType());
1176 if (!VP.getName().empty())
1177 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1178 if (Value *Val = VP.getValue()) {
1179 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1180 addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1181 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1182 // For declaration non-type template parameters (such as global values and
1184 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1185 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1186 // Emit DW_OP_stack_value to use the address as the immediate value of the
1187 // parameter, rather than a pointer to it.
1188 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1189 addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1190 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1191 assert(isa<MDString>(Val));
1192 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1193 cast<MDString>(Val)->getString());
1194 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1195 assert(isa<MDNode>(Val));
1196 DIArray A(cast<MDNode>(Val));
1197 addTemplateParams(*ParamDIE, A);
1204 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1205 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1206 DIE *NDie = getDIE(NS);
1209 NDie = new DIE(dwarf::DW_TAG_namespace);
1210 insertDIE(NS, NDie);
1211 if (!NS.getName().empty()) {
1212 addString(NDie, dwarf::DW_AT_name, NS.getName());
1213 addAccelNamespace(NS.getName(), NDie);
1215 addAccelNamespace("(anonymous namespace)", NDie);
1216 addSourceLine(NDie, NS);
1217 addToContextOwner(NDie, NS.getContext());
1221 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1222 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1223 DIE *SPDie = getDIE(SP);
1227 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1229 // DW_TAG_inlined_subroutine may refer to this DIE.
1230 insertDIE(SP, SPDie);
1232 DISubprogram SPDecl = SP.getFunctionDeclaration();
1233 DIE *DeclDie = NULL;
1234 if (SPDecl.isSubprogram()) {
1235 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1238 // Add to context owner.
1239 addToContextOwner(SPDie, SP.getContext());
1241 // Add function template parameters.
1242 addTemplateParams(*SPDie, SP.getTemplateParams());
1244 // If this DIE is going to refer declaration info using AT_specification
1245 // then there is no need to add other attributes.
1247 // Refer function declaration directly.
1248 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1254 // Add the linkage name if we have one.
1255 StringRef LinkageName = SP.getLinkageName();
1256 if (!LinkageName.empty())
1257 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1258 GlobalValue::getRealLinkageName(LinkageName));
1260 // Constructors and operators for anonymous aggregates do not have names.
1261 if (!SP.getName().empty())
1262 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1264 addSourceLine(SPDie, SP);
1266 // Add the prototype if we have a prototype and we have a C like
1268 uint16_t Language = DICompileUnit(Node).getLanguage();
1269 if (SP.isPrototyped() &&
1270 (Language == dwarf::DW_LANG_C89 ||
1271 Language == dwarf::DW_LANG_C99 ||
1272 Language == dwarf::DW_LANG_ObjC))
1273 addFlag(SPDie, dwarf::DW_AT_prototyped);
1275 // Add Return Type. A void return type will not have a type.
1276 DICompositeType SPTy = SP.getType();
1277 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1278 "the type of a subprogram should be a subroutine");
1280 DIArray Args = SPTy.getTypeArray();
1281 if (Args.getElement(0))
1282 addType(SPDie, DIType(Args.getElement(0)));
1284 unsigned VK = SP.getVirtuality();
1286 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1287 DIEBlock *Block = getDIEBlock();
1288 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1289 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1290 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1291 ContainingTypeMap.insert(std::make_pair(SPDie,
1292 DD->resolve(SP.getContainingType())));
1295 if (!SP.isDefinition()) {
1296 addFlag(SPDie, dwarf::DW_AT_declaration);
1298 // Add arguments. Do not add arguments for subprogram definition. They will
1299 // be handled while processing variables.
1300 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1301 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1302 DIType ATy = DIType(Args.getElement(i));
1304 if (ATy.isArtificial())
1305 addFlag(Arg, dwarf::DW_AT_artificial);
1306 SPDie->addChild(Arg);
1310 if (SP.isArtificial())
1311 addFlag(SPDie, dwarf::DW_AT_artificial);
1313 if (!SP.isLocalToUnit())
1314 addFlag(SPDie, dwarf::DW_AT_external);
1316 if (SP.isOptimized())
1317 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1319 if (unsigned isa = Asm->getISAEncoding()) {
1320 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1326 // Return const expression if value is a GEP to access merged global
1328 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1329 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1330 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1331 if (!CE || CE->getNumOperands() != 3 ||
1332 CE->getOpcode() != Instruction::GetElementPtr)
1335 // First operand points to a global struct.
1336 Value *Ptr = CE->getOperand(0);
1337 if (!isa<GlobalValue>(Ptr) ||
1338 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1341 // Second operand is zero.
1342 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1343 if (!CI || !CI->isZero())
1346 // Third operand is offset.
1347 if (!isa<ConstantInt>(CE->getOperand(2)))
1353 /// createGlobalVariableDIE - create global variable DIE.
1354 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1355 // Check for pre-existence.
1359 DIGlobalVariable GV(N);
1360 if (!GV.isGlobalVariable())
1363 DIDescriptor GVContext = GV.getContext();
1364 DIType GTy = GV.getType();
1366 // If this is a static data member definition, some attributes belong
1367 // to the declaration DIE.
1368 DIE *VariableDIE = NULL;
1369 bool IsStaticMember = false;
1370 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1371 if (SDMDecl.Verify()) {
1372 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1373 // We need the declaration DIE that is in the static member's class.
1374 // But that class might not exist in the DWARF yet.
1375 // Creating the class will create the static member decl DIE.
1376 getOrCreateContextDIE(DD->resolve(SDMDecl.getContext()));
1377 VariableDIE = getDIE(SDMDecl);
1378 assert(VariableDIE && "Static member decl has no context?");
1379 IsStaticMember = true;
1382 // If this is not a static data member definition, create the variable
1383 // DIE and add the initial set of attributes to it.
1385 VariableDIE = new DIE(GV.getTag());
1387 insertDIE(N, VariableDIE);
1389 // Add name and type.
1390 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1391 addType(VariableDIE, GTy);
1393 // Add scoping info.
1394 if (!GV.isLocalToUnit()) {
1395 addFlag(VariableDIE, dwarf::DW_AT_external);
1396 addGlobalName(GV.getName(), VariableDIE);
1399 // Add line number info.
1400 addSourceLine(VariableDIE, GV);
1401 // Add to context owner.
1402 addToContextOwner(VariableDIE, GVContext);
1406 bool addToAccelTable = false;
1407 DIE *VariableSpecDIE = NULL;
1408 bool isGlobalVariable = GV.getGlobal() != NULL;
1409 if (isGlobalVariable) {
1410 addToAccelTable = true;
1411 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1412 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1413 if (GV.getGlobal()->isThreadLocal()) {
1414 // FIXME: Make this work with -gsplit-dwarf.
1415 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1416 assert((PointerSize == 4 || PointerSize == 8) &&
1417 "Add support for other sizes if necessary");
1418 const MCExpr *Expr =
1419 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1420 // Based on GCC's support for TLS:
1421 if (!DD->useSplitDwarf()) {
1422 // 1) Start with a constNu of the appropriate pointer size
1423 addUInt(Block, 0, dwarf::DW_FORM_data1,
1424 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1425 // 2) containing the (relocated) address of the TLS variable
1426 addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1429 addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1431 // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1432 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1434 addOpAddress(Block, Sym);
1435 // Do not create specification DIE if context is either compile unit
1437 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1438 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1439 // Create specification DIE.
1440 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1441 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1442 dwarf::DW_FORM_ref4, VariableDIE);
1443 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1444 // A static member's declaration is already flagged as such.
1445 if (!SDMDecl.Verify())
1446 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1447 addDie(VariableSpecDIE);
1449 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1451 // Add the linkage name.
1452 StringRef LinkageName = GV.getLinkageName();
1453 if (!LinkageName.empty())
1454 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1455 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1457 addString(IsStaticMember && VariableSpecDIE ?
1458 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1459 GlobalValue::getRealLinkageName(LinkageName));
1460 } else if (const ConstantInt *CI =
1461 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1462 // AT_const_value was added when the static member was created. To avoid
1463 // emitting AT_const_value multiple times, we only add AT_const_value when
1464 // it is not a static member.
1465 if (!IsStaticMember)
1466 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1467 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1468 addToAccelTable = true;
1469 // GV is a merged global.
1470 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1471 Value *Ptr = CE->getOperand(0);
1472 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1473 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1474 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1475 addUInt(Block, 0, dwarf::DW_FORM_udata,
1476 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1477 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1478 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1481 if (addToAccelTable) {
1482 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1483 addAccelName(GV.getName(), AddrDIE);
1485 // If the linkage name is different than the name, go ahead and output
1486 // that as well into the name table.
1487 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1488 addAccelName(GV.getLinkageName(), AddrDIE);
1492 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1493 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1495 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1496 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1498 // The LowerBound value defines the lower bounds which is typically zero for
1499 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1500 // Count == -1 then the array is unbounded and we do not emit
1501 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1502 // Count == 0, then the array has zero elements in which case we do not emit
1504 int64_t LowerBound = SR.getLo();
1505 int64_t DefaultLowerBound = getDefaultLowerBound();
1506 int64_t Count = SR.getCount();
1508 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1509 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1511 if (Count != -1 && Count != 0)
1512 // FIXME: An unbounded array should reference the expression that defines
1514 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1516 Buffer.addChild(DW_Subrange);
1519 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1520 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1521 DICompositeType *CTy) {
1522 Buffer.setTag(dwarf::DW_TAG_array_type);
1523 if (CTy->isVector())
1524 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1526 // Emit the element type.
1527 addType(&Buffer, CTy->getTypeDerivedFrom());
1529 // Get an anonymous type for index type.
1530 // FIXME: This type should be passed down from the front end
1531 // as different languages may have different sizes for indexes.
1532 DIE *IdxTy = getIndexTyDie();
1534 // Construct an anonymous type for index type.
1535 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1536 addString(IdxTy, dwarf::DW_AT_name, "int");
1537 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1538 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1539 dwarf::DW_ATE_signed);
1541 setIndexTyDie(IdxTy);
1544 // Add subranges to array type.
1545 DIArray Elements = CTy->getTypeArray();
1546 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1547 DIDescriptor Element = Elements.getElement(i);
1548 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1549 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1553 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1554 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1555 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1556 StringRef Name = ETy.getName();
1557 addString(Enumerator, dwarf::DW_AT_name, Name);
1558 int64_t Value = ETy.getEnumValue();
1559 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1563 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1565 void CompileUnit::constructContainingTypeDIEs() {
1566 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1567 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1568 DIE *SPDie = CI->first;
1569 const MDNode *N = CI->second;
1571 DIE *NDie = getDIE(N);
1572 if (!NDie) continue;
1573 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1577 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1578 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1579 bool isScopeAbstract) {
1580 StringRef Name = DV->getName();
1582 // Translate tag to proper Dwarf tag.
1583 uint16_t Tag = DV->getTag();
1585 // Define variable debug information entry.
1586 DIE *VariableDie = new DIE(Tag);
1587 DbgVariable *AbsVar = DV->getAbstractVariable();
1588 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1590 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1591 dwarf::DW_FORM_ref4, AbsDIE);
1594 addString(VariableDie, dwarf::DW_AT_name, Name);
1595 addSourceLine(VariableDie, DV->getVariable());
1596 addType(VariableDie, DV->getType());
1599 if (DV->isArtificial())
1600 addFlag(VariableDie, dwarf::DW_AT_artificial);
1602 if (isScopeAbstract) {
1603 DV->setDIE(VariableDie);
1607 // Add variable address.
1609 unsigned Offset = DV->getDotDebugLocOffset();
1610 if (Offset != ~0U) {
1611 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1612 Asm->GetTempSymbol("debug_loc", Offset));
1613 DV->setDIE(VariableDie);
1617 // Check if variable is described by a DBG_VALUE instruction.
1618 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1619 assert(DVInsn->getNumOperands() == 3);
1620 if (DVInsn->getOperand(0).isReg()) {
1621 const MachineOperand RegOp = DVInsn->getOperand(0);
1622 // If the second operand is an immediate, this is an indirect value.
1623 if (DVInsn->getOperand(1).isImm()) {
1624 MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1625 addVariableAddress(*DV, VariableDie, Location);
1626 } else if (RegOp.getReg())
1627 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1628 } else if (DVInsn->getOperand(0).isImm())
1629 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1630 else if (DVInsn->getOperand(0).isFPImm())
1631 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1632 else if (DVInsn->getOperand(0).isCImm())
1633 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1634 DV->getType().isUnsignedDIType());
1636 DV->setDIE(VariableDie);
1639 // .. else use frame index.
1640 int FI = DV->getFrameIndex();
1642 unsigned FrameReg = 0;
1643 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1645 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1646 MachineLocation Location(FrameReg, Offset);
1647 addVariableAddress(*DV, VariableDie, Location);
1651 DV->setDIE(VariableDie);
1655 /// createMemberDIE - Create new member DIE.
1656 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1657 DIE *MemberDie = new DIE(DT.getTag());
1658 StringRef Name = DT.getName();
1660 addString(MemberDie, dwarf::DW_AT_name, Name);
1662 addType(MemberDie, DT.getTypeDerivedFrom());
1664 addSourceLine(MemberDie, DT);
1666 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1667 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1669 uint64_t Size = DT.getSizeInBits();
1670 uint64_t FieldSize = DT.getOriginalTypeSize();
1672 if (Size != FieldSize) {
1674 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1675 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1677 uint64_t Offset = DT.getOffsetInBits();
1678 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1679 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1680 uint64_t FieldOffset = (HiMark - FieldSize);
1681 Offset -= FieldOffset;
1683 // Maybe we need to work from the other end.
1684 if (Asm->getDataLayout().isLittleEndian())
1685 Offset = FieldSize - (Offset + Size);
1686 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1688 // Here WD_AT_data_member_location points to the anonymous
1689 // field that includes this bit field.
1690 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1693 // This is not a bitfield.
1694 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1696 if (DT.getTag() == dwarf::DW_TAG_inheritance
1697 && DT.isVirtual()) {
1699 // For C++, virtual base classes are not at fixed offset. Use following
1700 // expression to extract appropriate offset from vtable.
1701 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1703 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1704 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1705 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1706 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1707 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1708 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1709 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1710 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1712 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1715 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1717 if (DT.isProtected())
1718 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1719 dwarf::DW_ACCESS_protected);
1720 else if (DT.isPrivate())
1721 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1722 dwarf::DW_ACCESS_private);
1723 // Otherwise C++ member and base classes are considered public.
1725 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1726 dwarf::DW_ACCESS_public);
1728 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1729 dwarf::DW_VIRTUALITY_virtual);
1731 // Objective-C properties.
1732 if (MDNode *PNode = DT.getObjCProperty())
1733 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1734 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1737 if (DT.isArtificial())
1738 addFlag(MemberDie, dwarf::DW_AT_artificial);
1743 /// createStaticMemberDIE - Create new DIE for C++ static member.
1744 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1748 DIE *StaticMemberDIE = new DIE(DT.getTag());
1749 DIType Ty = DT.getTypeDerivedFrom();
1751 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1752 addType(StaticMemberDIE, Ty);
1753 addSourceLine(StaticMemberDIE, DT);
1754 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1755 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1757 // FIXME: We could omit private if the parent is a class_type, and
1758 // public if the parent is something else.
1759 if (DT.isProtected())
1760 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1761 dwarf::DW_ACCESS_protected);
1762 else if (DT.isPrivate())
1763 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1764 dwarf::DW_ACCESS_private);
1766 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1767 dwarf::DW_ACCESS_public);
1769 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1770 addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1771 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1772 addConstantFPValue(StaticMemberDIE, CFP);
1774 insertDIE(DT, StaticMemberDIE);
1775 return StaticMemberDIE;