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/Target/Mangler.h"
26 #include "llvm/Target/TargetFrameLowering.h"
27 #include "llvm/Target/TargetMachine.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetRegisterInfo.h"
33 /// CompileUnit - Compile unit constructor.
34 CompileUnit::CompileUnit(unsigned UID, DIE *D, const MDNode *N, AsmPrinter *A,
35 DwarfDebug *DW, DwarfUnits *DWU)
36 : UniqueID(UID), Node(N), CUDie(D), Asm(A), DD(DW), DU(DWU), IndexTyDie(0) {
37 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
41 /// ~CompileUnit - Destructor for compile unit.
42 CompileUnit::~CompileUnit() {
43 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
44 DIEBlocks[j]->~DIEBlock();
47 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
48 /// information entry.
49 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
50 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
54 /// getDefaultLowerBound - Return the default lower bound for an array. If the
55 /// DWARF version doesn't handle the language, return -1.
56 int64_t CompileUnit::getDefaultLowerBound() const {
57 switch (DICompileUnit(Node).getLanguage()) {
61 case dwarf::DW_LANG_C89:
62 case dwarf::DW_LANG_C99:
63 case dwarf::DW_LANG_C:
64 case dwarf::DW_LANG_C_plus_plus:
65 case dwarf::DW_LANG_ObjC:
66 case dwarf::DW_LANG_ObjC_plus_plus:
69 case dwarf::DW_LANG_Fortran77:
70 case dwarf::DW_LANG_Fortran90:
71 case dwarf::DW_LANG_Fortran95:
74 // The languages below have valid values only if the DWARF version >= 4.
75 case dwarf::DW_LANG_Java:
76 case dwarf::DW_LANG_Python:
77 case dwarf::DW_LANG_UPC:
78 case dwarf::DW_LANG_D:
79 if (dwarf::DWARF_VERSION >= 4)
83 case dwarf::DW_LANG_Ada83:
84 case dwarf::DW_LANG_Ada95:
85 case dwarf::DW_LANG_Cobol74:
86 case dwarf::DW_LANG_Cobol85:
87 case dwarf::DW_LANG_Modula2:
88 case dwarf::DW_LANG_Pascal83:
89 case dwarf::DW_LANG_PLI:
90 if (dwarf::DWARF_VERSION >= 4)
98 /// addFlag - Add a flag that is true.
99 void CompileUnit::addFlag(DIE *Die, uint16_t Attribute) {
100 if (DD->getDwarfVersion() >= 4)
101 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
103 Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
106 /// addUInt - Add an unsigned integer attribute data and value.
108 void CompileUnit::addUInt(DIE *Die, uint16_t Attribute,
109 uint16_t Form, uint64_t Integer) {
110 if (!Form) Form = DIEInteger::BestForm(false, Integer);
111 DIEValue *Value = Integer == 1 ?
112 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
113 Die->addValue(Attribute, Form, Value);
116 /// addSInt - Add an signed integer attribute data and value.
118 void CompileUnit::addSInt(DIE *Die, uint16_t Attribute,
119 uint16_t Form, int64_t Integer) {
120 if (!Form) Form = DIEInteger::BestForm(true, Integer);
121 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
122 Die->addValue(Attribute, Form, Value);
125 /// addString - Add a string attribute data and value. We always emit a
126 /// reference to the string pool instead of immediate strings so that DIEs have
127 /// more predictable sizes. In the case of split dwarf we emit an index
128 /// into another table which gets us the static offset into the string
130 void CompileUnit::addString(DIE *Die, uint16_t Attribute, StringRef String) {
133 if (!DD->useSplitDwarf()) {
134 MCSymbol *Symb = DU->getStringPoolEntry(String);
135 if (Asm->needsRelocationsForDwarfStringPool())
136 Value = new (DIEValueAllocator) DIELabel(Symb);
138 MCSymbol *StringPool = DU->getStringPoolSym();
139 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
141 Form = dwarf::DW_FORM_strp;
143 unsigned idx = DU->getStringPoolIndex(String);
144 Value = new (DIEValueAllocator) DIEInteger(idx);
145 Form = dwarf::DW_FORM_GNU_str_index;
147 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
148 Die->addValue(Attribute, Form, Str);
151 /// addLocalString - Add a string attribute data and value. This is guaranteed
152 /// to be in the local string pool instead of indirected.
153 void CompileUnit::addLocalString(DIE *Die, uint16_t Attribute,
155 MCSymbol *Symb = DU->getStringPoolEntry(String);
157 if (Asm->needsRelocationsForDwarfStringPool())
158 Value = new (DIEValueAllocator) DIELabel(Symb);
160 MCSymbol *StringPool = DU->getStringPoolSym();
161 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
163 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
166 /// addExpr - Add a Dwarf expression attribute data and value.
168 void CompileUnit::addExpr(DIE *Die, uint16_t Attribute, uint16_t Form,
169 const MCExpr *Expr) {
170 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
171 Die->addValue(Attribute, Form, Value);
174 /// addLabel - Add a Dwarf label attribute data and value.
176 void CompileUnit::addLabel(DIE *Die, uint16_t Attribute, uint16_t Form,
177 const MCSymbol *Label) {
178 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
179 Die->addValue(Attribute, Form, Value);
182 /// addLabelAddress - Add a dwarf label attribute data and value using
183 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
185 void CompileUnit::addLabelAddress(DIE *Die, uint16_t Attribute,
188 DD->addArangeLabel(SymbolCU(this, Label));
190 if (!DD->useSplitDwarf()) {
192 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
193 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
195 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
196 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
199 unsigned idx = DU->getAddrPoolIndex(Label);
200 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
201 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
205 /// addOpAddress - Add a dwarf op address data and value using the
206 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
208 void CompileUnit::addOpAddress(DIE *Die, const MCSymbol *Sym) {
209 DD->addArangeLabel(SymbolCU(this, 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, DIE *Entry) {
230 // We currently only use ref4.
231 Die->addValue(Attribute, dwarf::DW_FORM_ref4, 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 = resolve(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(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
591 if (Ty.isDerivedType())
592 return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
594 if (Ty.isBasicType())
595 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
596 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
597 *SizeInBits = Ty.getSizeInBits();
603 /// Return true if type encoding is unsigned.
604 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
605 DIDerivedType DTy(Ty);
606 if (DTy.isDerivedType())
607 return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
610 if (BTy.isBasicType()) {
611 unsigned Encoding = BTy.getEncoding();
612 if (Encoding == dwarf::DW_ATE_unsigned ||
613 Encoding == dwarf::DW_ATE_unsigned_char ||
614 Encoding == dwarf::DW_ATE_boolean)
620 /// If this type is derived from a base type then return base type size.
621 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
622 unsigned Tag = Ty.getTag();
624 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
625 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
626 Tag != dwarf::DW_TAG_restrict_type)
627 return Ty.getSizeInBits();
629 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
631 // If this type is not derived from any type then take conservative approach.
632 if (!BaseType.isValid())
633 return Ty.getSizeInBits();
635 // If this is a derived type, go ahead and get the base type, unless it's a
636 // reference then it's just the size of the field. Pointer types have no need
637 // of this since they're a different type of qualification on the type.
638 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
639 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
640 return Ty.getSizeInBits();
642 if (BaseType.isDerivedType())
643 return getBaseTypeSize(DD, DIDerivedType(BaseType));
645 return BaseType.getSizeInBits();
648 /// addConstantValue - Add constant value entry in variable DIE.
649 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
651 // FIXME: This is a bit conservative/simple - it emits negative values at
652 // their maximum bit width which is a bit unfortunate (& doesn't prefer
653 // udata/sdata over dataN as suggested by the DWARF spec)
654 assert(MO.isImm() && "Invalid machine operand!");
656 bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
659 // If we're a signed constant definitely use sdata.
660 if (SignedConstant) {
661 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
665 // Else use data for now unless it's larger than we can deal with.
666 switch (SizeInBits) {
668 Form = dwarf::DW_FORM_data1;
671 Form = dwarf::DW_FORM_data2;
674 Form = dwarf::DW_FORM_data4;
677 Form = dwarf::DW_FORM_data8;
680 Form = dwarf::DW_FORM_udata;
681 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
684 addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
687 /// addConstantFPValue - Add constant value entry in variable DIE.
688 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
689 assert (MO.isFPImm() && "Invalid machine operand!");
690 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
691 APFloat FPImm = MO.getFPImm()->getValueAPF();
693 // Get the raw data form of the floating point.
694 const APInt FltVal = FPImm.bitcastToAPInt();
695 const char *FltPtr = (const char*)FltVal.getRawData();
697 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
698 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
699 int Incr = (LittleEndian ? 1 : -1);
700 int Start = (LittleEndian ? 0 : NumBytes - 1);
701 int Stop = (LittleEndian ? NumBytes : -1);
703 // Output the constant to DWARF one byte at a time.
704 for (; Start != Stop; Start += Incr)
705 addUInt(Block, 0, dwarf::DW_FORM_data1,
706 (unsigned char)0xFF & FltPtr[Start]);
708 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
711 /// addConstantFPValue - Add constant value entry in variable DIE.
712 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
713 // Pass this down to addConstantValue as an unsigned bag of bits.
714 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
717 /// addConstantValue - Add constant value entry in variable DIE.
718 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
720 addConstantValue(Die, CI->getValue(), Unsigned);
723 // addConstantValue - Add constant value entry in variable DIE.
724 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
725 unsigned CIBitWidth = Val.getBitWidth();
726 if (CIBitWidth <= 64) {
727 // If we're a signed constant definitely use sdata.
729 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
734 // Else use data for now unless it's larger than we can deal with.
736 switch (CIBitWidth) {
738 Form = dwarf::DW_FORM_data1;
741 Form = dwarf::DW_FORM_data2;
744 Form = dwarf::DW_FORM_data4;
747 Form = dwarf::DW_FORM_data8;
750 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
754 addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
758 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
760 // Get the raw data form of the large APInt.
761 const uint64_t *Ptr64 = Val.getRawData();
763 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
764 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
766 // Output the constant to DWARF one byte at a time.
767 for (int i = 0; i < NumBytes; i++) {
770 c = Ptr64[i / 8] >> (8 * (i & 7));
772 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
773 addUInt(Block, 0, dwarf::DW_FORM_data1, c);
776 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
779 /// addTemplateParams - Add template parameters into buffer.
780 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
781 // Add template parameters.
782 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
783 DIDescriptor Element = TParams.getElement(i);
784 if (Element.isTemplateTypeParameter())
785 getOrCreateTemplateTypeParameterDIE(
786 DITemplateTypeParameter(Element), Buffer);
787 else if (Element.isTemplateValueParameter())
788 getOrCreateTemplateValueParameterDIE(
789 DITemplateValueParameter(Element), Buffer);
793 /// getOrCreateContextDIE - Get context owner's DIE.
794 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
795 if (Context.isType())
796 return getOrCreateTypeDIE(DIType(Context));
797 else if (Context.isNameSpace())
798 return getOrCreateNameSpace(DINameSpace(Context));
799 else if (Context.isSubprogram())
800 return getOrCreateSubprogramDIE(DISubprogram(Context));
802 return getDIE(Context);
805 /// addToContextOwner - Add Die into the list of its context owner's children.
806 void CompileUnit::addToContextOwner(DIE *Die, DIScope Context) {
807 assert(!Die->getParent());
808 if (DIE *ContextDIE = getOrCreateContextDIE(Context)) {
809 if (Die->getParent()) {
810 // While creating the context, if this is a type member, we will have
811 // added the child to the context already.
812 assert(Die->getParent() == ContextDIE);
815 ContextDIE->addChild(Die);
820 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
822 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
826 DIE *TyDIE = getDIE(Ty);
831 TyDIE = new DIE(Ty.getTag());
832 insertDIE(Ty, TyDIE);
833 if (Ty.isBasicType())
834 constructTypeDIE(*TyDIE, DIBasicType(Ty));
835 else if (Ty.isCompositeType())
836 constructTypeDIE(*TyDIE, DICompositeType(Ty));
838 assert(Ty.isDerivedType() && "Unknown kind of DIType");
839 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
841 // If this is a named finished type then include it in the list of types
842 // for the accelerator tables.
843 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
844 bool IsImplementation = 0;
845 if (Ty.isCompositeType()) {
846 DICompositeType CT(Ty);
847 // A runtime language of 0 actually means C/C++ and that any
848 // non-negative value is some version of Objective-C/C++.
849 IsImplementation = (CT.getRunTimeLang() == 0) ||
850 CT.isObjcClassComplete();
852 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
853 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
856 addToContextOwner(TyDIE, resolve(Ty.getContext()));
860 /// addType - Add a new type attribute to the specified entity.
861 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
862 assert(Ty && "Trying to add a type that doesn't exist?");
864 // Check for pre-existence.
865 DIEEntry *Entry = getDIEEntry(Ty);
866 // If it exists then use the existing value.
868 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
873 DIE *Buffer = getOrCreateTypeDIE(Ty);
876 Entry = createDIEEntry(Buffer);
877 insertDIEEntry(Ty, Entry);
878 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
880 // If this is a complete composite type then include it in the
881 // list of global types.
885 // Accelerator table mutators - add each name along with its companion
886 // DIE to the proper table while ensuring that the name that we're going
887 // to reference is in the string table. We do this since the names we
888 // add may not only be identical to the names in the DIE.
889 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
890 DU->getStringPoolEntry(Name);
891 std::vector<DIE *> &DIEs = AccelNames[Name];
895 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
896 DU->getStringPoolEntry(Name);
897 std::vector<DIE *> &DIEs = AccelObjC[Name];
901 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
902 DU->getStringPoolEntry(Name);
903 std::vector<DIE *> &DIEs = AccelNamespace[Name];
907 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
908 DU->getStringPoolEntry(Name);
909 std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
913 /// addGlobalName - Add a new global name to the compile unit.
914 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
915 std::string ContextString = getParentContextString(Context);
916 std::string FullName = ContextString + Name.str();
917 GlobalNames[FullName] = Die;
920 /// addGlobalType - Add a new global type to the compile unit.
922 void CompileUnit::addGlobalType(DIType Ty) {
923 DIScope Context = resolve(Ty.getContext());
924 if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
925 (!Context || Context.isCompileUnit() || Context.isFile() ||
926 Context.isNameSpace()))
927 if (DIEEntry *Entry = getDIEEntry(Ty)) {
928 std::string ContextString = getParentContextString(Context);
929 std::string FullName = ContextString + Ty.getName().str();
930 GlobalTypes[FullName] = Entry->getEntry();
934 /// getParentContextString - Walks the metadata parent chain in a language
935 /// specific manner (using the compile unit language) and returns
936 /// it as a string. This is done at the metadata level because DIEs may
937 /// not currently have been added to the parent context and walking the
938 /// DIEs looking for names is more expensive than walking the metadata.
939 std::string CompileUnit::getParentContextString(DIScope Context) const {
943 // FIXME: Decide whether to implement this for non-C++ languages.
944 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
948 SmallVector<DIScope, 1> Parents;
949 while (!Context.isCompileUnit()) {
950 Parents.push_back(Context);
951 if (Context.getContext())
952 Context = resolve(Context.getContext());
954 // Structure, etc types will have a NULL context if they're at the top
959 // Reverse iterate over our list to go from the outermost construct to the
961 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
965 StringRef Name = Ctx.getName();
974 /// addPubTypes - Add subprogram argument types for pubtypes section.
975 void CompileUnit::addPubTypes(DISubprogram SP) {
976 DICompositeType SPTy = SP.getType();
977 uint16_t SPTag = SPTy.getTag();
978 if (SPTag != dwarf::DW_TAG_subroutine_type)
981 DIArray Args = SPTy.getTypeArray();
982 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
983 DIType ATy(Args.getElement(i));
990 /// constructTypeDIE - Construct basic type die from DIBasicType.
991 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
992 // Get core information.
993 StringRef Name = BTy.getName();
994 // Add name if not anonymous or intermediate type.
996 addString(&Buffer, dwarf::DW_AT_name, Name);
998 // An unspecified type only has a name attribute.
999 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1002 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1005 uint64_t Size = BTy.getSizeInBits() >> 3;
1006 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1009 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1010 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1011 // Get core information.
1012 StringRef Name = DTy.getName();
1013 uint64_t Size = DTy.getSizeInBits() >> 3;
1014 uint16_t Tag = Buffer.getTag();
1016 // Map to main type, void will not have a type.
1017 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1019 addType(&Buffer, FromTy);
1021 // Add name if not anonymous or intermediate type.
1023 addString(&Buffer, dwarf::DW_AT_name, Name);
1025 // Add size if non-zero (derived types might be zero-sized.)
1026 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1027 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1029 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1030 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1031 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1032 // Add source line info if available and TyDesc is not a forward declaration.
1033 if (!DTy.isForwardDecl())
1034 addSourceLine(&Buffer, DTy);
1037 /// Return true if the type is appropriately scoped to be contained inside
1038 /// its own type unit.
1039 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1040 DIScope Parent = DD->resolve(Ty.getContext());
1042 // Don't generate a hash for anything scoped inside a function.
1043 if (Parent.isSubprogram())
1045 Parent = DD->resolve(Parent.getContext());
1050 /// Return true if the type should be split out into a type unit.
1051 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1052 uint16_t Tag = CTy.getTag();
1055 case dwarf::DW_TAG_structure_type:
1056 case dwarf::DW_TAG_union_type:
1057 case dwarf::DW_TAG_enumeration_type:
1058 case dwarf::DW_TAG_class_type:
1059 // If this is a class, structure, union, or enumeration type
1060 // that is a definition (not a declaration), and not scoped
1061 // inside a function then separate this out as a type unit.
1062 return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1068 /// constructTypeDIE - Construct type DIE from DICompositeType.
1069 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1070 // Get core information.
1071 StringRef Name = CTy.getName();
1073 uint64_t Size = CTy.getSizeInBits() >> 3;
1074 uint16_t Tag = Buffer.getTag();
1077 case dwarf::DW_TAG_array_type:
1078 constructArrayTypeDIE(Buffer, &CTy);
1080 case dwarf::DW_TAG_enumeration_type: {
1081 DIArray Elements = CTy.getTypeArray();
1083 // Add enumerators to enumeration type.
1084 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1085 DIE *ElemDie = NULL;
1086 DIDescriptor Enum(Elements.getElement(i));
1087 if (Enum.isEnumerator())
1088 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum), Buffer);
1090 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1092 addType(&Buffer, DTy);
1093 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1097 case dwarf::DW_TAG_subroutine_type: {
1098 // Add return type. A void return won't have a type.
1099 DIArray Elements = CTy.getTypeArray();
1100 DIDescriptor RTy = Elements.getElement(0);
1102 addType(&Buffer, DIType(RTy));
1104 bool isPrototyped = true;
1106 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1107 DIDescriptor Ty = Elements.getElement(i);
1108 if (Ty.isUnspecifiedParameter()) {
1109 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1110 Buffer.addChild(Arg);
1111 isPrototyped = false;
1113 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1114 addType(Arg, DIType(Ty));
1115 if (DIType(Ty).isArtificial())
1116 addFlag(Arg, dwarf::DW_AT_artificial);
1117 Buffer.addChild(Arg);
1120 // Add prototype flag if we're dealing with a C language and the
1121 // function has been prototyped.
1122 uint16_t Language = DICompileUnit(Node).getLanguage();
1124 (Language == dwarf::DW_LANG_C89 ||
1125 Language == dwarf::DW_LANG_C99 ||
1126 Language == dwarf::DW_LANG_ObjC))
1127 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1130 case dwarf::DW_TAG_structure_type:
1131 case dwarf::DW_TAG_union_type:
1132 case dwarf::DW_TAG_class_type: {
1133 // Add elements to structure type.
1134 DIArray Elements = CTy.getTypeArray();
1135 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1136 DIDescriptor Element = Elements.getElement(i);
1137 DIE *ElemDie = NULL;
1138 if (Element.isSubprogram()) {
1139 DISubprogram SP(Element);
1140 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1141 if (SP.isProtected())
1142 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1143 dwarf::DW_ACCESS_protected);
1144 else if (SP.isPrivate())
1145 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1146 dwarf::DW_ACCESS_private);
1148 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1149 dwarf::DW_ACCESS_public);
1150 if (SP.isExplicit())
1151 addFlag(ElemDie, dwarf::DW_AT_explicit);
1152 } else if (Element.isDerivedType()) {
1153 DIDerivedType DDTy(Element);
1154 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1155 ElemDie = new DIE(dwarf::DW_TAG_friend);
1156 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1157 dwarf::DW_AT_friend);
1158 Buffer.addChild(ElemDie);
1159 } else if (DDTy.isStaticMember()) {
1160 ElemDie = getOrCreateStaticMemberDIE(DDTy);
1162 ElemDie = createMemberDIE(DDTy, Buffer);
1164 } else if (Element.isObjCProperty()) {
1165 DIObjCProperty Property(Element);
1166 ElemDie = new DIE(Property.getTag());
1167 StringRef PropertyName = Property.getObjCPropertyName();
1168 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1169 addType(ElemDie, Property.getType());
1170 addSourceLine(ElemDie, Property);
1171 StringRef GetterName = Property.getObjCPropertyGetterName();
1172 if (!GetterName.empty())
1173 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1174 StringRef SetterName = Property.getObjCPropertySetterName();
1175 if (!SetterName.empty())
1176 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1177 unsigned PropertyAttributes = 0;
1178 if (Property.isReadOnlyObjCProperty())
1179 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1180 if (Property.isReadWriteObjCProperty())
1181 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1182 if (Property.isAssignObjCProperty())
1183 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1184 if (Property.isRetainObjCProperty())
1185 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1186 if (Property.isCopyObjCProperty())
1187 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1188 if (Property.isNonAtomicObjCProperty())
1189 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1190 if (PropertyAttributes)
1191 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1192 PropertyAttributes);
1194 DIEEntry *Entry = getDIEEntry(Element);
1196 Entry = createDIEEntry(ElemDie);
1197 insertDIEEntry(Element, Entry);
1199 Buffer.addChild(ElemDie);
1204 if (CTy.isAppleBlockExtension())
1205 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1207 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1208 if (DIDescriptor(ContainingType).isCompositeType())
1209 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1210 getOrCreateTypeDIE(DIType(ContainingType)));
1212 if (CTy.isObjcClassComplete())
1213 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1215 // Add template parameters to a class, structure or union types.
1216 // FIXME: The support isn't in the metadata for this yet.
1217 if (Tag == dwarf::DW_TAG_class_type ||
1218 Tag == dwarf::DW_TAG_structure_type ||
1219 Tag == dwarf::DW_TAG_union_type)
1220 addTemplateParams(Buffer, CTy.getTemplateParams());
1228 // Add name if not anonymous or intermediate type.
1230 addString(&Buffer, dwarf::DW_AT_name, Name);
1232 if (Tag == dwarf::DW_TAG_enumeration_type ||
1233 Tag == dwarf::DW_TAG_class_type ||
1234 Tag == dwarf::DW_TAG_structure_type ||
1235 Tag == dwarf::DW_TAG_union_type) {
1236 // Add size if non-zero (derived types might be zero-sized.)
1237 // TODO: Do we care about size for enum forward declarations?
1239 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1240 else if (!CTy.isForwardDecl())
1241 // Add zero size if it is not a forward declaration.
1242 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1244 // If we're a forward decl, say so.
1245 if (CTy.isForwardDecl())
1246 addFlag(&Buffer, dwarf::DW_AT_declaration);
1248 // Add source line info if available.
1249 if (!CTy.isForwardDecl())
1250 addSourceLine(&Buffer, CTy);
1252 // No harm in adding the runtime language to the declaration.
1253 unsigned RLang = CTy.getRunTimeLang();
1255 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1256 dwarf::DW_FORM_data1, RLang);
1258 // If this is a type applicable to a type unit it then add it to the
1259 // list of types we'll compute a hash for later.
1260 if (shouldCreateTypeUnit(CTy, DD))
1261 DD->addTypeUnitType(&Buffer);
1264 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1265 /// for the given DITemplateTypeParameter.
1267 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP,
1269 DIE *ParamDIE = getDIE(TP);
1273 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1274 Buffer.addChild(ParamDIE);
1275 // Add the type if it exists, it could be void and therefore no type.
1277 addType(ParamDIE, resolve(TP.getType()));
1278 if (!TP.getName().empty())
1279 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1283 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1284 /// for the given DITemplateValueParameter.
1286 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP,
1288 DIE *ParamDIE = getDIE(VP);
1292 ParamDIE = new DIE(VP.getTag());
1293 Buffer.addChild(ParamDIE);
1295 // Add the type if there is one, template template and template parameter
1296 // packs will not have a type.
1298 addType(ParamDIE, resolve(VP.getType()));
1299 if (!VP.getName().empty())
1300 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1301 if (Value *Val = VP.getValue()) {
1302 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1303 addConstantValue(ParamDIE, CI,
1304 isUnsignedDIType(DD, resolve(VP.getType())));
1305 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1306 // For declaration non-type template parameters (such as global values and
1308 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1309 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1310 // Emit DW_OP_stack_value to use the address as the immediate value of the
1311 // parameter, rather than a pointer to it.
1312 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1313 addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1314 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1315 assert(isa<MDString>(Val));
1316 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1317 cast<MDString>(Val)->getString());
1318 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1319 assert(isa<MDNode>(Val));
1320 DIArray A(cast<MDNode>(Val));
1321 addTemplateParams(*ParamDIE, A);
1328 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1329 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1330 DIE *NDie = getDIE(NS);
1333 NDie = new DIE(dwarf::DW_TAG_namespace);
1334 insertDIE(NS, NDie);
1335 if (!NS.getName().empty()) {
1336 addString(NDie, dwarf::DW_AT_name, NS.getName());
1337 addAccelNamespace(NS.getName(), NDie);
1338 addGlobalName(NS.getName(), NDie, NS.getContext());
1340 addAccelNamespace("(anonymous namespace)", NDie);
1341 addSourceLine(NDie, NS);
1342 addToContextOwner(NDie, NS.getContext());
1346 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1347 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1348 // Construct the context before querying for the existence of the DIE in case
1349 // such construction creates the DIE (as is the case for member function
1351 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1353 ContextDIE = CUDie.get();
1355 DIE *SPDie = getDIE(SP);
1359 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1361 // DW_TAG_inlined_subroutine may refer to this DIE.
1362 insertDIE(SP, SPDie);
1364 DISubprogram SPDecl = SP.getFunctionDeclaration();
1365 DIE *DeclDie = NULL;
1366 if (SPDecl.isSubprogram()) {
1367 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1370 // Add function template parameters.
1371 addTemplateParams(*SPDie, SP.getTemplateParams());
1373 // If this DIE is going to refer declaration info using AT_specification
1374 // then there is no need to add other attributes.
1376 // Refer function declaration directly.
1377 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1379 // Add subprogram definitions to the CU die directly.
1385 // Add to context owner.
1386 ContextDIE->addChild(SPDie);
1388 // Add the linkage name if we have one.
1389 StringRef LinkageName = SP.getLinkageName();
1390 if (!LinkageName.empty())
1391 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1392 GlobalValue::getRealLinkageName(LinkageName));
1394 // Constructors and operators for anonymous aggregates do not have names.
1395 if (!SP.getName().empty())
1396 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1398 addSourceLine(SPDie, SP);
1400 // Add the prototype if we have a prototype and we have a C like
1402 uint16_t Language = DICompileUnit(Node).getLanguage();
1403 if (SP.isPrototyped() &&
1404 (Language == dwarf::DW_LANG_C89 ||
1405 Language == dwarf::DW_LANG_C99 ||
1406 Language == dwarf::DW_LANG_ObjC))
1407 addFlag(SPDie, dwarf::DW_AT_prototyped);
1409 // Add Return Type. A void return type will not have a type.
1410 DICompositeType SPTy = SP.getType();
1411 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1412 "the type of a subprogram should be a subroutine");
1414 DIArray Args = SPTy.getTypeArray();
1415 if (Args.getElement(0))
1416 addType(SPDie, DIType(Args.getElement(0)));
1418 unsigned VK = SP.getVirtuality();
1420 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1421 DIEBlock *Block = getDIEBlock();
1422 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1423 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1424 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1425 ContainingTypeMap.insert(std::make_pair(SPDie,
1426 resolve(SP.getContainingType())));
1429 if (!SP.isDefinition()) {
1430 addFlag(SPDie, dwarf::DW_AT_declaration);
1432 // Add arguments. Do not add arguments for subprogram definition. They will
1433 // be handled while processing variables.
1434 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1435 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1436 DIType ATy = DIType(Args.getElement(i));
1438 if (ATy.isArtificial())
1439 addFlag(Arg, dwarf::DW_AT_artificial);
1440 SPDie->addChild(Arg);
1444 if (SP.isArtificial())
1445 addFlag(SPDie, dwarf::DW_AT_artificial);
1447 if (!SP.isLocalToUnit())
1448 addFlag(SPDie, dwarf::DW_AT_external);
1450 if (SP.isOptimized())
1451 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1453 if (unsigned isa = Asm->getISAEncoding()) {
1454 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1460 // Return const expression if value is a GEP to access merged global
1462 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1463 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1464 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1465 if (!CE || CE->getNumOperands() != 3 ||
1466 CE->getOpcode() != Instruction::GetElementPtr)
1469 // First operand points to a global struct.
1470 Value *Ptr = CE->getOperand(0);
1471 if (!isa<GlobalValue>(Ptr) ||
1472 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1475 // Second operand is zero.
1476 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1477 if (!CI || !CI->isZero())
1480 // Third operand is offset.
1481 if (!isa<ConstantInt>(CE->getOperand(2)))
1487 /// createGlobalVariableDIE - create global variable DIE.
1488 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1489 // Check for pre-existence.
1493 DIGlobalVariable GV(N);
1494 if (!GV.isGlobalVariable())
1497 DIScope GVContext = GV.getContext();
1498 DIType GTy = GV.getType();
1500 // If this is a static data member definition, some attributes belong
1501 // to the declaration DIE.
1502 DIE *VariableDIE = NULL;
1503 bool IsStaticMember = false;
1504 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1505 if (SDMDecl.Verify()) {
1506 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1507 // We need the declaration DIE that is in the static member's class.
1508 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1509 IsStaticMember = true;
1512 // If this is not a static data member definition, create the variable
1513 // DIE and add the initial set of attributes to it.
1515 VariableDIE = new DIE(GV.getTag());
1517 insertDIE(N, VariableDIE);
1519 // Add name and type.
1520 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1521 addType(VariableDIE, GTy);
1523 // Add scoping info.
1524 if (!GV.isLocalToUnit())
1525 addFlag(VariableDIE, dwarf::DW_AT_external);
1527 // Add line number info.
1528 addSourceLine(VariableDIE, GV);
1529 // Add to context owner.
1530 addToContextOwner(VariableDIE, GVContext);
1534 bool addToAccelTable = false;
1535 DIE *VariableSpecDIE = NULL;
1536 bool isGlobalVariable = GV.getGlobal() != NULL;
1537 if (isGlobalVariable) {
1538 addToAccelTable = true;
1539 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1540 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1541 if (GV.getGlobal()->isThreadLocal()) {
1542 // FIXME: Make this work with -gsplit-dwarf.
1543 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1544 assert((PointerSize == 4 || PointerSize == 8) &&
1545 "Add support for other sizes if necessary");
1546 const MCExpr *Expr =
1547 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1548 // Based on GCC's support for TLS:
1549 if (!DD->useSplitDwarf()) {
1550 // 1) Start with a constNu of the appropriate pointer size
1551 addUInt(Block, 0, dwarf::DW_FORM_data1,
1552 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1553 // 2) containing the (relocated) offset of the TLS variable
1554 // within the module's TLS block.
1555 addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1557 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1558 addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1560 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1561 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
1563 addOpAddress(Block, Sym);
1564 // Do not create specification DIE if context is either compile unit
1566 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1567 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1568 // Create specification DIE.
1569 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1570 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1571 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1572 // A static member's declaration is already flagged as such.
1573 if (!SDMDecl.Verify())
1574 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1575 addDie(VariableSpecDIE);
1577 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1579 // Add the linkage name.
1580 StringRef LinkageName = GV.getLinkageName();
1581 if (!LinkageName.empty())
1582 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1583 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1585 addString(IsStaticMember && VariableSpecDIE ?
1586 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1587 GlobalValue::getRealLinkageName(LinkageName));
1588 } else if (const ConstantInt *CI =
1589 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1590 // AT_const_value was added when the static member was created. To avoid
1591 // emitting AT_const_value multiple times, we only add AT_const_value when
1592 // it is not a static member.
1593 if (!IsStaticMember)
1594 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1595 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1596 addToAccelTable = true;
1597 // GV is a merged global.
1598 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1599 Value *Ptr = CE->getOperand(0);
1600 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1601 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1602 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1603 addUInt(Block, 0, dwarf::DW_FORM_udata,
1604 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1605 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1606 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1609 if (addToAccelTable) {
1610 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1611 addAccelName(GV.getName(), AddrDIE);
1613 // If the linkage name is different than the name, go ahead and output
1614 // that as well into the name table.
1615 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1616 addAccelName(GV.getLinkageName(), AddrDIE);
1619 if (!GV.isLocalToUnit())
1620 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1624 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1625 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1627 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1628 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1630 // The LowerBound value defines the lower bounds which is typically zero for
1631 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1632 // Count == -1 then the array is unbounded and we do not emit
1633 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1634 // Count == 0, then the array has zero elements in which case we do not emit
1636 int64_t LowerBound = SR.getLo();
1637 int64_t DefaultLowerBound = getDefaultLowerBound();
1638 int64_t Count = SR.getCount();
1640 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1641 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1643 if (Count != -1 && Count != 0)
1644 // FIXME: An unbounded array should reference the expression that defines
1646 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1648 Buffer.addChild(DW_Subrange);
1651 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1652 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1653 DICompositeType *CTy) {
1654 if (CTy->isVector())
1655 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1657 // Emit the element type.
1658 addType(&Buffer, resolve(CTy->getTypeDerivedFrom()));
1660 // Get an anonymous type for index type.
1661 // FIXME: This type should be passed down from the front end
1662 // as different languages may have different sizes for indexes.
1663 DIE *IdxTy = getIndexTyDie();
1665 // Construct an anonymous type for index type.
1666 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1667 addString(IdxTy, dwarf::DW_AT_name, "int");
1668 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1669 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1670 dwarf::DW_ATE_signed);
1672 setIndexTyDie(IdxTy);
1675 // Add subranges to array type.
1676 DIArray Elements = CTy->getTypeArray();
1677 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1678 DIDescriptor Element = Elements.getElement(i);
1679 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1680 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1684 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1685 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy, DIE &Buffer) {
1686 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1687 Buffer.addChild(Enumerator);
1688 StringRef Name = ETy.getName();
1689 addString(Enumerator, dwarf::DW_AT_name, Name);
1690 int64_t Value = ETy.getEnumValue();
1691 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1695 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1697 void CompileUnit::constructContainingTypeDIEs() {
1698 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1699 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1700 DIE *SPDie = CI->first;
1701 const MDNode *N = CI->second;
1703 DIE *NDie = getDIE(N);
1704 if (!NDie) continue;
1705 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1709 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1710 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1711 bool isScopeAbstract) {
1712 StringRef Name = DV->getName();
1714 // Define variable debug information entry.
1715 DIE *VariableDie = new DIE(DV->getTag());
1716 DbgVariable *AbsVar = DV->getAbstractVariable();
1717 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1719 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1722 addString(VariableDie, dwarf::DW_AT_name, Name);
1723 addSourceLine(VariableDie, DV->getVariable());
1724 addType(VariableDie, DV->getType());
1727 if (DV->isArtificial())
1728 addFlag(VariableDie, dwarf::DW_AT_artificial);
1730 if (isScopeAbstract) {
1731 DV->setDIE(VariableDie);
1735 // Add variable address.
1737 unsigned Offset = DV->getDotDebugLocOffset();
1738 if (Offset != ~0U) {
1739 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1740 Asm->GetTempSymbol("debug_loc", Offset));
1741 DV->setDIE(VariableDie);
1745 // Check if variable is described by a DBG_VALUE instruction.
1746 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1747 assert(DVInsn->getNumOperands() == 3);
1748 if (DVInsn->getOperand(0).isReg()) {
1749 const MachineOperand RegOp = DVInsn->getOperand(0);
1750 // If the second operand is an immediate, this is an indirect value.
1751 if (DVInsn->getOperand(1).isImm()) {
1752 MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1753 addVariableAddress(*DV, VariableDie, Location);
1754 } else if (RegOp.getReg())
1755 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1756 } else if (DVInsn->getOperand(0).isImm())
1757 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1758 else if (DVInsn->getOperand(0).isFPImm())
1759 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1760 else if (DVInsn->getOperand(0).isCImm())
1761 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1762 isUnsignedDIType(DD, DV->getType()));
1764 DV->setDIE(VariableDie);
1767 // .. else use frame index.
1768 int FI = DV->getFrameIndex();
1770 unsigned FrameReg = 0;
1771 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1773 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1774 MachineLocation Location(FrameReg, Offset);
1775 addVariableAddress(*DV, VariableDie, Location);
1779 DV->setDIE(VariableDie);
1783 /// createMemberDIE - Create new member DIE.
1784 DIE *CompileUnit::createMemberDIE(DIDerivedType DT, DIE &Buffer) {
1785 DIE *MemberDie = new DIE(DT.getTag());
1786 Buffer.addChild(MemberDie);
1787 StringRef Name = DT.getName();
1789 addString(MemberDie, dwarf::DW_AT_name, Name);
1791 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1793 addSourceLine(MemberDie, DT);
1795 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1796 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1798 uint64_t Size = DT.getSizeInBits();
1799 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1801 if (Size != FieldSize) {
1803 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0,
1804 getBaseTypeSize(DD, DT)>>3);
1805 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1807 uint64_t Offset = DT.getOffsetInBits();
1808 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1809 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1810 uint64_t FieldOffset = (HiMark - FieldSize);
1811 Offset -= FieldOffset;
1813 // Maybe we need to work from the other end.
1814 if (Asm->getDataLayout().isLittleEndian())
1815 Offset = FieldSize - (Offset + Size);
1816 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1818 // Here WD_AT_data_member_location points to the anonymous
1819 // field that includes this bit field.
1820 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1823 // This is not a bitfield.
1824 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1826 if (DT.getTag() == dwarf::DW_TAG_inheritance
1827 && DT.isVirtual()) {
1829 // For C++, virtual base classes are not at fixed offset. Use following
1830 // expression to extract appropriate offset from vtable.
1831 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1833 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1834 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1835 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1836 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1837 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1838 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1839 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1840 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1842 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1845 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1847 if (DT.isProtected())
1848 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1849 dwarf::DW_ACCESS_protected);
1850 else if (DT.isPrivate())
1851 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1852 dwarf::DW_ACCESS_private);
1853 // Otherwise C++ member and base classes are considered public.
1855 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1856 dwarf::DW_ACCESS_public);
1858 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1859 dwarf::DW_VIRTUALITY_virtual);
1861 // Objective-C properties.
1862 if (MDNode *PNode = DT.getObjCProperty())
1863 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1864 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1867 if (DT.isArtificial())
1868 addFlag(MemberDie, dwarf::DW_AT_artificial);
1873 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1874 DIE *CompileUnit::getOrCreateStaticMemberDIE(const DIDerivedType DT) {
1878 // Construct the context before querying for the existence of the DIE in case
1879 // such construction creates the DIE.
1880 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1881 assert(ContextDIE && "Static member should belong to a non-CU context.");
1883 DIE *StaticMemberDIE = getDIE(DT);
1884 if (StaticMemberDIE)
1885 return StaticMemberDIE;
1887 StaticMemberDIE = new DIE(DT.getTag());
1888 // Add to context owner.
1889 ContextDIE->addChild(StaticMemberDIE);
1891 DIType Ty = resolve(DT.getTypeDerivedFrom());
1893 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1894 addType(StaticMemberDIE, Ty);
1895 addSourceLine(StaticMemberDIE, DT);
1896 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1897 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1899 // FIXME: We could omit private if the parent is a class_type, and
1900 // public if the parent is something else.
1901 if (DT.isProtected())
1902 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1903 dwarf::DW_ACCESS_protected);
1904 else if (DT.isPrivate())
1905 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1906 dwarf::DW_ACCESS_private);
1908 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1909 dwarf::DW_ACCESS_public);
1911 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1912 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1913 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1914 addConstantFPValue(StaticMemberDIE, CFP);
1916 insertDIE(DT, StaticMemberDIE);
1917 return StaticMemberDIE;