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