1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for constructing a dwarf compile unit.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "DwarfUnit.h"
15 #include "DwarfAccelTable.h"
16 #include "DwarfCompileUnit.h"
17 #include "DwarfDebug.h"
18 #include "DwarfExpression.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DIBuilder.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Mangler.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetSubtargetInfo.h"
36
37 using namespace llvm;
38
39 #define DEBUG_TYPE "dwarfdebug"
40
41 static cl::opt<bool>
42 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
43 cl::desc("Generate DWARF4 type units."),
44 cl::init(false));
45
EmitOp(uint8_t Op,const char * Comment)46 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
47 DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
48 }
EmitSigned(int Value)49 void DIEDwarfExpression::EmitSigned(int Value) {
50 DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
51 }
EmitUnsigned(unsigned Value)52 void DIEDwarfExpression::EmitUnsigned(unsigned Value) {
53 DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
54 }
isFrameRegister(unsigned MachineReg)55 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
56 return MachineReg == getTRI()->getFrameRegister(*AP.MF);
57 }
58
59
60 /// Unit - Unit constructor.
DwarfUnit(unsigned UID,dwarf::Tag UnitTag,DICompileUnit Node,AsmPrinter * A,DwarfDebug * DW,DwarfFile * DWU)61 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
62 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
63 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
64 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
65 assert(UnitTag == dwarf::DW_TAG_compile_unit ||
66 UnitTag == dwarf::DW_TAG_type_unit);
67 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
68 }
69
DwarfTypeUnit(unsigned UID,DwarfCompileUnit & CU,AsmPrinter * A,DwarfDebug * DW,DwarfFile * DWU,MCDwarfDwoLineTable * SplitLineTable)70 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
71 DwarfDebug *DW, DwarfFile *DWU,
72 MCDwarfDwoLineTable *SplitLineTable)
73 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
74 CU(CU), SplitLineTable(SplitLineTable) {
75 if (SplitLineTable)
76 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
77 }
78
79 /// ~Unit - Destructor for compile unit.
~DwarfUnit()80 DwarfUnit::~DwarfUnit() {
81 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
82 DIEBlocks[j]->~DIEBlock();
83 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
84 DIELocs[j]->~DIELoc();
85 }
86
87 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
88 /// information entry.
createDIEEntry(DIE & Entry)89 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) {
90 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
91 return Value;
92 }
93
94 /// getDefaultLowerBound - Return the default lower bound for an array. If the
95 /// DWARF version doesn't handle the language, return -1.
getDefaultLowerBound() const96 int64_t DwarfUnit::getDefaultLowerBound() const {
97 switch (getLanguage()) {
98 default:
99 break;
100
101 case dwarf::DW_LANG_C89:
102 case dwarf::DW_LANG_C99:
103 case dwarf::DW_LANG_C:
104 case dwarf::DW_LANG_C_plus_plus:
105 case dwarf::DW_LANG_ObjC:
106 case dwarf::DW_LANG_ObjC_plus_plus:
107 return 0;
108
109 case dwarf::DW_LANG_Fortran77:
110 case dwarf::DW_LANG_Fortran90:
111 case dwarf::DW_LANG_Fortran95:
112 return 1;
113
114 // The languages below have valid values only if the DWARF version >= 4.
115 case dwarf::DW_LANG_Java:
116 case dwarf::DW_LANG_Python:
117 case dwarf::DW_LANG_UPC:
118 case dwarf::DW_LANG_D:
119 if (dwarf::DWARF_VERSION >= 4)
120 return 0;
121 break;
122
123 case dwarf::DW_LANG_Ada83:
124 case dwarf::DW_LANG_Ada95:
125 case dwarf::DW_LANG_Cobol74:
126 case dwarf::DW_LANG_Cobol85:
127 case dwarf::DW_LANG_Modula2:
128 case dwarf::DW_LANG_Pascal83:
129 case dwarf::DW_LANG_PLI:
130 if (dwarf::DWARF_VERSION >= 4)
131 return 1;
132 break;
133 }
134
135 return -1;
136 }
137
138 /// Check whether the DIE for this MDNode can be shared across CUs.
isShareableAcrossCUs(DIDescriptor D)139 static bool isShareableAcrossCUs(DIDescriptor D) {
140 // When the MDNode can be part of the type system, the DIE can be shared
141 // across CUs.
142 // Combining type units and cross-CU DIE sharing is lower value (since
143 // cross-CU DIE sharing is used in LTO and removes type redundancy at that
144 // level already) but may be implementable for some value in projects
145 // building multiple independent libraries with LTO and then linking those
146 // together.
147 return (D.isType() ||
148 (D.isSubprogram() && !DISubprogram(D).isDefinition())) &&
149 !GenerateDwarfTypeUnits;
150 }
151
152 /// getDIE - Returns the debug information entry map slot for the
153 /// specified debug variable. We delegate the request to DwarfDebug
154 /// when the DIE for this MDNode can be shared across CUs. The mappings
155 /// will be kept in DwarfDebug for shareable DIEs.
getDIE(DIDescriptor D) const156 DIE *DwarfUnit::getDIE(DIDescriptor D) const {
157 if (isShareableAcrossCUs(D))
158 return DU->getDIE(D);
159 return MDNodeToDieMap.lookup(D);
160 }
161
162 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
163 /// when the DIE for this MDNode can be shared across CUs. The mappings
164 /// will be kept in DwarfDebug for shareable DIEs.
insertDIE(DIDescriptor Desc,DIE * D)165 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) {
166 if (isShareableAcrossCUs(Desc)) {
167 DU->insertDIE(Desc, D);
168 return;
169 }
170 MDNodeToDieMap.insert(std::make_pair(Desc, D));
171 }
172
173 /// addFlag - Add a flag that is true.
addFlag(DIE & Die,dwarf::Attribute Attribute)174 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
175 if (DD->getDwarfVersion() >= 4)
176 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
177 else
178 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
179 }
180
181 /// addUInt - Add an unsigned integer attribute data and value.
182 ///
addUInt(DIE & Die,dwarf::Attribute Attribute,Optional<dwarf::Form> Form,uint64_t Integer)183 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
184 Optional<dwarf::Form> Form, uint64_t Integer) {
185 if (!Form)
186 Form = DIEInteger::BestForm(false, Integer);
187 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
188 DIEInteger(Integer);
189 Die.addValue(Attribute, *Form, Value);
190 }
191
addUInt(DIE & Block,dwarf::Form Form,uint64_t Integer)192 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
193 addUInt(Block, (dwarf::Attribute)0, Form, Integer);
194 }
195
196 /// addSInt - Add an signed integer attribute data and value.
197 ///
addSInt(DIE & Die,dwarf::Attribute Attribute,Optional<dwarf::Form> Form,int64_t Integer)198 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
199 Optional<dwarf::Form> Form, int64_t Integer) {
200 if (!Form)
201 Form = DIEInteger::BestForm(true, Integer);
202 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
203 Die.addValue(Attribute, *Form, Value);
204 }
205
addSInt(DIELoc & Die,Optional<dwarf::Form> Form,int64_t Integer)206 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
207 int64_t Integer) {
208 addSInt(Die, (dwarf::Attribute)0, Form, Integer);
209 }
210
211 /// addString - Add a string attribute data and value. We always emit a
212 /// reference to the string pool instead of immediate strings so that DIEs have
213 /// more predictable sizes. In the case of split dwarf we emit an index
214 /// into another table which gets us the static offset into the string
215 /// table.
addString(DIE & Die,dwarf::Attribute Attribute,StringRef String)216 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
217 StringRef String) {
218 if (!isDwoUnit())
219 return addLocalString(Die, Attribute, String);
220
221 addIndexedString(Die, Attribute, String);
222 }
223
addIndexedString(DIE & Die,dwarf::Attribute Attribute,StringRef String)224 void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute,
225 StringRef String) {
226 unsigned idx = DU->getStringPool().getIndex(*Asm, String);
227 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
228 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
229 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str);
230 }
231
232 /// addLocalString - Add a string attribute data and value. This is guaranteed
233 /// to be in the local string pool instead of indirected.
addLocalString(DIE & Die,dwarf::Attribute Attribute,StringRef String)234 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute,
235 StringRef String) {
236 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String);
237 DIEValue *Value;
238 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
239 Value = new (DIEValueAllocator) DIELabel(Symb);
240 else
241 Value = new (DIEValueAllocator) DIEDelta(Symb, DD->getDebugStrSym());
242 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
243 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str);
244 }
245
246 /// addLabel - Add a Dwarf label attribute data and value.
247 ///
addLabel(DIE & Die,dwarf::Attribute Attribute,dwarf::Form Form,const MCSymbol * Label)248 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
249 const MCSymbol *Label) {
250 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
251 Die.addValue(Attribute, Form, Value);
252 }
253
addLabel(DIELoc & Die,dwarf::Form Form,const MCSymbol * Label)254 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
255 addLabel(Die, (dwarf::Attribute)0, Form, Label);
256 }
257
258 /// addSectionOffset - Add an offset into a section attribute data and value.
259 ///
addSectionOffset(DIE & Die,dwarf::Attribute Attribute,uint64_t Integer)260 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
261 uint64_t Integer) {
262 if (DD->getDwarfVersion() >= 4)
263 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
264 else
265 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
266 }
267
getOrCreateSourceID(StringRef FileName,StringRef DirName)268 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
269 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
270 : getCU().getOrCreateSourceID(FileName, DirName);
271 }
272
273 /// addOpAddress - Add a dwarf op address data and value using the
274 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
275 ///
addOpAddress(DIELoc & Die,const MCSymbol * Sym)276 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
277 if (!DD->useSplitDwarf()) {
278 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
279 addLabel(Die, dwarf::DW_FORM_udata, Sym);
280 } else {
281 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
282 addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
283 DD->getAddressPool().getIndex(Sym));
284 }
285 }
286
addLabelDelta(DIE & Die,dwarf::Attribute Attribute,const MCSymbol * Hi,const MCSymbol * Lo)287 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
288 const MCSymbol *Hi, const MCSymbol *Lo) {
289 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
290 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value);
291 }
292
293 /// addDIEEntry - Add a DIE attribute data and value.
294 ///
addDIEEntry(DIE & Die,dwarf::Attribute Attribute,DIE & Entry)295 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
296 addDIEEntry(Die, Attribute, createDIEEntry(Entry));
297 }
298
addDIETypeSignature(DIE & Die,const DwarfTypeUnit & Type)299 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
300 // Flag the type unit reference as a declaration so that if it contains
301 // members (implicit special members, static data member definitions, member
302 // declarations for definitions in this CU, etc) consumers don't get confused
303 // and think this is a full definition.
304 addFlag(Die, dwarf::DW_AT_declaration);
305
306 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
307 new (DIEValueAllocator) DIETypeSignature(Type));
308 }
309
addDIEEntry(DIE & Die,dwarf::Attribute Attribute,DIEEntry * Entry)310 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
311 DIEEntry *Entry) {
312 const DIE *DieCU = Die.getUnitOrNull();
313 const DIE *EntryCU = Entry->getEntry().getUnitOrNull();
314 if (!DieCU)
315 // We assume that Die belongs to this CU, if it is not linked to any CU yet.
316 DieCU = &getUnitDie();
317 if (!EntryCU)
318 EntryCU = &getUnitDie();
319 Die.addValue(Attribute,
320 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
321 Entry);
322 }
323
324 /// Create a DIE with the given Tag, add the DIE to its parent, and
325 /// call insertDIE if MD is not null.
createAndAddDIE(unsigned Tag,DIE & Parent,DIDescriptor N)326 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
327 assert(Tag != dwarf::DW_TAG_auto_variable &&
328 Tag != dwarf::DW_TAG_arg_variable);
329 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
330 DIE &Die = *Parent.getChildren().back();
331 if (N)
332 insertDIE(N, &Die);
333 return Die;
334 }
335
336 /// addBlock - Add block data.
337 ///
addBlock(DIE & Die,dwarf::Attribute Attribute,DIELoc * Loc)338 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
339 Loc->ComputeSize(Asm);
340 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
341 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
342 }
343
addBlock(DIE & Die,dwarf::Attribute Attribute,DIEBlock * Block)344 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
345 DIEBlock *Block) {
346 Block->ComputeSize(Asm);
347 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
348 Die.addValue(Attribute, Block->BestForm(), Block);
349 }
350
351 /// addSourceLine - Add location information to specified debug information
352 /// entry.
addSourceLine(DIE & Die,unsigned Line,StringRef File,StringRef Directory)353 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
354 StringRef Directory) {
355 if (Line == 0)
356 return;
357
358 unsigned FileID = getOrCreateSourceID(File, Directory);
359 assert(FileID && "Invalid file id");
360 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
361 addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
362 }
363
364 /// addSourceLine - Add location information to specified debug information
365 /// entry.
addSourceLine(DIE & Die,DIVariable V)366 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) {
367 assert(V.isVariable());
368
369 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(),
370 V.getContext().getDirectory());
371 }
372
373 /// addSourceLine - Add location information to specified debug information
374 /// entry.
addSourceLine(DIE & Die,DIGlobalVariable G)375 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) {
376 assert(G.isGlobalVariable());
377
378 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory());
379 }
380
381 /// addSourceLine - Add location information to specified debug information
382 /// entry.
addSourceLine(DIE & Die,DISubprogram SP)383 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
384 assert(SP.isSubprogram());
385
386 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory());
387 }
388
389 /// addSourceLine - Add location information to specified debug information
390 /// entry.
addSourceLine(DIE & Die,DIType Ty)391 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) {
392 assert(Ty.isType());
393
394 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory());
395 }
396
397 /// addSourceLine - Add location information to specified debug information
398 /// entry.
addSourceLine(DIE & Die,DIObjCProperty Ty)399 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) {
400 assert(Ty.isObjCProperty());
401
402 DIFile File = Ty.getFile();
403 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(),
404 File.getDirectory());
405 }
406
407 /// addSourceLine - Add location information to specified debug information
408 /// entry.
addSourceLine(DIE & Die,DINameSpace NS)409 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
410 assert(NS.Verify());
411
412 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory());
413 }
414
415 /// addRegisterOp - Add register operand.
addRegisterOpPiece(DIELoc & TheDie,unsigned Reg,unsigned SizeInBits,unsigned OffsetInBits)416 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
417 unsigned SizeInBits, unsigned OffsetInBits) {
418 DIEDwarfExpression Expr(*Asm, *this, TheDie);
419 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
420 return true;
421 }
422
423 /// addRegisterOffset - Add register offset.
addRegisterOffset(DIELoc & TheDie,unsigned Reg,int64_t Offset)424 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
425 int64_t Offset) {
426 DIEDwarfExpression Expr(*Asm, *this, TheDie);
427 return Expr.AddMachineRegIndirect(Reg, Offset);
428 }
429
430 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
431 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
432 gives the variable VarName either the struct, or a pointer to the struct, as
433 its type. This is necessary for various behind-the-scenes things the
434 compiler needs to do with by-reference variables in Blocks.
435
436 However, as far as the original *programmer* is concerned, the variable
437 should still have type 'SomeType', as originally declared.
438
439 The function getBlockByrefType dives into the __Block_byref_x_VarName
440 struct to find the original type of the variable, which is then assigned to
441 the variable's Debug Information Entry as its real type. So far, so good.
442 However now the debugger will expect the variable VarName to have the type
443 SomeType. So we need the location attribute for the variable to be an
444 expression that explains to the debugger how to navigate through the
445 pointers and struct to find the actual variable of type SomeType.
446
447 The following function does just that. We start by getting
448 the "normal" location for the variable. This will be the location
449 of either the struct __Block_byref_x_VarName or the pointer to the
450 struct __Block_byref_x_VarName.
451
452 The struct will look something like:
453
454 struct __Block_byref_x_VarName {
455 ... <various fields>
456 struct __Block_byref_x_VarName *forwarding;
457 ... <various other fields>
458 SomeType VarName;
459 ... <maybe more fields>
460 };
461
462 If we are given the struct directly (as our starting point) we
463 need to tell the debugger to:
464
465 1). Add the offset of the forwarding field.
466
467 2). Follow that pointer to get the real __Block_byref_x_VarName
468 struct to use (the real one may have been copied onto the heap).
469
470 3). Add the offset for the field VarName, to find the actual variable.
471
472 If we started with a pointer to the struct, then we need to
473 dereference that pointer first, before the other steps.
474 Translating this into DWARF ops, we will need to append the following
475 to the current location description for the variable:
476
477 DW_OP_deref -- optional, if we start with a pointer
478 DW_OP_plus_uconst <forward_fld_offset>
479 DW_OP_deref
480 DW_OP_plus_uconst <varName_fld_offset>
481
482 That is what this function does. */
483
484 /// addBlockByrefAddress - Start with the address based on the location
485 /// provided, and generate the DWARF information necessary to find the
486 /// actual Block variable (navigating the Block struct) based on the
487 /// starting location. Add the DWARF information to the die. For
488 /// more information, read large comment just above here.
489 ///
addBlockByrefAddress(const DbgVariable & DV,DIE & Die,dwarf::Attribute Attribute,const MachineLocation & Location)490 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
491 dwarf::Attribute Attribute,
492 const MachineLocation &Location) {
493 DIType Ty = DV.getType();
494 DIType TmpTy = Ty;
495 uint16_t Tag = Ty.getTag();
496 bool isPointer = false;
497
498 StringRef varName = DV.getName();
499
500 if (Tag == dwarf::DW_TAG_pointer_type) {
501 DIDerivedType DTy(Ty);
502 TmpTy = resolve(DTy.getTypeDerivedFrom());
503 isPointer = true;
504 }
505
506 DICompositeType blockStruct(TmpTy);
507
508 // Find the __forwarding field and the variable field in the __Block_byref
509 // struct.
510 DIArray Fields = blockStruct.getElements();
511 DIDerivedType varField;
512 DIDerivedType forwardingField;
513
514 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
515 DIDerivedType DT(Fields.getElement(i));
516 StringRef fieldName = DT.getName();
517 if (fieldName == "__forwarding")
518 forwardingField = DT;
519 else if (fieldName == varName)
520 varField = DT;
521 }
522
523 // Get the offsets for the forwarding field and the variable field.
524 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
525 unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
526
527 // Decode the original location, and use that as the start of the byref
528 // variable's location.
529 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
530
531 bool validReg;
532 if (Location.isReg())
533 validReg = addRegisterOpPiece(*Loc, Location.getReg());
534 else
535 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
536
537 if (!validReg)
538 return;
539
540 // If we started with a pointer to the __Block_byref... struct, then
541 // the first thing we need to do is dereference the pointer (DW_OP_deref).
542 if (isPointer)
543 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
544
545 // Next add the offset for the '__forwarding' field:
546 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
547 // adding the offset if it's 0.
548 if (forwardingFieldOffset > 0) {
549 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
550 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
551 }
552
553 // Now dereference the __forwarding field to get to the real __Block_byref
554 // struct: DW_OP_deref.
555 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
556
557 // Now that we've got the real __Block_byref... struct, add the offset
558 // for the variable's field to get to the location of the actual variable:
559 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
560 if (varFieldOffset > 0) {
561 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
562 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
563 }
564
565 // Now attach the location information to the DIE.
566 addBlock(Die, Attribute, Loc);
567 }
568
569 /// Return true if type encoding is unsigned.
isUnsignedDIType(DwarfDebug * DD,DIType Ty)570 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
571 DIDerivedType DTy(Ty);
572 if (DTy.isDerivedType()) {
573 dwarf::Tag T = (dwarf::Tag)Ty.getTag();
574 // Encode pointer constants as unsigned bytes. This is used at least for
575 // null pointer constant emission.
576 // (Pieces of) aggregate types that get hacked apart by SROA may also be
577 // represented by a constant. Encode them as unsigned bytes.
578 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
579 // here, but accept them for now due to a bug in SROA producing bogus
580 // dbg.values.
581 if (T == dwarf::DW_TAG_array_type ||
582 T == dwarf::DW_TAG_class_type ||
583 T == dwarf::DW_TAG_pointer_type ||
584 T == dwarf::DW_TAG_ptr_to_member_type ||
585 T == dwarf::DW_TAG_reference_type ||
586 T == dwarf::DW_TAG_rvalue_reference_type ||
587 T == dwarf::DW_TAG_structure_type)
588 return true;
589 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
590 T == dwarf::DW_TAG_volatile_type ||
591 T == dwarf::DW_TAG_restrict_type ||
592 T == dwarf::DW_TAG_enumeration_type);
593 if (DITypeRef Deriv = DTy.getTypeDerivedFrom())
594 return isUnsignedDIType(DD, DD->resolve(Deriv));
595 // FIXME: Enums without a fixed underlying type have unknown signedness
596 // here, leading to incorrectly emitted constants.
597 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type);
598 return false;
599 }
600
601 DIBasicType BTy(Ty);
602 assert(BTy.isBasicType());
603 unsigned Encoding = BTy.getEncoding();
604 assert((Encoding == dwarf::DW_ATE_unsigned ||
605 Encoding == dwarf::DW_ATE_unsigned_char ||
606 Encoding == dwarf::DW_ATE_signed ||
607 Encoding == dwarf::DW_ATE_signed_char ||
608 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
609 (Ty.getTag() == dwarf::DW_TAG_unspecified_type &&
610 Ty.getName() == "decltype(nullptr)")) &&
611 "Unsupported encoding");
612 return (Encoding == dwarf::DW_ATE_unsigned ||
613 Encoding == dwarf::DW_ATE_unsigned_char ||
614 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
615 Ty.getTag() == dwarf::DW_TAG_unspecified_type);
616 }
617
618 /// If this type is derived from a base type then return base type size.
getBaseTypeSize(DwarfDebug * DD,DIDerivedType Ty)619 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
620 unsigned Tag = Ty.getTag();
621
622 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
623 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
624 Tag != dwarf::DW_TAG_restrict_type)
625 return Ty.getSizeInBits();
626
627 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
628
629 assert(BaseType.isValid());
630
631 // If this is a derived type, go ahead and get the base type, unless it's a
632 // reference then it's just the size of the field. Pointer types have no need
633 // of this since they're a different type of qualification on the type.
634 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
635 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
636 return Ty.getSizeInBits();
637
638 if (BaseType.isDerivedType())
639 return getBaseTypeSize(DD, DIDerivedType(BaseType));
640
641 return BaseType.getSizeInBits();
642 }
643
644 /// addConstantFPValue - Add constant value entry in variable DIE.
addConstantFPValue(DIE & Die,const MachineOperand & MO)645 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
646 assert(MO.isFPImm() && "Invalid machine operand!");
647 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
648 APFloat FPImm = MO.getFPImm()->getValueAPF();
649
650 // Get the raw data form of the floating point.
651 const APInt FltVal = FPImm.bitcastToAPInt();
652 const char *FltPtr = (const char *)FltVal.getRawData();
653
654 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
655 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
656 int Incr = (LittleEndian ? 1 : -1);
657 int Start = (LittleEndian ? 0 : NumBytes - 1);
658 int Stop = (LittleEndian ? NumBytes : -1);
659
660 // Output the constant to DWARF one byte at a time.
661 for (; Start != Stop; Start += Incr)
662 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
663
664 addBlock(Die, dwarf::DW_AT_const_value, Block);
665 }
666
667 /// addConstantFPValue - Add constant value entry in variable DIE.
addConstantFPValue(DIE & Die,const ConstantFP * CFP)668 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
669 // Pass this down to addConstantValue as an unsigned bag of bits.
670 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
671 }
672
673 /// addConstantValue - Add constant value entry in variable DIE.
addConstantValue(DIE & Die,const ConstantInt * CI,DIType Ty)674 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) {
675 addConstantValue(Die, CI->getValue(), Ty);
676 }
677
678 /// addConstantValue - Add constant value entry in variable DIE.
addConstantValue(DIE & Die,const MachineOperand & MO,DIType Ty)679 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
680 DIType Ty) {
681 assert(MO.isImm() && "Invalid machine operand!");
682
683 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
684 }
685
addConstantValue(DIE & Die,bool Unsigned,uint64_t Val)686 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
687 // FIXME: This is a bit conservative/simple - it emits negative values always
688 // sign extended to 64 bits rather than minimizing the number of bytes.
689 addUInt(Die, dwarf::DW_AT_const_value,
690 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
691 }
692
addConstantValue(DIE & Die,const APInt & Val,DIType Ty)693 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) {
694 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
695 }
696
697 // addConstantValue - Add constant value entry in variable DIE.
addConstantValue(DIE & Die,const APInt & Val,bool Unsigned)698 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
699 unsigned CIBitWidth = Val.getBitWidth();
700 if (CIBitWidth <= 64) {
701 addConstantValue(Die, Unsigned,
702 Unsigned ? Val.getZExtValue() : Val.getSExtValue());
703 return;
704 }
705
706 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
707
708 // Get the raw data form of the large APInt.
709 const uint64_t *Ptr64 = Val.getRawData();
710
711 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
712 bool LittleEndian = Asm->getDataLayout().isLittleEndian();
713
714 // Output the constant to DWARF one byte at a time.
715 for (int i = 0; i < NumBytes; i++) {
716 uint8_t c;
717 if (LittleEndian)
718 c = Ptr64[i / 8] >> (8 * (i & 7));
719 else
720 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
721 addUInt(*Block, dwarf::DW_FORM_data1, c);
722 }
723
724 addBlock(Die, dwarf::DW_AT_const_value, Block);
725 }
726
727 /// addTemplateParams - Add template parameters into buffer.
addTemplateParams(DIE & Buffer,DIArray TParams)728 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
729 // Add template parameters.
730 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
731 DIDescriptor Element = TParams.getElement(i);
732 if (Element.isTemplateTypeParameter())
733 constructTemplateTypeParameterDIE(Buffer,
734 DITemplateTypeParameter(Element));
735 else if (Element.isTemplateValueParameter())
736 constructTemplateValueParameterDIE(Buffer,
737 DITemplateValueParameter(Element));
738 }
739 }
740
741 /// getOrCreateContextDIE - Get context owner's DIE.
getOrCreateContextDIE(DIScope Context)742 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) {
743 if (!Context || Context.isFile())
744 return &getUnitDie();
745 if (Context.isType())
746 return getOrCreateTypeDIE(DIType(Context));
747 if (Context.isNameSpace())
748 return getOrCreateNameSpace(DINameSpace(Context));
749 if (Context.isSubprogram())
750 return getOrCreateSubprogramDIE(DISubprogram(Context));
751 return getDIE(Context);
752 }
753
createTypeDIE(DICompositeType Ty)754 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) {
755 DIScope Context = resolve(Ty.getContext());
756 DIE *ContextDIE = getOrCreateContextDIE(Context);
757
758 if (DIE *TyDIE = getDIE(Ty))
759 return TyDIE;
760
761 // Create new type.
762 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
763
764 constructTypeDIE(TyDIE, Ty);
765
766 updateAcceleratorTables(Context, Ty, TyDIE);
767 return &TyDIE;
768 }
769
770 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
771 /// given DIType.
getOrCreateTypeDIE(const MDNode * TyNode)772 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
773 if (!TyNode)
774 return nullptr;
775
776 DIType Ty(TyNode);
777 assert(Ty.isType());
778 assert(Ty == resolve(Ty.getRef()) &&
779 "type was not uniqued, possible ODR violation.");
780
781 // DW_TAG_restrict_type is not supported in DWARF2
782 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
783 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom()));
784
785 // Construct the context before querying for the existence of the DIE in case
786 // such construction creates the DIE.
787 DIScope Context = resolve(Ty.getContext());
788 DIE *ContextDIE = getOrCreateContextDIE(Context);
789 assert(ContextDIE);
790
791 if (DIE *TyDIE = getDIE(Ty))
792 return TyDIE;
793
794 // Create new type.
795 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
796
797 updateAcceleratorTables(Context, Ty, TyDIE);
798
799 if (Ty.isBasicType())
800 constructTypeDIE(TyDIE, DIBasicType(Ty));
801 else if (Ty.isCompositeType()) {
802 DICompositeType CTy(Ty);
803 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl())
804 if (MDString *TypeId = CTy.getIdentifier()) {
805 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
806 // Skip updating the accelerator tables since this is not the full type.
807 return &TyDIE;
808 }
809 constructTypeDIE(TyDIE, CTy);
810 } else {
811 assert(Ty.isDerivedType() && "Unknown kind of DIType");
812 constructTypeDIE(TyDIE, DIDerivedType(Ty));
813 }
814
815 return &TyDIE;
816 }
817
updateAcceleratorTables(DIScope Context,DIType Ty,const DIE & TyDIE)818 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty,
819 const DIE &TyDIE) {
820 if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
821 bool IsImplementation = 0;
822 if (Ty.isCompositeType()) {
823 DICompositeType CT(Ty);
824 // A runtime language of 0 actually means C/C++ and that any
825 // non-negative value is some version of Objective-C/C++.
826 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
827 }
828 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
829 DD->addAccelType(Ty.getName(), TyDIE, Flags);
830
831 if (!Context || Context.isCompileUnit() || Context.isFile() ||
832 Context.isNameSpace())
833 addGlobalType(Ty, TyDIE, Context);
834 }
835 }
836
837 /// addType - Add a new type attribute to the specified entity.
addType(DIE & Entity,DIType Ty,dwarf::Attribute Attribute)838 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) {
839 assert(Ty && "Trying to add a type that doesn't exist?");
840
841 // Check for pre-existence.
842 DIEEntry *Entry = getDIEEntry(Ty);
843 // If it exists then use the existing value.
844 if (Entry) {
845 addDIEEntry(Entity, Attribute, Entry);
846 return;
847 }
848
849 // Construct type.
850 DIE *Buffer = getOrCreateTypeDIE(Ty);
851
852 // Set up proxy.
853 Entry = createDIEEntry(*Buffer);
854 insertDIEEntry(Ty, Entry);
855 addDIEEntry(Entity, Attribute, Entry);
856 }
857
858 /// getParentContextString - Walks the metadata parent chain in a language
859 /// specific manner (using the compile unit language) and returns
860 /// it as a string. This is done at the metadata level because DIEs may
861 /// not currently have been added to the parent context and walking the
862 /// DIEs looking for names is more expensive than walking the metadata.
getParentContextString(DIScope Context) const863 std::string DwarfUnit::getParentContextString(DIScope Context) const {
864 if (!Context)
865 return "";
866
867 // FIXME: Decide whether to implement this for non-C++ languages.
868 if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
869 return "";
870
871 std::string CS;
872 SmallVector<DIScope, 1> Parents;
873 while (!Context.isCompileUnit()) {
874 Parents.push_back(Context);
875 if (Context.getContext())
876 Context = resolve(Context.getContext());
877 else
878 // Structure, etc types will have a NULL context if they're at the top
879 // level.
880 break;
881 }
882
883 // Reverse iterate over our list to go from the outermost construct to the
884 // innermost.
885 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
886 E = Parents.rend();
887 I != E; ++I) {
888 DIScope Ctx = *I;
889 StringRef Name = Ctx.getName();
890 if (Name.empty() && Ctx.isNameSpace())
891 Name = "(anonymous namespace)";
892 if (!Name.empty()) {
893 CS += Name;
894 CS += "::";
895 }
896 }
897 return CS;
898 }
899
900 /// constructTypeDIE - Construct basic type die from DIBasicType.
constructTypeDIE(DIE & Buffer,DIBasicType BTy)901 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
902 // Get core information.
903 StringRef Name = BTy.getName();
904 // Add name if not anonymous or intermediate type.
905 if (!Name.empty())
906 addString(Buffer, dwarf::DW_AT_name, Name);
907
908 // An unspecified type only has a name attribute.
909 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
910 return;
911
912 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
913 BTy.getEncoding());
914
915 uint64_t Size = BTy.getSizeInBits() >> 3;
916 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
917 }
918
919 /// constructTypeDIE - Construct derived type die from DIDerivedType.
constructTypeDIE(DIE & Buffer,DIDerivedType DTy)920 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
921 // Get core information.
922 StringRef Name = DTy.getName();
923 uint64_t Size = DTy.getSizeInBits() >> 3;
924 uint16_t Tag = Buffer.getTag();
925
926 // Map to main type, void will not have a type.
927 DIType FromTy = resolve(DTy.getTypeDerivedFrom());
928 if (FromTy)
929 addType(Buffer, FromTy);
930
931 // Add name if not anonymous or intermediate type.
932 if (!Name.empty())
933 addString(Buffer, dwarf::DW_AT_name, Name);
934
935 // Add size if non-zero (derived types might be zero-sized.)
936 if (Size && Tag != dwarf::DW_TAG_pointer_type
937 && Tag != dwarf::DW_TAG_ptr_to_member_type)
938 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
939
940 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
941 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
942 *getOrCreateTypeDIE(resolve(DTy.getClassType())));
943 // Add source line info if available and TyDesc is not a forward declaration.
944 if (!DTy.isForwardDecl())
945 addSourceLine(Buffer, DTy);
946 }
947
948 /// constructSubprogramArguments - Construct function argument DIEs.
constructSubprogramArguments(DIE & Buffer,DITypeArray Args)949 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) {
950 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
951 DIType Ty = resolve(Args.getElement(i));
952 if (!Ty) {
953 assert(i == N-1 && "Unspecified parameter must be the last argument");
954 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
955 } else {
956 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
957 addType(Arg, Ty);
958 if (Ty.isArtificial())
959 addFlag(Arg, dwarf::DW_AT_artificial);
960 }
961 }
962 }
963
964 /// constructTypeDIE - Construct type DIE from DICompositeType.
constructTypeDIE(DIE & Buffer,DICompositeType CTy)965 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
966 // Add name if not anonymous or intermediate type.
967 StringRef Name = CTy.getName();
968
969 uint64_t Size = CTy.getSizeInBits() >> 3;
970 uint16_t Tag = Buffer.getTag();
971
972 switch (Tag) {
973 case dwarf::DW_TAG_array_type:
974 constructArrayTypeDIE(Buffer, CTy);
975 break;
976 case dwarf::DW_TAG_enumeration_type:
977 constructEnumTypeDIE(Buffer, CTy);
978 break;
979 case dwarf::DW_TAG_subroutine_type: {
980 // Add return type. A void return won't have a type.
981 DITypeArray Elements = DISubroutineType(CTy).getTypeArray();
982 DIType RTy(resolve(Elements.getElement(0)));
983 if (RTy)
984 addType(Buffer, RTy);
985
986 bool isPrototyped = true;
987 if (Elements.getNumElements() == 2 &&
988 !Elements.getElement(1))
989 isPrototyped = false;
990
991 constructSubprogramArguments(Buffer, Elements);
992
993 // Add prototype flag if we're dealing with a C language and the
994 // function has been prototyped.
995 uint16_t Language = getLanguage();
996 if (isPrototyped &&
997 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
998 Language == dwarf::DW_LANG_ObjC))
999 addFlag(Buffer, dwarf::DW_AT_prototyped);
1000
1001 if (CTy.isLValueReference())
1002 addFlag(Buffer, dwarf::DW_AT_reference);
1003
1004 if (CTy.isRValueReference())
1005 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
1006 } break;
1007 case dwarf::DW_TAG_structure_type:
1008 case dwarf::DW_TAG_union_type:
1009 case dwarf::DW_TAG_class_type: {
1010 // Add elements to structure type.
1011 DIArray Elements = CTy.getElements();
1012 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1013 DIDescriptor Element = Elements.getElement(i);
1014 if (Element.isSubprogram())
1015 getOrCreateSubprogramDIE(DISubprogram(Element));
1016 else if (Element.isDerivedType()) {
1017 DIDerivedType DDTy(Element);
1018 if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1019 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
1020 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
1021 dwarf::DW_AT_friend);
1022 } else if (DDTy.isStaticMember()) {
1023 getOrCreateStaticMemberDIE(DDTy);
1024 } else {
1025 constructMemberDIE(Buffer, DDTy);
1026 }
1027 } else if (Element.isObjCProperty()) {
1028 DIObjCProperty Property(Element);
1029 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer);
1030 StringRef PropertyName = Property.getObjCPropertyName();
1031 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1032 if (Property.getType())
1033 addType(ElemDie, Property.getType());
1034 addSourceLine(ElemDie, Property);
1035 StringRef GetterName = Property.getObjCPropertyGetterName();
1036 if (!GetterName.empty())
1037 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1038 StringRef SetterName = Property.getObjCPropertySetterName();
1039 if (!SetterName.empty())
1040 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1041 unsigned PropertyAttributes = 0;
1042 if (Property.isReadOnlyObjCProperty())
1043 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1044 if (Property.isReadWriteObjCProperty())
1045 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1046 if (Property.isAssignObjCProperty())
1047 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1048 if (Property.isRetainObjCProperty())
1049 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1050 if (Property.isCopyObjCProperty())
1051 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1052 if (Property.isNonAtomicObjCProperty())
1053 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1054 if (PropertyAttributes)
1055 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
1056 PropertyAttributes);
1057
1058 DIEEntry *Entry = getDIEEntry(Element);
1059 if (!Entry) {
1060 Entry = createDIEEntry(ElemDie);
1061 insertDIEEntry(Element, Entry);
1062 }
1063 } else
1064 continue;
1065 }
1066
1067 if (CTy.isAppleBlockExtension())
1068 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
1069
1070 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
1071 // inside C++ composite types to point to the base class with the vtable.
1072 DICompositeType ContainingType(resolve(CTy.getContainingType()));
1073 if (ContainingType)
1074 addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
1075 *getOrCreateTypeDIE(ContainingType));
1076
1077 if (CTy.isObjcClassComplete())
1078 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1079
1080 // Add template parameters to a class, structure or union types.
1081 // FIXME: The support isn't in the metadata for this yet.
1082 if (Tag == dwarf::DW_TAG_class_type ||
1083 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1084 addTemplateParams(Buffer, CTy.getTemplateParams());
1085
1086 break;
1087 }
1088 default:
1089 break;
1090 }
1091
1092 // Add name if not anonymous or intermediate type.
1093 if (!Name.empty())
1094 addString(Buffer, dwarf::DW_AT_name, Name);
1095
1096 if (Tag == dwarf::DW_TAG_enumeration_type ||
1097 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1098 Tag == dwarf::DW_TAG_union_type) {
1099 // Add size if non-zero (derived types might be zero-sized.)
1100 // TODO: Do we care about size for enum forward declarations?
1101 if (Size)
1102 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1103 else if (!CTy.isForwardDecl())
1104 // Add zero size if it is not a forward declaration.
1105 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1106
1107 // If we're a forward decl, say so.
1108 if (CTy.isForwardDecl())
1109 addFlag(Buffer, dwarf::DW_AT_declaration);
1110
1111 // Add source line info if available.
1112 if (!CTy.isForwardDecl())
1113 addSourceLine(Buffer, CTy);
1114
1115 // No harm in adding the runtime language to the declaration.
1116 unsigned RLang = CTy.getRunTimeLang();
1117 if (RLang)
1118 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1119 RLang);
1120 }
1121 }
1122
1123 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
1124 /// DITemplateTypeParameter.
constructTemplateTypeParameterDIE(DIE & Buffer,DITemplateTypeParameter TP)1125 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
1126 DITemplateTypeParameter TP) {
1127 DIE &ParamDIE =
1128 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1129 // Add the type if it exists, it could be void and therefore no type.
1130 if (TP.getType())
1131 addType(ParamDIE, resolve(TP.getType()));
1132 if (!TP.getName().empty())
1133 addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1134 }
1135
1136 /// constructTemplateValueParameterDIE - Construct new DIE for the given
1137 /// DITemplateValueParameter.
1138 void
constructTemplateValueParameterDIE(DIE & Buffer,DITemplateValueParameter VP)1139 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer,
1140 DITemplateValueParameter VP) {
1141 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
1142
1143 // Add the type if there is one, template template and template parameter
1144 // packs will not have a type.
1145 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
1146 addType(ParamDIE, resolve(VP.getType()));
1147 if (!VP.getName().empty())
1148 addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1149 if (Metadata *Val = VP.getValue()) {
1150 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1151 addConstantValue(ParamDIE, CI, resolve(VP.getType()));
1152 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1153 // For declaration non-type template parameters (such as global values and
1154 // functions)
1155 DIELoc *Loc = new (DIEValueAllocator) DIELoc();
1156 addOpAddress(*Loc, Asm->getSymbol(GV));
1157 // Emit DW_OP_stack_value to use the address as the immediate value of the
1158 // parameter, rather than a pointer to it.
1159 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1160 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1161 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1162 assert(isa<MDString>(Val));
1163 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1164 cast<MDString>(Val)->getString());
1165 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1166 assert(isa<MDNode>(Val));
1167 DIArray A(cast<MDNode>(Val));
1168 addTemplateParams(ParamDIE, A);
1169 }
1170 }
1171 }
1172
1173 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
getOrCreateNameSpace(DINameSpace NS)1174 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
1175 // Construct the context before querying for the existence of the DIE in case
1176 // such construction creates the DIE.
1177 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
1178
1179 if (DIE *NDie = getDIE(NS))
1180 return NDie;
1181 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1182
1183 StringRef Name = NS.getName();
1184 if (!Name.empty())
1185 addString(NDie, dwarf::DW_AT_name, NS.getName());
1186 else
1187 Name = "(anonymous namespace)";
1188 DD->addAccelNamespace(Name, NDie);
1189 addGlobalName(Name, NDie, NS.getContext());
1190 addSourceLine(NDie, NS);
1191 return &NDie;
1192 }
1193
1194 /// getOrCreateSubprogramDIE - Create new DIE using SP.
getOrCreateSubprogramDIE(DISubprogram SP,bool Minimal)1195 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
1196 // Construct the context before querying for the existence of the DIE in case
1197 // such construction creates the DIE (as is the case for member function
1198 // declarations).
1199 DIE *ContextDIE =
1200 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP.getContext()));
1201
1202 if (DIE *SPDie = getDIE(SP))
1203 return SPDie;
1204
1205 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1206 if (!Minimal) {
1207 // Add subprogram definitions to the CU die directly.
1208 ContextDIE = &getUnitDie();
1209 // Build the decl now to ensure it precedes the definition.
1210 getOrCreateSubprogramDIE(SPDecl);
1211 }
1212 }
1213
1214 // DW_TAG_inlined_subroutine may refer to this DIE.
1215 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1216
1217 // Stop here and fill this in later, depending on whether or not this
1218 // subprogram turns out to have inlined instances or not.
1219 if (SP.isDefinition())
1220 return &SPDie;
1221
1222 applySubprogramAttributes(SP, SPDie);
1223 return &SPDie;
1224 }
1225
applySubprogramDefinitionAttributes(DISubprogram SP,DIE & SPDie)1226 bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
1227 DIE &SPDie) {
1228 DIE *DeclDie = nullptr;
1229 StringRef DeclLinkageName;
1230 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
1231 DeclDie = getDIE(SPDecl);
1232 assert(DeclDie && "This DIE should've already been constructed when the "
1233 "definition DIE was created in "
1234 "getOrCreateSubprogramDIE");
1235 DeclLinkageName = SPDecl.getLinkageName();
1236 }
1237
1238 // Add function template parameters.
1239 addTemplateParams(SPDie, SP.getTemplateParams());
1240
1241 // Add the linkage name if we have one and it isn't in the Decl.
1242 StringRef LinkageName = SP.getLinkageName();
1243 assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1244 LinkageName == DeclLinkageName) &&
1245 "decl has a linkage name and it is different");
1246 if (!LinkageName.empty() && DeclLinkageName.empty())
1247 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1248 GlobalValue::getRealLinkageName(LinkageName));
1249
1250 if (!DeclDie)
1251 return false;
1252
1253 // Refer to the function declaration where all the other attributes will be
1254 // found.
1255 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1256 return true;
1257 }
1258
applySubprogramAttributes(DISubprogram SP,DIE & SPDie,bool Minimal)1259 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
1260 bool Minimal) {
1261 if (!Minimal)
1262 if (applySubprogramDefinitionAttributes(SP, SPDie))
1263 return;
1264
1265 // Constructors and operators for anonymous aggregates do not have names.
1266 if (!SP.getName().empty())
1267 addString(SPDie, dwarf::DW_AT_name, SP.getName());
1268
1269 // Skip the rest of the attributes under -gmlt to save space.
1270 if (Minimal)
1271 return;
1272
1273 addSourceLine(SPDie, SP);
1274
1275 // Add the prototype if we have a prototype and we have a C like
1276 // language.
1277 uint16_t Language = getLanguage();
1278 if (SP.isPrototyped() &&
1279 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1280 Language == dwarf::DW_LANG_ObjC))
1281 addFlag(SPDie, dwarf::DW_AT_prototyped);
1282
1283 DISubroutineType SPTy = SP.getType();
1284 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1285 "the type of a subprogram should be a subroutine");
1286
1287 DITypeArray Args = SPTy.getTypeArray();
1288 // Add a return type. If this is a type like a C/C++ void type we don't add a
1289 // return type.
1290 if (resolve(Args.getElement(0)))
1291 addType(SPDie, DIType(resolve(Args.getElement(0))));
1292
1293 unsigned VK = SP.getVirtuality();
1294 if (VK) {
1295 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1296 DIELoc *Block = getDIELoc();
1297 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1298 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1299 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1300 ContainingTypeMap.insert(
1301 std::make_pair(&SPDie, resolve(SP.getContainingType())));
1302 }
1303
1304 if (!SP.isDefinition()) {
1305 addFlag(SPDie, dwarf::DW_AT_declaration);
1306
1307 // Add arguments. Do not add arguments for subprogram definition. They will
1308 // be handled while processing variables.
1309 constructSubprogramArguments(SPDie, Args);
1310 }
1311
1312 if (SP.isArtificial())
1313 addFlag(SPDie, dwarf::DW_AT_artificial);
1314
1315 if (!SP.isLocalToUnit())
1316 addFlag(SPDie, dwarf::DW_AT_external);
1317
1318 if (SP.isOptimized())
1319 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1320
1321 if (unsigned isa = Asm->getISAEncoding()) {
1322 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1323 }
1324
1325 if (SP.isLValueReference())
1326 addFlag(SPDie, dwarf::DW_AT_reference);
1327
1328 if (SP.isRValueReference())
1329 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1330
1331 if (SP.isProtected())
1332 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1333 dwarf::DW_ACCESS_protected);
1334 else if (SP.isPrivate())
1335 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1336 dwarf::DW_ACCESS_private);
1337 else if (SP.isPublic())
1338 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1339 dwarf::DW_ACCESS_public);
1340
1341 if (SP.isExplicit())
1342 addFlag(SPDie, dwarf::DW_AT_explicit);
1343 }
1344
1345 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
constructSubrangeDIE(DIE & Buffer,DISubrange SR,DIE * IndexTy)1346 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
1347 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1348 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1349
1350 // The LowerBound value defines the lower bounds which is typically zero for
1351 // C/C++. The Count value is the number of elements. Values are 64 bit. If
1352 // Count == -1 then the array is unbounded and we do not emit
1353 // DW_AT_lower_bound and DW_AT_count attributes.
1354 int64_t LowerBound = SR.getLo();
1355 int64_t DefaultLowerBound = getDefaultLowerBound();
1356 int64_t Count = SR.getCount();
1357
1358 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1359 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1360
1361 if (Count != -1)
1362 // FIXME: An unbounded array should reference the expression that defines
1363 // the array.
1364 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1365 }
1366
getIndexTyDie()1367 DIE *DwarfUnit::getIndexTyDie() {
1368 if (IndexTyDie)
1369 return IndexTyDie;
1370 // Construct an integer type to use for indexes.
1371 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1372 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1373 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1374 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1375 dwarf::DW_ATE_unsigned);
1376 return IndexTyDie;
1377 }
1378
1379 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
constructArrayTypeDIE(DIE & Buffer,DICompositeType CTy)1380 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
1381 if (CTy.isVector())
1382 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1383
1384 // Emit the element type.
1385 addType(Buffer, resolve(CTy.getTypeDerivedFrom()));
1386
1387 // Get an anonymous type for index type.
1388 // FIXME: This type should be passed down from the front end
1389 // as different languages may have different sizes for indexes.
1390 DIE *IdxTy = getIndexTyDie();
1391
1392 // Add subranges to array type.
1393 DIArray Elements = CTy.getElements();
1394 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1395 DIDescriptor Element = Elements.getElement(i);
1396 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1397 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1398 }
1399 }
1400
1401 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
constructEnumTypeDIE(DIE & Buffer,DICompositeType CTy)1402 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
1403 DIArray Elements = CTy.getElements();
1404
1405 // Add enumerators to enumeration type.
1406 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1407 DIEnumerator Enum(Elements.getElement(i));
1408 if (Enum.isEnumerator()) {
1409 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1410 StringRef Name = Enum.getName();
1411 addString(Enumerator, dwarf::DW_AT_name, Name);
1412 int64_t Value = Enum.getEnumValue();
1413 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1414 Value);
1415 }
1416 }
1417 DIType DTy = resolve(CTy.getTypeDerivedFrom());
1418 if (DTy) {
1419 addType(Buffer, DTy);
1420 addFlag(Buffer, dwarf::DW_AT_enum_class);
1421 }
1422 }
1423
1424 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1425 /// vtables.
constructContainingTypeDIEs()1426 void DwarfUnit::constructContainingTypeDIEs() {
1427 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1428 CE = ContainingTypeMap.end();
1429 CI != CE; ++CI) {
1430 DIE &SPDie = *CI->first;
1431 DIDescriptor D(CI->second);
1432 if (!D)
1433 continue;
1434 DIE *NDie = getDIE(D);
1435 if (!NDie)
1436 continue;
1437 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1438 }
1439 }
1440
1441 /// constructMemberDIE - Construct member DIE from DIDerivedType.
constructMemberDIE(DIE & Buffer,DIDerivedType DT)1442 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
1443 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer);
1444 StringRef Name = DT.getName();
1445 if (!Name.empty())
1446 addString(MemberDie, dwarf::DW_AT_name, Name);
1447
1448 addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
1449
1450 addSourceLine(MemberDie, DT);
1451
1452 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
1453
1454 // For C++, virtual base classes are not at fixed offset. Use following
1455 // expression to extract appropriate offset from vtable.
1456 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1457
1458 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc();
1459 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1460 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1461 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1462 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1463 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1464 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1465 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1466
1467 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1468 } else {
1469 uint64_t Size = DT.getSizeInBits();
1470 uint64_t FieldSize = getBaseTypeSize(DD, DT);
1471 uint64_t OffsetInBytes;
1472
1473 if (FieldSize && Size != FieldSize) {
1474 // Handle bitfield, assume bytes are 8 bits.
1475 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1476 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1477
1478 uint64_t Offset = DT.getOffsetInBits();
1479 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1480 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1481 uint64_t FieldOffset = (HiMark - FieldSize);
1482 Offset -= FieldOffset;
1483
1484 // Maybe we need to work from the other end.
1485 if (Asm->getDataLayout().isLittleEndian())
1486 Offset = FieldSize - (Offset + Size);
1487 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1488
1489 // Here DW_AT_data_member_location points to the anonymous
1490 // field that includes this bit field.
1491 OffsetInBytes = FieldOffset >> 3;
1492 } else
1493 // This is not a bitfield.
1494 OffsetInBytes = DT.getOffsetInBits() >> 3;
1495
1496 if (DD->getDwarfVersion() <= 2) {
1497 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc();
1498 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1499 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1500 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1501 } else
1502 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1503 OffsetInBytes);
1504 }
1505
1506 if (DT.isProtected())
1507 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1508 dwarf::DW_ACCESS_protected);
1509 else if (DT.isPrivate())
1510 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1511 dwarf::DW_ACCESS_private);
1512 // Otherwise C++ member and base classes are considered public.
1513 else if (DT.isPublic())
1514 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1515 dwarf::DW_ACCESS_public);
1516 if (DT.isVirtual())
1517 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1518 dwarf::DW_VIRTUALITY_virtual);
1519
1520 // Objective-C properties.
1521 if (MDNode *PNode = DT.getObjCProperty())
1522 if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1523 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1524 PropertyDie);
1525
1526 if (DT.isArtificial())
1527 addFlag(MemberDie, dwarf::DW_AT_artificial);
1528 }
1529
1530 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
getOrCreateStaticMemberDIE(DIDerivedType DT)1531 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
1532 if (!DT.Verify())
1533 return nullptr;
1534
1535 // Construct the context before querying for the existence of the DIE in case
1536 // such construction creates the DIE.
1537 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
1538 assert(dwarf::isType(ContextDIE->getTag()) &&
1539 "Static member should belong to a type.");
1540
1541 if (DIE *StaticMemberDIE = getDIE(DT))
1542 return StaticMemberDIE;
1543
1544 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
1545
1546 DIType Ty = resolve(DT.getTypeDerivedFrom());
1547
1548 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1549 addType(StaticMemberDIE, Ty);
1550 addSourceLine(StaticMemberDIE, DT);
1551 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1552 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1553
1554 // FIXME: We could omit private if the parent is a class_type, and
1555 // public if the parent is something else.
1556 if (DT.isProtected())
1557 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1558 dwarf::DW_ACCESS_protected);
1559 else if (DT.isPrivate())
1560 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1561 dwarf::DW_ACCESS_private);
1562 else if (DT.isPublic())
1563 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1564 dwarf::DW_ACCESS_public);
1565
1566 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1567 addConstantValue(StaticMemberDIE, CI, Ty);
1568 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1569 addConstantFPValue(StaticMemberDIE, CFP);
1570
1571 return &StaticMemberDIE;
1572 }
1573
emitHeader(const MCSymbol * ASectionSym) const1574 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const {
1575 // Emit size of content not including length itself
1576 Asm->OutStreamer.AddComment("Length of Unit");
1577 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1578
1579 Asm->OutStreamer.AddComment("DWARF version number");
1580 Asm->EmitInt16(DD->getDwarfVersion());
1581 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1582 // We share one abbreviations table across all units so it's always at the
1583 // start of the section. Use a relocatable offset where needed to ensure
1584 // linking doesn't invalidate that offset.
1585 if (ASectionSym)
1586 Asm->EmitSectionOffset(ASectionSym, ASectionSym);
1587 else
1588 // Use a constant value when no symbol is provided.
1589 Asm->EmitInt32(0);
1590 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1591 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1592 }
1593
initSection(const MCSection * Section)1594 void DwarfUnit::initSection(const MCSection *Section) {
1595 assert(!this->Section);
1596 this->Section = Section;
1597 }
1598
emitHeader(const MCSymbol * ASectionSym) const1599 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const {
1600 DwarfUnit::emitHeader(ASectionSym);
1601 Asm->OutStreamer.AddComment("Type Signature");
1602 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
1603 Asm->OutStreamer.AddComment("Type DIE Offset");
1604 // In a skeleton type unit there is no type DIE so emit a zero offset.
1605 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0,
1606 sizeof(Ty->getOffset()));
1607 }
1608
isDwoUnit() const1609 bool DwarfTypeUnit::isDwoUnit() const {
1610 // Since there are no skeleton type units, all type units are dwo type units
1611 // when split DWARF is being used.
1612 return DD->useSplitDwarf();
1613 }
1614