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, uint16_t Form,
111 Form = DIEInteger::BestForm(false, Integer);
112 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
114 Die->addValue(Attribute, Form, Value);
117 /// addSInt - Add an signed integer attribute data and value.
119 void CompileUnit::addSInt(DIE *Die, uint16_t Attribute, uint16_t Form,
122 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, uint16_t Attribute, StringRef String) {
135 if (!DD->useSplitDwarf()) {
136 MCSymbol *Symb = DU->getStringPoolEntry(String);
137 if (Asm->needsRelocationsForDwarfStringPool())
138 Value = new (DIEValueAllocator) DIELabel(Symb);
140 MCSymbol *StringPool = DU->getStringPoolSym();
141 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
143 Form = dwarf::DW_FORM_strp;
145 unsigned idx = DU->getStringPoolIndex(String);
146 Value = new (DIEValueAllocator) DIEInteger(idx);
147 Form = dwarf::DW_FORM_GNU_str_index;
149 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
150 Die->addValue(Attribute, Form, Str);
153 /// addLocalString - Add a string attribute data and value. This is guaranteed
154 /// to be in the local string pool instead of indirected.
155 void CompileUnit::addLocalString(DIE *Die, uint16_t Attribute,
157 MCSymbol *Symb = DU->getStringPoolEntry(String);
159 if (Asm->needsRelocationsForDwarfStringPool())
160 Value = new (DIEValueAllocator) DIELabel(Symb);
162 MCSymbol *StringPool = DU->getStringPoolSym();
163 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
165 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
168 /// addExpr - Add a Dwarf expression attribute data and value.
170 void CompileUnit::addExpr(DIE *Die, uint16_t Attribute, uint16_t Form,
171 const MCExpr *Expr) {
172 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
173 Die->addValue(Attribute, Form, Value);
176 /// addLabel - Add a Dwarf label attribute data and value.
178 void CompileUnit::addLabel(DIE *Die, uint16_t Attribute, uint16_t Form,
179 const MCSymbol *Label) {
180 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
181 Die->addValue(Attribute, Form, Value);
184 /// addLabelAddress - Add a dwarf label attribute data and value using
185 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
187 void CompileUnit::addLabelAddress(DIE *Die, uint16_t Attribute,
190 DD->addArangeLabel(SymbolCU(this, Label));
192 if (!DD->useSplitDwarf()) {
194 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
195 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
197 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
198 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
201 unsigned idx = DU->getAddrPoolIndex(Label);
202 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
203 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
207 /// addOpAddress - Add a dwarf op address data and value using the
208 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
210 void CompileUnit::addOpAddress(DIE *Die, const MCSymbol *Sym) {
211 DD->addArangeLabel(SymbolCU(this, Sym));
212 if (!DD->useSplitDwarf()) {
213 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
214 addLabel(Die, 0, dwarf::DW_FORM_udata, Sym);
216 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
217 addUInt(Die, 0, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
221 /// addDelta - Add a label delta attribute data and value.
223 void CompileUnit::addDelta(DIE *Die, uint16_t Attribute, uint16_t Form,
224 const MCSymbol *Hi, const MCSymbol *Lo) {
225 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
226 Die->addValue(Attribute, Form, Value);
229 /// addDIEEntry - Add a DIE attribute data and value.
231 void CompileUnit::addDIEEntry(DIE *Die, uint16_t Attribute, DIE *Entry) {
232 // We currently only use ref4.
233 Die->addValue(Attribute, dwarf::DW_FORM_ref4, createDIEEntry(Entry));
236 /// addBlock - Add block data.
238 void CompileUnit::addBlock(DIE *Die, uint16_t Attribute, uint16_t Form,
240 Block->ComputeSize(Asm);
241 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
242 Die->addValue(Attribute, Block->BestForm(), Block);
245 /// addSourceLine - Add location information to specified debug information
247 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
252 unsigned Line = V.getLineNumber();
256 DD->getOrCreateSourceID(V.getContext().getFilename(),
257 V.getContext().getDirectory(), getUniqueID());
258 assert(FileID && "Invalid file id");
259 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
260 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
263 /// addSourceLine - Add location information to specified debug information
265 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
266 // Verify global variable.
267 if (!G.isGlobalVariable())
270 unsigned Line = G.getLineNumber();
274 DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
275 assert(FileID && "Invalid file id");
276 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
277 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
280 /// addSourceLine - Add location information to specified debug information
282 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
283 // Verify subprogram.
284 if (!SP.isSubprogram())
287 // If the line number is 0, don't add it.
288 unsigned Line = SP.getLineNumber();
292 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
294 assert(FileID && "Invalid file id");
295 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
296 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
299 /// addSourceLine - Add location information to specified debug information
301 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
306 unsigned Line = Ty.getLineNumber();
309 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
311 assert(FileID && "Invalid file id");
312 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
313 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
316 /// addSourceLine - Add location information to specified debug information
318 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
320 if (!Ty.isObjCProperty())
323 unsigned Line = Ty.getLineNumber();
326 DIFile File = Ty.getFile();
327 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
328 File.getDirectory(), getUniqueID());
329 assert(FileID && "Invalid file id");
330 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
331 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
334 /// addSourceLine - Add location information to specified debug information
336 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
341 unsigned Line = NS.getLineNumber();
344 StringRef FN = NS.getFilename();
347 DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
348 assert(FileID && "Invalid file id");
349 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
350 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
353 /// addVariableAddress - Add DW_AT_location attribute for a
354 /// DbgVariable based on provided MachineLocation.
355 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
356 MachineLocation Location) {
357 if (DV.variableHasComplexAddress())
358 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
359 else if (DV.isBlockByrefVariable())
360 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
362 addAddress(Die, dwarf::DW_AT_location, Location,
363 DV.getVariable().isIndirect());
366 /// addRegisterOp - Add register operand.
367 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
368 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
369 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
371 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
373 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
374 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
378 /// addRegisterOffset - Add register offset.
379 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg, int64_t Offset) {
380 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
381 unsigned DWReg = RI->getDwarfRegNum(Reg, false);
382 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
383 if (Reg == TRI->getFrameRegister(*Asm->MF))
384 // If variable offset is based in frame register then use fbreg.
385 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
387 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
389 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
390 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
392 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
395 /// addAddress - Add an address attribute to a die based on the location
397 void CompileUnit::addAddress(DIE *Die, uint16_t Attribute,
398 const MachineLocation &Location, bool Indirect) {
399 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
401 if (Location.isReg() && !Indirect)
402 addRegisterOp(Block, Location.getReg());
404 addRegisterOffset(Block, Location.getReg(), Location.getOffset());
405 if (Indirect && !Location.isReg()) {
406 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
410 // Now attach the location information to the DIE.
411 addBlock(Die, Attribute, 0, Block);
414 /// addComplexAddress - Start with the address based on the location provided,
415 /// and generate the DWARF information necessary to find the actual variable
416 /// given the extra address information encoded in the DIVariable, starting from
417 /// the starting location. Add the DWARF information to the die.
419 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
421 const MachineLocation &Location) {
422 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
423 unsigned N = DV.getNumAddrElements();
425 if (Location.isReg()) {
426 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
427 // If first address element is OpPlus then emit
428 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
429 addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
432 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);
445 llvm_unreachable("unknown DIBuilder Opcode");
448 // Now attach the location information to the DIE.
449 addBlock(Die, Attribute, 0, Block);
452 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
453 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
454 gives the variable VarName either the struct, or a pointer to the struct, as
455 its type. This is necessary for various behind-the-scenes things the
456 compiler needs to do with by-reference variables in Blocks.
458 However, as far as the original *programmer* is concerned, the variable
459 should still have type 'SomeType', as originally declared.
461 The function getBlockByrefType dives into the __Block_byref_x_VarName
462 struct to find the original type of the variable, which is then assigned to
463 the variable's Debug Information Entry as its real type. So far, so good.
464 However now the debugger will expect the variable VarName to have the type
465 SomeType. So we need the location attribute for the variable to be an
466 expression that explains to the debugger how to navigate through the
467 pointers and struct to find the actual variable of type SomeType.
469 The following function does just that. We start by getting
470 the "normal" location for the variable. This will be the location
471 of either the struct __Block_byref_x_VarName or the pointer to the
472 struct __Block_byref_x_VarName.
474 The struct will look something like:
476 struct __Block_byref_x_VarName {
478 struct __Block_byref_x_VarName *forwarding;
479 ... <various other fields>
481 ... <maybe more fields>
484 If we are given the struct directly (as our starting point) we
485 need to tell the debugger to:
487 1). Add the offset of the forwarding field.
489 2). Follow that pointer to get the real __Block_byref_x_VarName
490 struct to use (the real one may have been copied onto the heap).
492 3). Add the offset for the field VarName, to find the actual variable.
494 If we started with a pointer to the struct, then we need to
495 dereference that pointer first, before the other steps.
496 Translating this into DWARF ops, we will need to append the following
497 to the current location description for the variable:
499 DW_OP_deref -- optional, if we start with a pointer
500 DW_OP_plus_uconst <forward_fld_offset>
502 DW_OP_plus_uconst <varName_fld_offset>
504 That is what this function does. */
506 /// addBlockByrefAddress - Start with the address based on the location
507 /// provided, and generate the DWARF information necessary to find the
508 /// actual Block variable (navigating the Block struct) based on the
509 /// starting location. Add the DWARF information to the die. For
510 /// more information, read large comment just above here.
512 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
514 const MachineLocation &Location) {
515 DIType Ty = DV.getType();
517 uint16_t Tag = Ty.getTag();
518 bool isPointer = false;
520 StringRef varName = DV.getName();
522 if (Tag == dwarf::DW_TAG_pointer_type) {
523 DIDerivedType DTy = DIDerivedType(Ty);
524 TmpTy = resolve(DTy.getTypeDerivedFrom());
528 DICompositeType blockStruct = DICompositeType(TmpTy);
530 // Find the __forwarding field and the variable field in the __Block_byref
532 DIArray Fields = blockStruct.getTypeArray();
533 DIDescriptor varField = DIDescriptor();
534 DIDescriptor forwardingField = DIDescriptor();
536 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
537 DIDescriptor Element = Fields.getElement(i);
538 DIDerivedType DT = DIDerivedType(Element);
539 StringRef fieldName = DT.getName();
540 if (fieldName == "__forwarding")
541 forwardingField = Element;
542 else if (fieldName == varName)
546 // Get the offsets for the forwarding field and the variable field.
547 unsigned forwardingFieldOffset =
548 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
549 unsigned varFieldOffset = 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(DITemplateTypeParameter(Element),
787 else if (Element.isTemplateValueParameter())
788 getOrCreateTemplateValueParameterDIE(DITemplateValueParameter(Element),
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) || CT.isObjcClassComplete();
851 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
852 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
855 addToContextOwner(TyDIE, resolve(Ty.getContext()));
859 /// addType - Add a new type attribute to the specified entity.
860 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
861 assert(Ty && "Trying to add a type that doesn't exist?");
863 // Check for pre-existence.
864 DIEEntry *Entry = getDIEEntry(Ty);
865 // If it exists then use the existing value.
867 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
872 DIE *Buffer = getOrCreateTypeDIE(Ty);
875 Entry = createDIEEntry(Buffer);
876 insertDIEEntry(Ty, Entry);
877 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
879 // If this is a complete composite type then include it in the
880 // list of global types.
884 // Accelerator table mutators - add each name along with its companion
885 // DIE to the proper table while ensuring that the name that we're going
886 // to reference is in the string table. We do this since the names we
887 // add may not only be identical to the names in the DIE.
888 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
889 DU->getStringPoolEntry(Name);
890 std::vector<DIE *> &DIEs = AccelNames[Name];
894 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
895 DU->getStringPoolEntry(Name);
896 std::vector<DIE *> &DIEs = AccelObjC[Name];
900 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
901 DU->getStringPoolEntry(Name);
902 std::vector<DIE *> &DIEs = AccelNamespace[Name];
906 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
907 DU->getStringPoolEntry(Name);
908 std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
912 /// addGlobalName - Add a new global name to the compile unit.
913 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
914 std::string FullName = getParentContextString(Context) + Name.str();
915 GlobalNames[FullName] = Die;
918 /// addGlobalType - Add a new global type to the compile unit.
920 void CompileUnit::addGlobalType(DIType Ty) {
921 DIScope Context = resolve(Ty.getContext());
922 if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
923 (!Context || Context.isCompileUnit() || Context.isFile() ||
924 Context.isNameSpace()))
925 if (DIEEntry *Entry = getDIEEntry(Ty)) {
926 std::string FullName =
927 getParentContextString(Context) + Ty.getName().str();
928 GlobalTypes[FullName] = Entry->getEntry();
932 /// getParentContextString - Walks the metadata parent chain in a language
933 /// specific manner (using the compile unit language) and returns
934 /// it as a string. This is done at the metadata level because DIEs may
935 /// not currently have been added to the parent context and walking the
936 /// DIEs looking for names is more expensive than walking the metadata.
937 std::string CompileUnit::getParentContextString(DIScope Context) const {
941 // FIXME: Decide whether to implement this for non-C++ languages.
942 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
946 SmallVector<DIScope, 1> Parents;
947 while (!Context.isCompileUnit()) {
948 Parents.push_back(Context);
949 if (Context.getContext())
950 Context = resolve(Context.getContext());
952 // Structure, etc types will have a NULL context if they're at the top
957 // Reverse iterate over our list to go from the outermost construct to the
959 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
963 StringRef Name = Ctx.getName();
972 /// addPubTypes - Add subprogram argument types for pubtypes section.
973 void CompileUnit::addPubTypes(DISubprogram SP) {
974 DICompositeType SPTy = SP.getType();
975 uint16_t SPTag = SPTy.getTag();
976 if (SPTag != dwarf::DW_TAG_subroutine_type)
979 DIArray Args = SPTy.getTypeArray();
980 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
981 DIType ATy(Args.getElement(i));
988 /// constructTypeDIE - Construct basic type die from DIBasicType.
989 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
990 // Get core information.
991 StringRef Name = BTy.getName();
992 // Add name if not anonymous or intermediate type.
994 addString(&Buffer, dwarf::DW_AT_name, Name);
996 // An unspecified type only has a name attribute.
997 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
1000 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1003 uint64_t Size = BTy.getSizeInBits() >> 3;
1004 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1007 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1008 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1009 // Get core information.
1010 StringRef Name = DTy.getName();
1011 uint64_t Size = DTy.getSizeInBits() >> 3;
1012 uint16_t Tag = Buffer.getTag();
1014 // Map to main type, void will not have a type.
1015 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
1017 addType(&Buffer, FromTy);
1019 // Add name if not anonymous or intermediate type.
1021 addString(&Buffer, dwarf::DW_AT_name, Name);
1023 // Add size if non-zero (derived types might be zero-sized.)
1024 if (Size && Tag != dwarf::DW_TAG_pointer_type)
1025 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1027 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
1028 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1029 getOrCreateTypeDIE(resolve(DTy.getClassType())));
1030 // Add source line info if available and TyDesc is not a forward declaration.
1031 if (!DTy.isForwardDecl())
1032 addSourceLine(&Buffer, DTy);
1035 /// Return true if the type is appropriately scoped to be contained inside
1036 /// its own type unit.
1037 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
1038 DIScope Parent = DD->resolve(Ty.getContext());
1040 // Don't generate a hash for anything scoped inside a function.
1041 if (Parent.isSubprogram())
1043 Parent = DD->resolve(Parent.getContext());
1048 /// Return true if the type should be split out into a type unit.
1049 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
1050 uint16_t Tag = CTy.getTag();
1053 case dwarf::DW_TAG_structure_type:
1054 case dwarf::DW_TAG_union_type:
1055 case dwarf::DW_TAG_enumeration_type:
1056 case dwarf::DW_TAG_class_type:
1057 // If this is a class, structure, union, or enumeration type
1058 // that is a definition (not a declaration), and not scoped
1059 // inside a function then separate this out as a type unit.
1060 return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
1066 /// constructTypeDIE - Construct type DIE from DICompositeType.
1067 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1068 // Get core information.
1069 StringRef Name = CTy.getName();
1071 uint64_t Size = CTy.getSizeInBits() >> 3;
1072 uint16_t Tag = Buffer.getTag();
1075 case dwarf::DW_TAG_array_type:
1076 constructArrayTypeDIE(Buffer, &CTy);
1078 case dwarf::DW_TAG_enumeration_type: {
1079 DIArray Elements = CTy.getTypeArray();
1081 // Add enumerators to enumeration type.
1082 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1083 DIDescriptor Enum(Elements.getElement(i));
1084 if (Enum.isEnumerator())
1085 constructEnumTypeDIE(DIEnumerator(Enum), Buffer);
1087 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1089 addType(&Buffer, DTy);
1090 addFlag(&Buffer, dwarf::DW_AT_enum_class);
1093 case dwarf::DW_TAG_subroutine_type: {
1094 // Add return type. A void return won't have a type.
1095 DIArray Elements = CTy.getTypeArray();
1096 DIDescriptor RTy = Elements.getElement(0);
1098 addType(&Buffer, DIType(RTy));
1100 bool isPrototyped = true;
1102 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1103 DIDescriptor Ty = Elements.getElement(i);
1104 if (Ty.isUnspecifiedParameter()) {
1105 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1106 Buffer.addChild(Arg);
1107 isPrototyped = false;
1109 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1110 addType(Arg, DIType(Ty));
1111 if (DIType(Ty).isArtificial())
1112 addFlag(Arg, dwarf::DW_AT_artificial);
1113 Buffer.addChild(Arg);
1116 // Add prototype flag if we're dealing with a C language and the
1117 // function has been prototyped.
1118 uint16_t Language = DICompileUnit(Node).getLanguage();
1120 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1121 Language == dwarf::DW_LANG_ObjC))
1122 addFlag(&Buffer, dwarf::DW_AT_prototyped);
1124 case dwarf::DW_TAG_structure_type:
1125 case dwarf::DW_TAG_union_type:
1126 case dwarf::DW_TAG_class_type: {
1127 // Add elements to structure type.
1128 DIArray Elements = CTy.getTypeArray();
1129 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1130 DIDescriptor Element = Elements.getElement(i);
1131 DIE *ElemDie = NULL;
1132 if (Element.isSubprogram()) {
1133 DISubprogram SP(Element);
1134 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1135 if (SP.isProtected())
1136 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1137 dwarf::DW_ACCESS_protected);
1138 else if (SP.isPrivate())
1139 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1140 dwarf::DW_ACCESS_private);
1142 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1143 dwarf::DW_ACCESS_public);
1144 if (SP.isExplicit())
1145 addFlag(ElemDie, dwarf::DW_AT_explicit);
1146 } else if (Element.isDerivedType()) {
1147 DIDerivedType DDTy(Element);
1148 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1149 ElemDie = new DIE(dwarf::DW_TAG_friend);
1150 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1151 dwarf::DW_AT_friend);
1152 Buffer.addChild(ElemDie);
1153 } else if (DDTy.isStaticMember()) {
1154 ElemDie = getOrCreateStaticMemberDIE(DDTy);
1156 ElemDie = createMemberDIE(DDTy, Buffer);
1158 } else if (Element.isObjCProperty()) {
1159 DIObjCProperty Property(Element);
1160 ElemDie = new DIE(Property.getTag());
1161 StringRef PropertyName = Property.getObjCPropertyName();
1162 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1163 addType(ElemDie, Property.getType());
1164 addSourceLine(ElemDie, Property);
1165 StringRef GetterName = Property.getObjCPropertyGetterName();
1166 if (!GetterName.empty())
1167 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1168 StringRef SetterName = Property.getObjCPropertySetterName();
1169 if (!SetterName.empty())
1170 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1171 unsigned PropertyAttributes = 0;
1172 if (Property.isReadOnlyObjCProperty())
1173 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1174 if (Property.isReadWriteObjCProperty())
1175 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1176 if (Property.isAssignObjCProperty())
1177 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1178 if (Property.isRetainObjCProperty())
1179 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1180 if (Property.isCopyObjCProperty())
1181 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1182 if (Property.isNonAtomicObjCProperty())
1183 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1184 if (PropertyAttributes)
1185 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1186 PropertyAttributes);
1188 DIEEntry *Entry = getDIEEntry(Element);
1190 Entry = createDIEEntry(ElemDie);
1191 insertDIEEntry(Element, Entry);
1193 Buffer.addChild(ElemDie);
1198 if (CTy.isAppleBlockExtension())
1199 addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1201 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1202 if (DIDescriptor(ContainingType).isCompositeType())
1203 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
1204 getOrCreateTypeDIE(DIType(ContainingType)));
1206 if (CTy.isObjcClassComplete())
1207 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1209 // Add template parameters to a class, structure or union types.
1210 // FIXME: The support isn't in the metadata for this yet.
1211 if (Tag == dwarf::DW_TAG_class_type ||
1212 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1213 addTemplateParams(Buffer, CTy.getTemplateParams());
1221 // Add name if not anonymous or intermediate type.
1223 addString(&Buffer, dwarf::DW_AT_name, Name);
1225 if (Tag == dwarf::DW_TAG_enumeration_type ||
1226 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1227 Tag == dwarf::DW_TAG_union_type) {
1228 // Add size if non-zero (derived types might be zero-sized.)
1229 // TODO: Do we care about size for enum forward declarations?
1231 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1232 else if (!CTy.isForwardDecl())
1233 // Add zero size if it is not a forward declaration.
1234 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1236 // If we're a forward decl, say so.
1237 if (CTy.isForwardDecl())
1238 addFlag(&Buffer, dwarf::DW_AT_declaration);
1240 // Add source line info if available.
1241 if (!CTy.isForwardDecl())
1242 addSourceLine(&Buffer, CTy);
1244 // No harm in adding the runtime language to the declaration.
1245 unsigned RLang = CTy.getRunTimeLang();
1247 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1250 // If this is a type applicable to a type unit it then add it to the
1251 // list of types we'll compute a hash for later.
1252 if (shouldCreateTypeUnit(CTy, DD))
1253 DD->addTypeUnitType(&Buffer);
1256 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1257 /// for the given DITemplateTypeParameter.
1259 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP,
1261 DIE *ParamDIE = getDIE(TP);
1265 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1266 Buffer.addChild(ParamDIE);
1267 // Add the type if it exists, it could be void and therefore no type.
1269 addType(ParamDIE, resolve(TP.getType()));
1270 if (!TP.getName().empty())
1271 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1275 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1276 /// for the given DITemplateValueParameter.
1278 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP,
1280 DIE *ParamDIE = getDIE(VP);
1284 ParamDIE = new DIE(VP.getTag());
1285 Buffer.addChild(ParamDIE);
1287 // Add the type if there is one, template template and template parameter
1288 // packs will not have a type.
1290 addType(ParamDIE, resolve(VP.getType()));
1291 if (!VP.getName().empty())
1292 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1293 if (Value *Val = VP.getValue()) {
1294 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1295 addConstantValue(ParamDIE, CI,
1296 isUnsignedDIType(DD, resolve(VP.getType())));
1297 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1298 // For declaration non-type template parameters (such as global values and
1300 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1301 addOpAddress(Block, Asm->Mang->getSymbol(GV));
1302 // Emit DW_OP_stack_value to use the address as the immediate value of the
1303 // parameter, rather than a pointer to it.
1304 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1305 addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1306 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1307 assert(isa<MDString>(Val));
1308 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1309 cast<MDString>(Val)->getString());
1310 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1311 assert(isa<MDNode>(Val));
1312 DIArray A(cast<MDNode>(Val));
1313 addTemplateParams(*ParamDIE, A);
1320 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1321 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1322 DIE *NDie = getDIE(NS);
1325 NDie = new DIE(dwarf::DW_TAG_namespace);
1326 insertDIE(NS, NDie);
1327 if (!NS.getName().empty()) {
1328 addString(NDie, dwarf::DW_AT_name, NS.getName());
1329 addAccelNamespace(NS.getName(), NDie);
1330 addGlobalName(NS.getName(), NDie, NS.getContext());
1332 addAccelNamespace("(anonymous namespace)", NDie);
1333 addSourceLine(NDie, NS);
1334 addToContextOwner(NDie, NS.getContext());
1338 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1339 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1340 // Construct the context before querying for the existence of the DIE in case
1341 // such construction creates the DIE (as is the case for member function
1343 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
1345 ContextDIE = CUDie.get();
1347 DIE *SPDie = getDIE(SP);
1351 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1353 // DW_TAG_inlined_subroutine may refer to this DIE.
1354 insertDIE(SP, SPDie);
1356 DISubprogram SPDecl = SP.getFunctionDeclaration();
1357 DIE *DeclDie = NULL;
1358 if (SPDecl.isSubprogram()) {
1359 DeclDie = getOrCreateSubprogramDIE(SPDecl);
1362 // Add function template parameters.
1363 addTemplateParams(*SPDie, SP.getTemplateParams());
1365 // If this DIE is going to refer declaration info using AT_specification
1366 // then there is no need to add other attributes.
1368 // Refer function declaration directly.
1369 addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
1371 // Add subprogram definitions to the CU die directly.
1377 // Add to context owner.
1378 ContextDIE->addChild(SPDie);
1380 // Add the linkage name if we have one.
1381 StringRef LinkageName = SP.getLinkageName();
1382 if (!LinkageName.empty())
1383 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1384 GlobalValue::getRealLinkageName(LinkageName));
1386 // Constructors and operators for anonymous aggregates do not have names.
1387 if (!SP.getName().empty())
1388 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1390 addSourceLine(SPDie, SP);
1392 // Add the prototype if we have a prototype and we have a C like
1394 uint16_t Language = DICompileUnit(Node).getLanguage();
1395 if (SP.isPrototyped() &&
1396 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1397 Language == dwarf::DW_LANG_ObjC))
1398 addFlag(SPDie, dwarf::DW_AT_prototyped);
1400 // Add Return Type. A void return type will not have a type.
1401 DICompositeType SPTy = SP.getType();
1402 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1403 "the type of a subprogram should be a subroutine");
1405 DIArray Args = SPTy.getTypeArray();
1406 if (Args.getElement(0))
1407 addType(SPDie, DIType(Args.getElement(0)));
1409 unsigned VK = SP.getVirtuality();
1411 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1412 DIEBlock *Block = getDIEBlock();
1413 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1414 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1415 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1416 ContainingTypeMap.insert(std::make_pair(SPDie,
1417 resolve(SP.getContainingType())));
1420 if (!SP.isDefinition()) {
1421 addFlag(SPDie, dwarf::DW_AT_declaration);
1423 // Add arguments. Do not add arguments for subprogram definition. They will
1424 // be handled while processing variables.
1425 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1426 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1427 DIType ATy = DIType(Args.getElement(i));
1429 if (ATy.isArtificial())
1430 addFlag(Arg, dwarf::DW_AT_artificial);
1431 SPDie->addChild(Arg);
1435 if (SP.isArtificial())
1436 addFlag(SPDie, dwarf::DW_AT_artificial);
1438 if (!SP.isLocalToUnit())
1439 addFlag(SPDie, dwarf::DW_AT_external);
1441 if (SP.isOptimized())
1442 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1444 if (unsigned isa = Asm->getISAEncoding()) {
1445 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1451 // Return const expression if value is a GEP to access merged global
1453 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1454 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1455 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1456 if (!CE || CE->getNumOperands() != 3 ||
1457 CE->getOpcode() != Instruction::GetElementPtr)
1460 // First operand points to a global struct.
1461 Value *Ptr = CE->getOperand(0);
1462 if (!isa<GlobalValue>(Ptr) ||
1463 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1466 // Second operand is zero.
1467 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1468 if (!CI || !CI->isZero())
1471 // Third operand is offset.
1472 if (!isa<ConstantInt>(CE->getOperand(2)))
1478 /// createGlobalVariableDIE - create global variable DIE.
1479 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1480 // Check for pre-existence.
1484 DIGlobalVariable GV(N);
1485 if (!GV.isGlobalVariable())
1488 DIScope GVContext = GV.getContext();
1489 DIType GTy = GV.getType();
1491 // If this is a static data member definition, some attributes belong
1492 // to the declaration DIE.
1493 DIE *VariableDIE = NULL;
1494 bool IsStaticMember = false;
1495 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1496 if (SDMDecl.Verify()) {
1497 assert(SDMDecl.isStaticMember() && "Expected static member decl");
1498 // We need the declaration DIE that is in the static member's class.
1499 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
1500 IsStaticMember = true;
1503 // If this is not a static data member definition, create the variable
1504 // DIE and add the initial set of attributes to it.
1506 VariableDIE = new DIE(GV.getTag());
1508 insertDIE(N, VariableDIE);
1510 // Add name and type.
1511 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1512 addType(VariableDIE, GTy);
1514 // Add scoping info.
1515 if (!GV.isLocalToUnit())
1516 addFlag(VariableDIE, dwarf::DW_AT_external);
1518 // Add line number info.
1519 addSourceLine(VariableDIE, GV);
1520 // Add to context owner.
1521 addToContextOwner(VariableDIE, GVContext);
1525 bool addToAccelTable = false;
1526 DIE *VariableSpecDIE = NULL;
1527 bool isGlobalVariable = GV.getGlobal() != NULL;
1528 if (isGlobalVariable) {
1529 addToAccelTable = true;
1530 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1531 const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1532 if (GV.getGlobal()->isThreadLocal()) {
1533 // FIXME: Make this work with -gsplit-dwarf.
1534 unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1535 assert((PointerSize == 4 || PointerSize == 8) &&
1536 "Add support for other sizes if necessary");
1537 const MCExpr *Expr =
1538 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1539 // Based on GCC's support for TLS:
1540 if (!DD->useSplitDwarf()) {
1541 // 1) Start with a constNu of the appropriate pointer size
1542 addUInt(Block, 0, dwarf::DW_FORM_data1,
1543 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1544 // 2) containing the (relocated) offset of the TLS variable
1545 // within the module's TLS block.
1546 addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1548 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1549 addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1551 // 3) followed by a custom OP to make the debugger do a TLS lookup.
1552 addUInt(Block, 0, dwarf::DW_FORM_data1,
1553 dwarf::DW_OP_GNU_push_tls_address);
1555 addOpAddress(Block, Sym);
1556 // Do not create specification DIE if context is either compile unit
1558 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1559 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
1560 // Create specification DIE.
1561 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1562 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
1563 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1564 // A static member's declaration is already flagged as such.
1565 if (!SDMDecl.Verify())
1566 addFlag(VariableDIE, dwarf::DW_AT_declaration);
1567 addDie(VariableSpecDIE);
1569 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1571 // Add the linkage name.
1572 StringRef LinkageName = GV.getLinkageName();
1573 if (!LinkageName.empty())
1574 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1575 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1577 addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
1579 dwarf::DW_AT_MIPS_linkage_name,
1580 GlobalValue::getRealLinkageName(LinkageName));
1581 } else if (const ConstantInt *CI =
1582 dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1583 // AT_const_value was added when the static member was created. To avoid
1584 // emitting AT_const_value multiple times, we only add AT_const_value when
1585 // it is not a static member.
1586 if (!IsStaticMember)
1587 addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
1588 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1589 addToAccelTable = true;
1590 // GV is a merged global.
1591 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1592 Value *Ptr = CE->getOperand(0);
1593 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1594 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1595 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
1596 addUInt(Block, 0, dwarf::DW_FORM_udata,
1597 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1598 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1599 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1602 if (addToAccelTable) {
1603 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1604 addAccelName(GV.getName(), AddrDIE);
1606 // If the linkage name is different than the name, go ahead and output
1607 // that as well into the name table.
1608 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1609 addAccelName(GV.getLinkageName(), AddrDIE);
1612 if (!GV.isLocalToUnit())
1613 addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
1617 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1618 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1620 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1621 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
1623 // The LowerBound value defines the lower bounds which is typically zero for
1624 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1625 // Count == -1 then the array is unbounded and we do not emit
1626 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1627 // Count == 0, then the array has zero elements in which case we do not emit
1629 int64_t LowerBound = SR.getLo();
1630 int64_t DefaultLowerBound = getDefaultLowerBound();
1631 int64_t Count = SR.getCount();
1633 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1634 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1636 if (Count != -1 && Count != 0)
1637 // FIXME: An unbounded array should reference the expression that defines
1639 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1641 Buffer.addChild(DW_Subrange);
1644 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1645 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType *CTy) {
1646 if (CTy->isVector())
1647 addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1649 // Emit the element type.
1650 addType(&Buffer, resolve(CTy->getTypeDerivedFrom()));
1652 // Get an anonymous type for index type.
1653 // FIXME: This type should be passed down from the front end
1654 // as different languages may have different sizes for indexes.
1655 DIE *IdxTy = getIndexTyDie();
1657 // Construct an anonymous type for index type.
1658 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1659 addString(IdxTy, dwarf::DW_AT_name, "int");
1660 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1661 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1662 dwarf::DW_ATE_signed);
1664 setIndexTyDie(IdxTy);
1667 // Add subranges to array type.
1668 DIArray Elements = CTy->getTypeArray();
1669 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1670 DIDescriptor Element = Elements.getElement(i);
1671 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1672 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1676 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1677 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy, DIE &Buffer) {
1678 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1679 Buffer.addChild(Enumerator);
1680 StringRef Name = ETy.getName();
1681 addString(Enumerator, dwarf::DW_AT_name, Name);
1682 int64_t Value = ETy.getEnumValue();
1683 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1687 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1689 void CompileUnit::constructContainingTypeDIEs() {
1690 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1691 CE = ContainingTypeMap.end();
1693 DIE *SPDie = CI->first;
1694 const MDNode *N = CI->second;
1697 DIE *NDie = getDIE(N);
1700 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
1704 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1705 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1706 StringRef Name = DV->getName();
1708 // Define variable debug information entry.
1709 DIE *VariableDie = new DIE(DV->getTag());
1710 DbgVariable *AbsVar = DV->getAbstractVariable();
1711 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1713 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
1716 addString(VariableDie, dwarf::DW_AT_name, Name);
1717 addSourceLine(VariableDie, DV->getVariable());
1718 addType(VariableDie, DV->getType());
1721 if (DV->isArtificial())
1722 addFlag(VariableDie, dwarf::DW_AT_artificial);
1724 if (isScopeAbstract) {
1725 DV->setDIE(VariableDie);
1729 // Add variable address.
1731 unsigned Offset = DV->getDotDebugLocOffset();
1732 if (Offset != ~0U) {
1733 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1734 Asm->GetTempSymbol("debug_loc", Offset));
1735 DV->setDIE(VariableDie);
1739 // Check if variable is described by a DBG_VALUE instruction.
1740 if (const MachineInstr *DVInsn = DV->getMInsn()) {
1741 assert(DVInsn->getNumOperands() == 3);
1742 if (DVInsn->getOperand(0).isReg()) {
1743 const MachineOperand RegOp = DVInsn->getOperand(0);
1744 // If the second operand is an immediate, this is an indirect value.
1745 if (DVInsn->getOperand(1).isImm()) {
1746 MachineLocation Location(RegOp.getReg(),
1747 DVInsn->getOperand(1).getImm());
1748 addVariableAddress(*DV, VariableDie, Location);
1749 } else if (RegOp.getReg())
1750 addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1751 } else if (DVInsn->getOperand(0).isImm())
1752 addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1753 else if (DVInsn->getOperand(0).isFPImm())
1754 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1755 else if (DVInsn->getOperand(0).isCImm())
1756 addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1757 isUnsignedDIType(DD, DV->getType()));
1759 DV->setDIE(VariableDie);
1762 // .. else use frame index.
1763 int FI = DV->getFrameIndex();
1765 unsigned FrameReg = 0;
1766 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1767 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1768 MachineLocation Location(FrameReg, Offset);
1769 addVariableAddress(*DV, VariableDie, Location);
1773 DV->setDIE(VariableDie);
1777 /// createMemberDIE - Create new member DIE.
1778 DIE *CompileUnit::createMemberDIE(DIDerivedType DT, DIE &Buffer) {
1779 DIE *MemberDie = new DIE(DT.getTag());
1780 Buffer.addChild(MemberDie);
1781 StringRef Name = DT.getName();
1783 addString(MemberDie, dwarf::DW_AT_name, Name);
1785 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1787 addSourceLine(MemberDie, DT);
1789 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1790 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1792 uint64_t Size = DT.getSizeInBits();
1793 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1795 if (Size != FieldSize) {
1797 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, getBaseTypeSize(DD, DT) >> 3);
1798 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1800 uint64_t Offset = DT.getOffsetInBits();
1801 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1802 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1803 uint64_t FieldOffset = (HiMark - FieldSize);
1804 Offset -= FieldOffset;
1806 // Maybe we need to work from the other end.
1807 if (Asm->getDataLayout().isLittleEndian())
1808 Offset = FieldSize - (Offset + Size);
1809 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1811 // Here WD_AT_data_member_location points to the anonymous
1812 // field that includes this bit field.
1813 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1816 // This is not a bitfield.
1817 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1819 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1821 // For C++, virtual base classes are not at fixed offset. Use following
1822 // expression to extract appropriate offset from vtable.
1823 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1825 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1826 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1827 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1828 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1829 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1830 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1831 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1832 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1834 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, VBaseLocationDie);
1836 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1838 if (DT.isProtected())
1839 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1840 dwarf::DW_ACCESS_protected);
1841 else if (DT.isPrivate())
1842 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1843 dwarf::DW_ACCESS_private);
1844 // Otherwise C++ member and base classes are considered public.
1846 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1847 dwarf::DW_ACCESS_public);
1849 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1850 dwarf::DW_VIRTUALITY_virtual);
1852 // Objective-C properties.
1853 if (MDNode *PNode = DT.getObjCProperty())
1854 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1855 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1858 if (DT.isArtificial())
1859 addFlag(MemberDie, dwarf::DW_AT_artificial);
1864 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
1865 DIE *CompileUnit::getOrCreateStaticMemberDIE(const DIDerivedType DT) {
1869 // Construct the context before querying for the existence of the DIE in case
1870 // such construction creates the DIE.
1871 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1872 assert(ContextDIE && "Static member should belong to a non-CU context.");
1874 DIE *StaticMemberDIE = getDIE(DT);
1875 if (StaticMemberDIE)
1876 return StaticMemberDIE;
1878 StaticMemberDIE = new DIE(DT.getTag());
1879 // Add to context owner.
1880 ContextDIE->addChild(StaticMemberDIE);
1882 DIType Ty = resolve(DT.getTypeDerivedFrom());
1884 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1885 addType(StaticMemberDIE, Ty);
1886 addSourceLine(StaticMemberDIE, DT);
1887 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1888 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1890 // FIXME: We could omit private if the parent is a class_type, and
1891 // public if the parent is something else.
1892 if (DT.isProtected())
1893 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1894 dwarf::DW_ACCESS_protected);
1895 else if (DT.isPrivate())
1896 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1897 dwarf::DW_ACCESS_private);
1899 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1900 dwarf::DW_ACCESS_public);
1902 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1903 addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
1904 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1905 addConstantFPValue(StaticMemberDIE, CFP);
1907 insertDIE(DT, StaticMemberDIE);
1908 return StaticMemberDIE;