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/TargetRegisterInfo.h"
34 /// CompileUnit - Compile unit constructor.
35 CompileUnit::CompileUnit(unsigned UID, unsigned L, DIE *D, AsmPrinter *A,
36 DwarfDebug *DW, DwarfUnits *DWU)
37 : UniqueID(UID), Language(L), CUDie(D), Asm(A), DD(DW), DU(DWU),
38 IndexTyDie(0), DebugInfoOffset(0) {
39 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
42 /// ~CompileUnit - Destructor for compile unit.
43 CompileUnit::~CompileUnit() {
44 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
45 DIEBlocks[j]->~DIEBlock();
48 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
49 /// information entry.
50 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
51 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
55 /// getDefaultLowerBound - Return the default lower bound for an array. If the
56 /// DWARF version doesn't handle the language, return -1.
57 int64_t CompileUnit::getDefaultLowerBound() const {
62 case dwarf::DW_LANG_C89:
63 case dwarf::DW_LANG_C99:
64 case dwarf::DW_LANG_C:
65 case dwarf::DW_LANG_C_plus_plus:
66 case dwarf::DW_LANG_ObjC:
67 case dwarf::DW_LANG_ObjC_plus_plus:
70 case dwarf::DW_LANG_Fortran77:
71 case dwarf::DW_LANG_Fortran90:
72 case dwarf::DW_LANG_Fortran95:
75 // The languages below have valid values only if the DWARF version >= 4.
76 case dwarf::DW_LANG_Java:
77 case dwarf::DW_LANG_Python:
78 case dwarf::DW_LANG_UPC:
79 case dwarf::DW_LANG_D:
80 if (dwarf::DWARF_VERSION >= 4)
84 case dwarf::DW_LANG_Ada83:
85 case dwarf::DW_LANG_Ada95:
86 case dwarf::DW_LANG_Cobol74:
87 case dwarf::DW_LANG_Cobol85:
88 case dwarf::DW_LANG_Modula2:
89 case dwarf::DW_LANG_Pascal83:
90 case dwarf::DW_LANG_PLI:
91 if (dwarf::DWARF_VERSION >= 4)
99 /// addFlag - Add a flag that is true.
100 void CompileUnit::addFlag(DIE *Die, unsigned Attribute) {
101 if (!DD->useDarwinGDBCompat())
102 Die->addValue(Attribute, dwarf::DW_FORM_flag_present,
105 addUInt(Die, Attribute, dwarf::DW_FORM_flag, 1);
108 /// addUInt - Add an unsigned integer attribute data and value.
110 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
111 unsigned Form, uint64_t Integer) {
112 if (!Form) Form = DIEInteger::BestForm(false, Integer);
113 DIEValue *Value = Integer == 1 ?
114 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
115 Die->addValue(Attribute, Form, Value);
118 /// addSInt - Add an signed integer attribute data and value.
120 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
121 unsigned Form, int64_t Integer) {
122 if (!Form) Form = DIEInteger::BestForm(true, Integer);
123 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
124 Die->addValue(Attribute, Form, Value);
127 /// addString - Add a string attribute data and value. We always emit a
128 /// reference to the string pool instead of immediate strings so that DIEs have
129 /// more predictable sizes. In the case of split dwarf we emit an index
130 /// into another table which gets us the static offset into the string
132 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
133 if (!DD->useSplitDwarf()) {
134 MCSymbol *Symb = DU->getStringPoolEntry(String);
136 if (Asm->needsRelocationsForDwarfStringPool())
137 Value = new (DIEValueAllocator) DIELabel(Symb);
139 MCSymbol *StringPool = DU->getStringPoolSym();
140 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
142 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
144 unsigned idx = DU->getStringPoolIndex(String);
145 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
146 Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Value);
150 /// addLocalString - Add a string attribute data and value. This is guaranteed
151 /// to be in the local string pool instead of indirected.
152 void CompileUnit::addLocalString(DIE *Die, unsigned Attribute,
154 MCSymbol *Symb = DU->getStringPoolEntry(String);
156 if (Asm->needsRelocationsForDwarfStringPool())
157 Value = new (DIEValueAllocator) DIELabel(Symb);
159 MCSymbol *StringPool = DU->getStringPoolSym();
160 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
162 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
165 /// addLabel - Add a Dwarf label attribute data and value.
167 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
168 const MCSymbol *Label) {
169 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
170 Die->addValue(Attribute, Form, Value);
173 /// addLabelAddress - Add a dwarf label attribute data and value using
174 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
176 void CompileUnit::addLabelAddress(DIE *Die, unsigned Attribute,
178 if (!DD->useSplitDwarf()) {
180 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
181 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
183 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
184 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
187 unsigned idx = DU->getAddrPoolIndex(Label);
188 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
189 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
193 /// addOpAddress - Add a dwarf op address data and value using the
194 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
196 void CompileUnit::addOpAddress(DIE *Die, MCSymbol *Sym) {
198 if (!DD->useSplitDwarf()) {
199 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
200 addLabel(Die, 0, dwarf::DW_FORM_udata, Sym);
202 unsigned idx = DU->getAddrPoolIndex(Sym);
203 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
204 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
205 Die->addValue(0, dwarf::DW_FORM_GNU_addr_index, Value);
209 /// addDelta - Add a label delta attribute data and value.
211 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
212 const MCSymbol *Hi, const MCSymbol *Lo) {
213 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
214 Die->addValue(Attribute, Form, Value);
217 /// addDIEEntry - Add a DIE attribute data and value.
219 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
221 Die->addValue(Attribute, Form, createDIEEntry(Entry));
224 /// addBlock - Add block data.
226 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
228 Block->ComputeSize(Asm);
229 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
230 Die->addValue(Attribute, Block->BestForm(), Block);
233 /// addSourceLine - Add location information to specified debug information
235 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
240 unsigned Line = V.getLineNumber();
243 unsigned FileID = DD->getOrCreateSourceID(V.getContext().getFilename(),
244 V.getContext().getDirectory(),
246 assert(FileID && "Invalid file id");
247 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
248 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
251 /// addSourceLine - Add location information to specified debug information
253 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
254 // Verify global variable.
258 unsigned Line = G.getLineNumber();
261 unsigned FileID = DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(),
263 assert(FileID && "Invalid file id");
264 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
265 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
268 /// addSourceLine - Add location information to specified debug information
270 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
271 // Verify subprogram.
275 // If the line number is 0, don't add it.
276 unsigned Line = SP.getLineNumber();
280 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(),
281 SP.getDirectory(), getUniqueID());
282 assert(FileID && "Invalid file id");
283 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
284 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
287 /// addSourceLine - Add location information to specified debug information
289 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
294 unsigned Line = Ty.getLineNumber();
297 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(),
298 Ty.getDirectory(), getUniqueID());
299 assert(FileID && "Invalid file id");
300 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
301 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
304 /// addSourceLine - Add location information to specified debug information
306 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
311 unsigned Line = Ty.getLineNumber();
314 DIFile File = Ty.getFile();
315 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
316 File.getDirectory(), getUniqueID());
317 assert(FileID && "Invalid file id");
318 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
319 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
322 /// addSourceLine - Add location information to specified debug information
324 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
329 unsigned Line = NS.getLineNumber();
332 StringRef FN = NS.getFilename();
334 unsigned FileID = DD->getOrCreateSourceID(FN, NS.getDirectory(),
336 assert(FileID && "Invalid file id");
337 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
338 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
341 /// addVariableAddress - Add DW_AT_location attribute for a
342 /// DbgVariable based on provided MachineLocation.
343 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
344 MachineLocation Location) {
345 if (DV->variableHasComplexAddress())
346 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
347 else if (DV->isBlockByrefVariable())
348 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
350 addAddress(Die, dwarf::DW_AT_location, Location);
353 /// addRegisterOp - Add register operand.
354 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
355 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
356 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
358 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
360 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
361 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
365 /// addRegisterOffset - Add register offset.
366 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
368 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
369 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
370 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
371 if (Reg == TRI->getFrameRegister(*Asm->MF))
372 // If variable offset is based in frame register then use fbreg.
373 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
375 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
377 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
378 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
380 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
383 /// addAddress - Add an address attribute to a die based on the location
385 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
386 const MachineLocation &Location) {
387 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
389 if (Location.isReg())
390 addRegisterOp(Block, Location.getReg());
392 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
394 // Now attach the location information to the DIE.
395 addBlock(Die, Attribute, 0, Block);
398 /// addComplexAddress - Start with the address based on the location provided,
399 /// and generate the DWARF information necessary to find the actual variable
400 /// given the extra address information encoded in the DIVariable, starting from
401 /// the starting location. Add the DWARF information to the die.
403 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
405 const MachineLocation &Location) {
406 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
407 unsigned N = DV->getNumAddrElements();
409 if (Location.isReg()) {
410 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
411 // If first address element is OpPlus then emit
412 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
413 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
416 addRegisterOp(Block, Location.getReg());
419 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
422 uint64_t Element = DV->getAddrElement(i);
423 if (Element == DIBuilder::OpPlus) {
424 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
425 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
426 } else if (Element == DIBuilder::OpDeref) {
427 if (!Location.isReg())
428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
429 } else llvm_unreachable("unknown DIBuilder Opcode");
432 // Now attach the location information to the DIE.
433 addBlock(Die, Attribute, 0, Block);
436 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
437 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
438 gives the variable VarName either the struct, or a pointer to the struct, as
439 its type. This is necessary for various behind-the-scenes things the
440 compiler needs to do with by-reference variables in Blocks.
442 However, as far as the original *programmer* is concerned, the variable
443 should still have type 'SomeType', as originally declared.
445 The function getBlockByrefType dives into the __Block_byref_x_VarName
446 struct to find the original type of the variable, which is then assigned to
447 the variable's Debug Information Entry as its real type. So far, so good.
448 However now the debugger will expect the variable VarName to have the type
449 SomeType. So we need the location attribute for the variable to be an
450 expression that explains to the debugger how to navigate through the
451 pointers and struct to find the actual variable of type SomeType.
453 The following function does just that. We start by getting
454 the "normal" location for the variable. This will be the location
455 of either the struct __Block_byref_x_VarName or the pointer to the
456 struct __Block_byref_x_VarName.
458 The struct will look something like:
460 struct __Block_byref_x_VarName {
462 struct __Block_byref_x_VarName *forwarding;
463 ... <various other fields>
465 ... <maybe more fields>
468 If we are given the struct directly (as our starting point) we
469 need to tell the debugger to:
471 1). Add the offset of the forwarding field.
473 2). Follow that pointer to get the real __Block_byref_x_VarName
474 struct to use (the real one may have been copied onto the heap).
476 3). Add the offset for the field VarName, to find the actual variable.
478 If we started with a pointer to the struct, then we need to
479 dereference that pointer first, before the other steps.
480 Translating this into DWARF ops, we will need to append the following
481 to the current location description for the variable:
483 DW_OP_deref -- optional, if we start with a pointer
484 DW_OP_plus_uconst <forward_fld_offset>
486 DW_OP_plus_uconst <varName_fld_offset>
488 That is what this function does. */
490 /// addBlockByrefAddress - Start with the address based on the location
491 /// provided, and generate the DWARF information necessary to find the
492 /// actual Block variable (navigating the Block struct) based on the
493 /// starting location. Add the DWARF information to the die. For
494 /// more information, read large comment just above here.
496 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
498 const MachineLocation &Location) {
499 DIType Ty = DV->getType();
501 unsigned Tag = Ty.getTag();
502 bool isPointer = false;
504 StringRef varName = DV->getName();
506 if (Tag == dwarf::DW_TAG_pointer_type) {
507 DIDerivedType DTy = DIDerivedType(Ty);
508 TmpTy = DTy.getTypeDerivedFrom();
512 DICompositeType blockStruct = DICompositeType(TmpTy);
514 // Find the __forwarding field and the variable field in the __Block_byref
516 DIArray Fields = blockStruct.getTypeArray();
517 DIDescriptor varField = DIDescriptor();
518 DIDescriptor forwardingField = DIDescriptor();
520 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
521 DIDescriptor Element = Fields.getElement(i);
522 DIDerivedType DT = DIDerivedType(Element);
523 StringRef fieldName = DT.getName();
524 if (fieldName == "__forwarding")
525 forwardingField = Element;
526 else if (fieldName == varName)
530 // Get the offsets for the forwarding field and the variable field.
531 unsigned forwardingFieldOffset =
532 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
533 unsigned varFieldOffset =
534 DIDerivedType(varField).getOffsetInBits() >> 3;
536 // Decode the original location, and use that as the start of the byref
537 // variable's location.
538 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
540 if (Location.isReg())
541 addRegisterOp(Block, Location.getReg());
543 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
545 // If we started with a pointer to the __Block_byref... struct, then
546 // the first thing we need to do is dereference the pointer (DW_OP_deref).
548 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
550 // Next add the offset for the '__forwarding' field:
551 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
552 // adding the offset if it's 0.
553 if (forwardingFieldOffset > 0) {
554 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
555 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
558 // Now dereference the __forwarding field to get to the real __Block_byref
559 // struct: DW_OP_deref.
560 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
562 // Now that we've got the real __Block_byref... struct, add the offset
563 // for the variable's field to get to the location of the actual variable:
564 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
565 if (varFieldOffset > 0) {
566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
567 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
570 // Now attach the location information to the DIE.
571 addBlock(Die, Attribute, 0, Block);
574 /// isTypeSigned - Return true if the type is signed.
575 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
576 if (Ty.isDerivedType())
577 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
578 if (Ty.isBasicType())
579 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
580 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
581 *SizeInBits = Ty.getSizeInBits();
587 /// addConstantValue - Add constant value entry in variable DIE.
588 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
590 assert(MO.isImm() && "Invalid machine operand!");
591 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
593 bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
594 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
595 switch (SizeInBits) {
596 case 8: Form = dwarf::DW_FORM_data1; break;
597 case 16: Form = dwarf::DW_FORM_data2; break;
598 case 32: Form = dwarf::DW_FORM_data4; break;
599 case 64: Form = dwarf::DW_FORM_data8; break;
602 SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
603 : addUInt(Block, 0, Form, MO.getImm());
605 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
609 /// addConstantFPValue - Add constant value entry in variable DIE.
610 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
611 assert (MO.isFPImm() && "Invalid machine operand!");
612 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
613 APFloat FPImm = MO.getFPImm()->getValueAPF();
615 // Get the raw data form of the floating point.
616 const APInt FltVal = FPImm.bitcastToAPInt();
617 const char *FltPtr = (const char*)FltVal.getRawData();
619 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
620 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
621 int Incr = (LittleEndian ? 1 : -1);
622 int Start = (LittleEndian ? 0 : NumBytes - 1);
623 int Stop = (LittleEndian ? NumBytes : -1);
625 // Output the constant to DWARF one byte at a time.
626 for (; Start != Stop; Start += Incr)
627 addUInt(Block, 0, dwarf::DW_FORM_data1,
628 (unsigned char)0xFF & FltPtr[Start]);
630 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
634 /// addConstantFPValue - Add constant value entry in variable DIE.
635 bool CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
636 return addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), false);
639 /// addConstantValue - Add constant value entry in variable DIE.
640 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
642 return addConstantValue(Die, CI->getValue(), Unsigned);
645 // addConstantValue - Add constant value entry in variable DIE.
646 bool CompileUnit::addConstantValue(DIE *Die, const APInt &Val,
648 unsigned CIBitWidth = Val.getBitWidth();
649 if (CIBitWidth <= 64) {
651 switch (CIBitWidth) {
652 case 8: form = dwarf::DW_FORM_data1; break;
653 case 16: form = dwarf::DW_FORM_data2; break;
654 case 32: form = dwarf::DW_FORM_data4; break;
655 case 64: form = dwarf::DW_FORM_data8; break;
657 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
660 addUInt(Die, dwarf::DW_AT_const_value, form, Val.getZExtValue());
662 addSInt(Die, dwarf::DW_AT_const_value, form, Val.getSExtValue());
666 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
668 // Get the raw data form of the large APInt.
669 const uint64_t *Ptr64 = Val.getRawData();
671 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
672 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
674 // Output the constant to DWARF one byte at a time.
675 for (int i = 0; i < NumBytes; i++) {
678 c = Ptr64[i / 8] >> (8 * (i & 7));
680 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
681 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
684 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
688 /// addTemplateParams - Add template parameters into buffer.
689 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
690 // Add template parameters.
691 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
692 DIDescriptor Element = TParams.getElement(i);
693 if (Element.isTemplateTypeParameter())
694 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
695 DITemplateTypeParameter(Element)));
696 else if (Element.isTemplateValueParameter())
697 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
698 DITemplateValueParameter(Element)));
702 /// getOrCreateContextDIE - Get context owner's DIE.
703 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) {
704 if (Context.isType())
705 return getOrCreateTypeDIE(DIType(Context));
706 else if (Context.isNameSpace())
707 return getOrCreateNameSpace(DINameSpace(Context));
708 else if (Context.isSubprogram())
709 return getOrCreateSubprogramDIE(DISubprogram(Context));
711 return getDIE(Context);
714 /// addToContextOwner - Add Die into the list of its context owner's children.
715 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
716 if (DIE *ContextDIE = getOrCreateContextDIE(Context))
717 ContextDIE->addChild(Die);
722 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
724 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
728 DIE *TyDIE = getDIE(Ty);
733 TyDIE = new DIE(dwarf::DW_TAG_base_type);
734 insertDIE(Ty, TyDIE);
735 if (Ty.isBasicType())
736 constructTypeDIE(*TyDIE, DIBasicType(Ty));
737 else if (Ty.isCompositeType())
738 constructTypeDIE(*TyDIE, DICompositeType(Ty));
740 assert(Ty.isDerivedType() && "Unknown kind of DIType");
741 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
743 // If this is a named finished type then include it in the list of types
744 // for the accelerator tables.
745 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
746 bool IsImplementation = 0;
747 if (Ty.isCompositeType()) {
748 DICompositeType CT(Ty);
749 // A runtime language of 0 actually means C/C++ and that any
750 // non-negative value is some version of Objective-C/C++.
751 IsImplementation = (CT.getRunTimeLang() == 0) ||
752 CT.isObjcClassComplete();
754 unsigned Flags = IsImplementation ?
755 DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
756 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
759 addToContextOwner(TyDIE, Ty.getContext());
763 /// addType - Add a new type attribute to the specified entity.
764 void CompileUnit::addType(DIE *Entity, DIType Ty, unsigned Attribute) {
768 // Check for pre-existence.
769 DIEEntry *Entry = getDIEEntry(Ty);
770 // If it exists then use the existing value.
772 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
777 DIE *Buffer = getOrCreateTypeDIE(Ty);
780 Entry = createDIEEntry(Buffer);
781 insertDIEEntry(Ty, Entry);
782 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
784 // If this is a complete composite type then include it in the
785 // list of global types.
789 /// addGlobalType - Add a new global type to the compile unit.
791 void CompileUnit::addGlobalType(DIType Ty) {
792 DIDescriptor Context = Ty.getContext();
793 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
794 && (!Context || Context.isCompileUnit() || Context.isFile()
795 || Context.isNameSpace()))
796 if (DIEEntry *Entry = getDIEEntry(Ty))
797 GlobalTypes[Ty.getName()] = Entry->getEntry();
800 /// addPubTypes - Add type for pubtypes section.
801 void CompileUnit::addPubTypes(DISubprogram SP) {
802 DICompositeType SPTy = SP.getType();
803 unsigned SPTag = SPTy.getTag();
804 if (SPTag != dwarf::DW_TAG_subroutine_type)
807 DIArray Args = SPTy.getTypeArray();
808 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
809 DIType ATy(Args.getElement(i));
816 /// constructTypeDIE - Construct basic type die from DIBasicType.
817 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
818 // Get core information.
819 StringRef Name = BTy.getName();
820 // Add name if not anonymous or intermediate type.
822 addString(&Buffer, dwarf::DW_AT_name, Name);
824 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
825 Buffer.setTag(dwarf::DW_TAG_unspecified_type);
826 // Unspecified types has only name, nothing else.
830 Buffer.setTag(dwarf::DW_TAG_base_type);
831 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
834 uint64_t Size = BTy.getSizeInBits() >> 3;
835 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
838 /// constructTypeDIE - Construct derived type die from DIDerivedType.
839 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
840 // Get core information.
841 StringRef Name = DTy.getName();
842 uint64_t Size = DTy.getSizeInBits() >> 3;
843 unsigned Tag = DTy.getTag();
845 // FIXME - Workaround for templates.
846 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
850 // Map to main type, void will not have a type.
851 DIType FromTy = DTy.getTypeDerivedFrom();
852 addType(&Buffer, FromTy);
854 // Add name if not anonymous or intermediate type.
856 addString(&Buffer, dwarf::DW_AT_name, Name);
858 // Add size if non-zero (derived types might be zero-sized.)
859 if (Size && Tag != dwarf::DW_TAG_pointer_type)
860 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
862 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
863 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
864 getOrCreateTypeDIE(DTy.getClassType()));
865 // Add source line info if available and TyDesc is not a forward declaration.
866 if (!DTy.isForwardDecl())
867 addSourceLine(&Buffer, DTy);
870 /// constructTypeDIE - Construct type DIE from DICompositeType.
871 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
872 // Get core information.
873 StringRef Name = CTy.getName();
875 uint64_t Size = CTy.getSizeInBits() >> 3;
876 unsigned Tag = CTy.getTag();
880 case dwarf::DW_TAG_array_type:
881 constructArrayTypeDIE(Buffer, &CTy);
883 case dwarf::DW_TAG_enumeration_type: {
884 DIArray Elements = CTy.getTypeArray();
886 // Add enumerators to enumeration type.
887 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
889 DIDescriptor Enum(Elements.getElement(i));
890 if (Enum.isEnumerator()) {
891 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
892 Buffer.addChild(ElemDie);
895 DIType DTy = CTy.getTypeDerivedFrom();
897 addType(&Buffer, DTy);
898 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
902 case dwarf::DW_TAG_subroutine_type: {
904 DIArray Elements = CTy.getTypeArray();
905 DIDescriptor RTy = Elements.getElement(0);
906 addType(&Buffer, DIType(RTy));
908 bool isPrototyped = true;
910 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
911 DIDescriptor Ty = Elements.getElement(i);
912 if (Ty.isUnspecifiedParameter()) {
913 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
914 Buffer.addChild(Arg);
915 isPrototyped = false;
917 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
918 addType(Arg, DIType(Ty));
919 if (DIType(Ty).isArtificial())
920 addFlag(Arg, dwarf::DW_AT_artificial);
921 Buffer.addChild(Arg);
924 // Add prototype flag if we're dealing with a C language and the
925 // function has been prototyped.
927 (Language == dwarf::DW_LANG_C89 ||
928 Language == dwarf::DW_LANG_C99 ||
929 Language == dwarf::DW_LANG_ObjC))
930 addFlag(&Buffer, dwarf::DW_AT_prototyped);
933 case dwarf::DW_TAG_structure_type:
934 case dwarf::DW_TAG_union_type:
935 case dwarf::DW_TAG_class_type: {
936 // Add elements to structure type.
937 DIArray Elements = CTy.getTypeArray();
939 // A forward struct declared type may not have elements available.
940 unsigned N = Elements.getNumElements();
944 // Add elements to structure type.
945 for (unsigned i = 0; i < N; ++i) {
946 DIDescriptor Element = Elements.getElement(i);
948 if (Element.isSubprogram()) {
949 DISubprogram SP(Element);
950 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
951 if (SP.isProtected())
952 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
953 dwarf::DW_ACCESS_protected);
954 else if (SP.isPrivate())
955 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
956 dwarf::DW_ACCESS_private);
958 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
959 dwarf::DW_ACCESS_public);
961 addFlag(ElemDie, dwarf::DW_AT_explicit);
962 } else if (Element.isDerivedType()) {
963 DIDerivedType DDTy(Element);
964 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
965 ElemDie = new DIE(dwarf::DW_TAG_friend);
966 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
967 } else if (DDTy.isStaticMember())
968 ElemDie = createStaticMemberDIE(DDTy);
970 ElemDie = createMemberDIE(DDTy);
971 } else if (Element.isObjCProperty()) {
972 DIObjCProperty Property(Element);
973 ElemDie = new DIE(Property.getTag());
974 StringRef PropertyName = Property.getObjCPropertyName();
975 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
976 addType(ElemDie, Property.getType());
977 addSourceLine(ElemDie, Property);
978 StringRef GetterName = Property.getObjCPropertyGetterName();
979 if (!GetterName.empty())
980 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
981 StringRef SetterName = Property.getObjCPropertySetterName();
982 if (!SetterName.empty())
983 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
984 unsigned PropertyAttributes = 0;
985 if (Property.isReadOnlyObjCProperty())
986 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
987 if (Property.isReadWriteObjCProperty())
988 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
989 if (Property.isAssignObjCProperty())
990 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
991 if (Property.isRetainObjCProperty())
992 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
993 if (Property.isCopyObjCProperty())
994 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
995 if (Property.isNonAtomicObjCProperty())
996 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
997 if (PropertyAttributes)
998 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1001 DIEEntry *Entry = getDIEEntry(Element);
1003 Entry = createDIEEntry(ElemDie);
1004 insertDIEEntry(Element, Entry);
1008 Buffer.addChild(ElemDie);
1011 if (CTy.isAppleBlockExtension())
1012 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1014 DICompositeType ContainingType = CTy.getContainingType();
1015 if (DIDescriptor(ContainingType).isCompositeType())
1016 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1017 getOrCreateTypeDIE(DIType(ContainingType)));
1019 DIDescriptor Context = CTy.getContext();
1020 addToContextOwner(&Buffer, Context);
1023 if (CTy.isObjcClassComplete())
1024 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1026 // Add template parameters to a class, structure or union types.
1027 // FIXME: The support isn't in the metadata for this yet.
1028 if (Tag == dwarf::DW_TAG_class_type ||
1029 Tag == dwarf::DW_TAG_structure_type ||
1030 Tag == dwarf::DW_TAG_union_type)
1031 addTemplateParams(Buffer, CTy.getTemplateParams());
1039 // Add name if not anonymous or intermediate type.
1041 addString(&Buffer, dwarf::DW_AT_name, Name);
1043 if (Tag == dwarf::DW_TAG_enumeration_type ||
1044 Tag == dwarf::DW_TAG_class_type ||
1045 Tag == dwarf::DW_TAG_structure_type ||
1046 Tag == dwarf::DW_TAG_union_type) {
1047 // Add size if non-zero (derived types might be zero-sized.)
1048 // TODO: Do we care about size for enum forward declarations?
1050 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1051 else if (!CTy.isForwardDecl())
1052 // Add zero size if it is not a forward declaration.
1053 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1055 // If we're a forward decl, say so.
1056 if (CTy.isForwardDecl())
1057 addFlag(&Buffer, dwarf::DW_AT_declaration);
1059 // Add source line info if available.
1060 if (!CTy.isForwardDecl())
1061 addSourceLine(&Buffer, CTy);
1063 // No harm in adding the runtime language to the declaration.
1064 unsigned RLang = CTy.getRunTimeLang();
1066 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1067 dwarf::DW_FORM_data1, RLang);
1071 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1072 /// for the given DITemplateTypeParameter.
1074 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1075 DIE *ParamDIE = getDIE(TP);
1079 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1080 addType(ParamDIE, TP.getType());
1081 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1085 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1086 /// for the given DITemplateValueParameter.
1088 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){
1089 DIE *ParamDIE = getDIE(TPV);
1093 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
1094 addType(ParamDIE, TPV.getType());
1095 if (!TPV.getName().empty())
1096 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
1097 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1102 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1103 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1104 DIE *NDie = getDIE(NS);
1107 NDie = new DIE(dwarf::DW_TAG_namespace);
1108 insertDIE(NS, NDie);
1109 if (!NS.getName().empty()) {
1110 addString(NDie, dwarf::DW_AT_name, NS.getName());
1111 addAccelNamespace(NS.getName(), NDie);
1113 addAccelNamespace("(anonymous namespace)", NDie);
1114 addSourceLine(NDie, NS);
1115 addToContextOwner(NDie, NS.getContext());
1119 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1120 /// printer to not emit usual symbol prefix before the symbol name is used then
1121 /// return linkage name after skipping this special LLVM prefix.
1122 static StringRef getRealLinkageName(StringRef LinkageName) {
1124 if (LinkageName.startswith(StringRef(&One, 1)))
1125 return LinkageName.substr(1);
1129 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1130 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1131 DIE *SPDie = getDIE(SP);
1135 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1137 // DW_TAG_inlined_subroutine may refer to this DIE.
1138 insertDIE(SP, SPDie);
1140 DISubprogram SPDecl = SP.getFunctionDeclaration();
1141 DIE *DeclDie = NULL;
1142 if (SPDecl.isSubprogram()) {
1143 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1146 // Add to context owner.
1147 addToContextOwner(SPDie, SP.getContext());
1149 // Add function template parameters.
1150 addTemplateParams(*SPDie, SP.getTemplateParams());
1152 // Unfortunately this code needs to stay here instead of below the
1153 // AT_specification code in order to work around a bug in older
1154 // gdbs that requires the linkage name to resolve multiple template
1156 // TODO: Remove this set of code when we get rid of the old gdb
1158 StringRef LinkageName = SP.getLinkageName();
1159 if (!LinkageName.empty() && DD->useDarwinGDBCompat())
1160 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1161 getRealLinkageName(LinkageName));
1163 // If this DIE is going to refer declaration info using AT_specification
1164 // then there is no need to add other attributes.
1166 // Refer function declaration directly.
1167 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1173 // Add the linkage name if we have one.
1174 if (!LinkageName.empty() && !DD->useDarwinGDBCompat())
1175 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1176 getRealLinkageName(LinkageName));
1178 // Constructors and operators for anonymous aggregates do not have names.
1179 if (!SP.getName().empty())
1180 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1182 addSourceLine(SPDie, SP);
1184 // Add the prototype if we have a prototype and we have a C like
1186 if (SP.isPrototyped() &&
1187 (Language == dwarf::DW_LANG_C89 ||
1188 Language == dwarf::DW_LANG_C99 ||
1189 Language == dwarf::DW_LANG_ObjC))
1190 addFlag(SPDie, dwarf::DW_AT_prototyped);
1193 DICompositeType SPTy = SP.getType();
1194 DIArray Args = SPTy.getTypeArray();
1195 unsigned SPTag = SPTy.getTag();
1197 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1198 addType(SPDie, SPTy);
1200 addType(SPDie, DIType(Args.getElement(0)));
1202 unsigned VK = SP.getVirtuality();
1204 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1205 DIEBlock *Block = getDIEBlock();
1206 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1207 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1208 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1209 ContainingTypeMap.insert(std::make_pair(SPDie,
1210 SP.getContainingType()));
1213 if (!SP.isDefinition()) {
1214 addFlag(SPDie, dwarf::DW_AT_declaration);
1216 // Add arguments. Do not add arguments for subprogram definition. They will
1217 // be handled while processing variables.
1218 DICompositeType SPTy = SP.getType();
1219 DIArray Args = SPTy.getTypeArray();
1220 unsigned SPTag = SPTy.getTag();
1222 if (SPTag == dwarf::DW_TAG_subroutine_type)
1223 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1224 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1225 DIType ATy = DIType(Args.getElement(i));
1227 if (ATy.isArtificial())
1228 addFlag(Arg, dwarf::DW_AT_artificial);
1229 SPDie->addChild(Arg);
1233 if (SP.isArtificial())
1234 addFlag(SPDie, dwarf::DW_AT_artificial);
1236 if (!SP.isLocalToUnit())
1237 addFlag(SPDie, dwarf::DW_AT_external);
1239 if (SP.isOptimized())
1240 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1242 if (unsigned isa = Asm->getISAEncoding()) {
1243 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1249 // Return const expression if value is a GEP to access merged global
1251 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1252 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1253 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1254 if (!CE || CE->getNumOperands() != 3 ||
1255 CE->getOpcode() != Instruction::GetElementPtr)
1258 // First operand points to a global struct.
1259 Value *Ptr = CE->getOperand(0);
1260 if (!isa<GlobalValue>(Ptr) ||
1261 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1264 // Second operand is zero.
1265 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1266 if (!CI || !CI->isZero())
1269 // Third operand is offset.
1270 if (!isa<ConstantInt>(CE->getOperand(2)))
1276 /// createGlobalVariableDIE - create global variable DIE.
1277 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1278 // Check for pre-existence.
1282 DIGlobalVariable GV(N);
1286 DIDescriptor GVContext = GV.getContext();
1287 DIType GTy = GV.getType();
1289 // If this is a static data member definition, some attributes belong
1290 // to the declaration DIE.
1291 DIE *VariableDIE = NULL;
1292 bool IsStaticMember = false;
1293 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1294 if (SDMDecl.Verify()) {
1295 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1296 // We need the declaration DIE that is in the static member's class.
1297 // But that class might not exist in the DWARF yet.
1298 // Creating the class will create the static member decl DIE.
1299 getOrCreateContextDIE(SDMDecl.getContext());
1300 VariableDIE = getDIE(SDMDecl);
1301 assert(VariableDIE && "Static member decl has no context?");
1302 IsStaticMember = true;
1305 // If this is not a static data member definition, create the variable
1306 // DIE and add the initial set of attributes to it.
1308 VariableDIE = new DIE(GV.getTag());
1310 insertDIE(N, VariableDIE);
1312 // Add name and type.
1313 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1314 addType(VariableDIE, GTy);
1316 // Add scoping info.
1317 if (!GV.isLocalToUnit()) {
1318 addFlag(VariableDIE, dwarf::DW_AT_external);
1319 addGlobalName(GV.getName(), VariableDIE);
1322 // Add line number info.
1323 addSourceLine(VariableDIE, GV);
1324 // Add to context owner.
1325 addToContextOwner(VariableDIE, GVContext);
1329 bool addToAccelTable = false;
1330 DIE *VariableSpecDIE = NULL;
1331 bool isGlobalVariable = GV.getGlobal() != NULL;
1332 if (isGlobalVariable) {
1333 addToAccelTable = true;
1334 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1335 addOpAddress(Block, Asm->Mang->getSymbol(GV.getGlobal()));
1336 // Do not create specification DIE if context is either compile unit
1338 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1339 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1340 // Create specification DIE.
1341 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1342 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1343 dwarf::DW_FORM_ref4, VariableDIE);
1344 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1345 // A static member's declaration is already flagged as such.
1346 if (!SDMDecl.Verify())
1347 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1348 addDie(VariableSpecDIE);
1350 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1352 // Add linkage name.
1353 StringRef LinkageName = GV.getLinkageName();
1354 if (!LinkageName.empty()) {
1355 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1356 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1358 addString(IsStaticMember && VariableSpecDIE ?
1359 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1360 getRealLinkageName(LinkageName));
1361 // In compatibility mode with older gdbs we put the linkage name on both
1362 // the TAG_variable DIE and on the TAG_member DIE.
1363 if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat())
1364 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1365 getRealLinkageName(LinkageName));
1367 } else if (const ConstantInt *CI =
1368 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1369 // AT_const_value was added when the static member was created. To avoid
1370 // emitting AT_const_value multiple times, we only add AT_const_value when
1371 // it is not a static member.
1372 if (!IsStaticMember)
1373 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1374 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1375 addToAccelTable = true;
1376 // GV is a merged global.
1377 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1378 Value *Ptr = CE->getOperand(0);
1379 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1380 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1381 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1382 addUInt(Block, 0, dwarf::DW_FORM_udata,
1383 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1384 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1385 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1388 if (addToAccelTable) {
1389 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1390 addAccelName(GV.getName(), AddrDIE);
1392 // If the linkage name is different than the name, go ahead and output
1393 // that as well into the name table.
1394 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1395 addAccelName(GV.getLinkageName(), AddrDIE);
1401 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1402 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1404 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1405 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1407 // The LowerBound value defines the lower bounds which is typically zero for
1408 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1409 // Count == -1 then the array is unbounded and we do not emit
1410 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1411 // Count == 0, then the array has zero elements in which case we do not emit
1413 int64_t LowerBound = SR.getLo();
1414 int64_t DefaultLowerBound = getDefaultLowerBound();
1415 int64_t Count = SR.getCount();
1417 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1418 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1420 if (Count != -1 && Count != 0)
1421 // FIXME: An unbounded array should reference the expression that defines
1423 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1425 Buffer.addChild(DW_Subrange);
1428 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1429 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1430 DICompositeType *CTy) {
1431 Buffer.setTag(dwarf::DW_TAG_array_type);
1432 if (CTy->isVector())
1433 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1435 // Emit derived type.
1436 addType(&Buffer, CTy->getTypeDerivedFrom());
1437 DIArray Elements = CTy->getTypeArray();
1439 // Get an anonymous type for index type.
1440 // FIXME: This type should be passed down from the front end
1441 // as different languages may have different sizes for indexes.
1442 DIE *IdxTy = getIndexTyDie();
1444 // Construct an anonymous type for index type.
1445 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1446 addString(IdxTy, dwarf::DW_AT_name, "int");
1447 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1448 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1449 dwarf::DW_ATE_signed);
1451 setIndexTyDie(IdxTy);
1454 // Add subranges to array type.
1455 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1456 DIDescriptor Element = Elements.getElement(i);
1457 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1458 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1462 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1463 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1464 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1465 StringRef Name = ETy.getName();
1466 addString(Enumerator, dwarf::DW_AT_name, Name);
1467 int64_t Value = ETy.getEnumValue();
1468 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1472 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1474 void CompileUnit::constructContainingTypeDIEs() {
1475 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1476 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1477 DIE *SPDie = CI->first;
1478 const MDNode *N = CI->second;
1480 DIE *NDie = getDIE(N);
1481 if (!NDie) continue;
1482 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1486 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1487 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1488 StringRef Name = DV->getName();
1490 // Translate tag to proper Dwarf tag.
1491 unsigned Tag = DV->getTag();
1493 // Define variable debug information entry.
1494 DIE *VariableDie = new DIE(Tag);
1495 DbgVariable *AbsVar = DV->getAbstractVariable();
1496 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1498 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1499 dwarf::DW_FORM_ref4, AbsDIE);
1501 addString(VariableDie, dwarf::DW_AT_name, Name);
1502 addSourceLine(VariableDie, DV->getVariable());
1503 addType(VariableDie, DV->getType());
1506 if (DV->isArtificial())
1507 addFlag(VariableDie, dwarf::DW_AT_artificial);
1509 if (isScopeAbstract) {
1510 DV->setDIE(VariableDie);
1514 // Add variable address.
1516 unsigned Offset = DV->getDotDebugLocOffset();
1517 if (Offset != ~0U) {
1518 addLabel(VariableDie, dwarf::DW_AT_location,
1519 dwarf::DW_FORM_data4,
1520 Asm->GetTempSymbol("debug_loc", Offset));
1521 DV->setDIE(VariableDie);
1525 // Check if variable is described by a DBG_VALUE instruction.
1526 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1527 bool updated = false;
1528 if (DVInsn->getNumOperands() == 3) {
1529 if (DVInsn->getOperand(0).isReg()) {
1530 const MachineOperand RegOp = DVInsn->getOperand(0);
1531 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1532 if (DVInsn->getOperand(1).isImm() &&
1533 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1534 unsigned FrameReg = 0;
1535 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1537 TFI->getFrameIndexReference(*Asm->MF,
1538 DVInsn->getOperand(1).getImm(),
1540 MachineLocation Location(FrameReg, Offset);
1541 addVariableAddress(DV, VariableDie, Location);
1543 } else if (RegOp.getReg())
1544 addVariableAddress(DV, VariableDie,
1545 MachineLocation(RegOp.getReg()));
1548 else if (DVInsn->getOperand(0).isImm())
1550 addConstantValue(VariableDie, DVInsn->getOperand(0),
1552 else if (DVInsn->getOperand(0).isFPImm())
1554 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1555 else if (DVInsn->getOperand(0).isCImm())
1557 addConstantValue(VariableDie,
1558 DVInsn->getOperand(0).getCImm(),
1559 DV->getType().isUnsignedDIType());
1561 addVariableAddress(DV, VariableDie,
1562 Asm->getDebugValueLocation(DVInsn));
1566 // If variableDie is not updated then DBG_VALUE instruction does not
1567 // have valid variable info.
1571 DV->setDIE(VariableDie);
1574 // .. else use frame index.
1575 int FI = DV->getFrameIndex();
1577 unsigned FrameReg = 0;
1578 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1580 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1581 MachineLocation Location(FrameReg, Offset);
1582 addVariableAddress(DV, VariableDie, Location);
1586 DV->setDIE(VariableDie);
1590 /// createMemberDIE - Create new member DIE.
1591 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1592 DIE *MemberDie = new DIE(DT.getTag());
1593 StringRef Name = DT.getName();
1595 addString(MemberDie, dwarf::DW_AT_name, Name);
1597 addType(MemberDie, DT.getTypeDerivedFrom());
1599 addSourceLine(MemberDie, DT);
1601 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1602 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1604 uint64_t Size = DT.getSizeInBits();
1605 uint64_t FieldSize = DT.getOriginalTypeSize();
1607 if (Size != FieldSize) {
1609 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1610 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1612 uint64_t Offset = DT.getOffsetInBits();
1613 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1614 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1615 uint64_t FieldOffset = (HiMark - FieldSize);
1616 Offset -= FieldOffset;
1618 // Maybe we need to work from the other end.
1619 if (Asm->getDataLayout().isLittleEndian())
1620 Offset = FieldSize - (Offset + Size);
1621 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1623 // Here WD_AT_data_member_location points to the anonymous
1624 // field that includes this bit field.
1625 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1628 // This is not a bitfield.
1629 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1631 if (DT.getTag() == dwarf::DW_TAG_inheritance
1632 && DT.isVirtual()) {
1634 // For C++, virtual base classes are not at fixed offset. Use following
1635 // expression to extract appropriate offset from vtable.
1636 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1638 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1639 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1640 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1641 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1642 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1643 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1644 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1645 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1647 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1650 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1652 if (DT.isProtected())
1653 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1654 dwarf::DW_ACCESS_protected);
1655 else if (DT.isPrivate())
1656 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1657 dwarf::DW_ACCESS_private);
1658 // Otherwise C++ member and base classes are considered public.
1660 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1661 dwarf::DW_ACCESS_public);
1663 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1664 dwarf::DW_VIRTUALITY_virtual);
1666 // Objective-C properties.
1667 if (MDNode *PNode = DT.getObjCProperty())
1668 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1669 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1672 if (DT.isArtificial())
1673 addFlag(MemberDie, dwarf::DW_AT_artificial);
1678 /// createStaticMemberDIE - Create new DIE for C++ static member.
1679 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1683 DIE *StaticMemberDIE = new DIE(DT.getTag());
1684 DIType Ty = DT.getTypeDerivedFrom();
1686 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1687 addType(StaticMemberDIE, Ty);
1688 addSourceLine(StaticMemberDIE, DT);
1689 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1690 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1692 // FIXME: We could omit private if the parent is a class_type, and
1693 // public if the parent is something else.
1694 if (DT.isProtected())
1695 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1696 dwarf::DW_ACCESS_protected);
1697 else if (DT.isPrivate())
1698 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1699 dwarf::DW_ACCESS_private);
1701 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1702 dwarf::DW_ACCESS_public);
1704 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1705 addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1706 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1707 addConstantFPValue(StaticMemberDIE, CFP);
1709 insertDIE(DT, StaticMemberDIE);
1710 return StaticMemberDIE;