1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains support for constructing a dwarf compile unit.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "DwarfUnit.h"
14 #include "AddressPool.h"
15 #include "DwarfCompileUnit.h"
16 #include "DwarfExpression.h"
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/ADT/APInt.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/iterator_range.h"
21 #include "llvm/CodeGen/TargetRegisterInfo.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/GlobalValue.h"
25 #include "llvm/IR/Metadata.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCDwarf.h"
29 #include "llvm/MC/MCSection.h"
30 #include "llvm/MC/MCStreamer.h"
31 #include "llvm/Support/Casting.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include <cassert>
34 #include <cstdint>
35 #include <string>
36 #include <utility>
37 
38 using namespace llvm;
39 
40 #define DEBUG_TYPE "dwarfdebug"
41 
42 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP,
43                                        DwarfCompileUnit &CU, DIELoc &DIE)
44     : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP), OutDIE(DIE) {}
45 
46 void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
47   CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Op);
48 }
49 
50 void DIEDwarfExpression::emitSigned(int64_t Value) {
51   CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata, Value);
52 }
53 
54 void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
55   CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value);
56 }
57 
58 void DIEDwarfExpression::emitData1(uint8_t Value) {
59   CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value);
60 }
61 
62 void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
63   CU.addBaseTypeRef(getActiveDIE(), Idx);
64 }
65 
66 void DIEDwarfExpression::enableTemporaryBuffer() {
67   assert(!IsBuffering && "Already buffering?");
68   IsBuffering = true;
69 }
70 
71 void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
72 
73 unsigned DIEDwarfExpression::getTemporaryBufferSize() {
74   return TmpDIE.computeSize(AP.getDwarfFormParams());
75 }
76 
77 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
78 
79 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
80                                          llvm::Register MachineReg) {
81   return MachineReg == TRI.getFrameRegister(*AP.MF);
82 }
83 
84 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
85                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
86     : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU) {}
87 
88 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
89                              DwarfDebug *DW, DwarfFile *DWU,
90                              MCDwarfDwoLineTable *SplitLineTable)
91     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
92       SplitLineTable(SplitLineTable) {
93 }
94 
95 DwarfUnit::~DwarfUnit() {
96   for (DIEBlock *B : DIEBlocks)
97     B->~DIEBlock();
98   for (DIELoc *L : DIELocs)
99     L->~DIELoc();
100 }
101 
102 int64_t DwarfUnit::getDefaultLowerBound() const {
103   switch (getLanguage()) {
104   default:
105     break;
106 
107   // The languages below have valid values in all DWARF versions.
108   case dwarf::DW_LANG_C:
109   case dwarf::DW_LANG_C89:
110   case dwarf::DW_LANG_C_plus_plus:
111     return 0;
112 
113   case dwarf::DW_LANG_Fortran77:
114   case dwarf::DW_LANG_Fortran90:
115     return 1;
116 
117   // The languages below have valid values only if the DWARF version >= 3.
118   case dwarf::DW_LANG_C99:
119   case dwarf::DW_LANG_ObjC:
120   case dwarf::DW_LANG_ObjC_plus_plus:
121     if (DD->getDwarfVersion() >= 3)
122       return 0;
123     break;
124 
125   case dwarf::DW_LANG_Fortran95:
126     if (DD->getDwarfVersion() >= 3)
127       return 1;
128     break;
129 
130   // Starting with DWARF v4, all defined languages have valid values.
131   case dwarf::DW_LANG_D:
132   case dwarf::DW_LANG_Java:
133   case dwarf::DW_LANG_Python:
134   case dwarf::DW_LANG_UPC:
135     if (DD->getDwarfVersion() >= 4)
136       return 0;
137     break;
138 
139   case dwarf::DW_LANG_Ada83:
140   case dwarf::DW_LANG_Ada95:
141   case dwarf::DW_LANG_Cobol74:
142   case dwarf::DW_LANG_Cobol85:
143   case dwarf::DW_LANG_Modula2:
144   case dwarf::DW_LANG_Pascal83:
145   case dwarf::DW_LANG_PLI:
146     if (DD->getDwarfVersion() >= 4)
147       return 1;
148     break;
149 
150   // The languages below are new in DWARF v5.
151   case dwarf::DW_LANG_BLISS:
152   case dwarf::DW_LANG_C11:
153   case dwarf::DW_LANG_C_plus_plus_03:
154   case dwarf::DW_LANG_C_plus_plus_11:
155   case dwarf::DW_LANG_C_plus_plus_14:
156   case dwarf::DW_LANG_Dylan:
157   case dwarf::DW_LANG_Go:
158   case dwarf::DW_LANG_Haskell:
159   case dwarf::DW_LANG_OCaml:
160   case dwarf::DW_LANG_OpenCL:
161   case dwarf::DW_LANG_RenderScript:
162   case dwarf::DW_LANG_Rust:
163   case dwarf::DW_LANG_Swift:
164     if (DD->getDwarfVersion() >= 5)
165       return 0;
166     break;
167 
168   case dwarf::DW_LANG_Fortran03:
169   case dwarf::DW_LANG_Fortran08:
170   case dwarf::DW_LANG_Julia:
171   case dwarf::DW_LANG_Modula3:
172     if (DD->getDwarfVersion() >= 5)
173       return 1;
174     break;
175   }
176 
177   return -1;
178 }
179 
180 /// Check whether the DIE for this MDNode can be shared across CUs.
181 bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const {
182   // When the MDNode can be part of the type system, the DIE can be shared
183   // across CUs.
184   // Combining type units and cross-CU DIE sharing is lower value (since
185   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
186   // level already) but may be implementable for some value in projects
187   // building multiple independent libraries with LTO and then linking those
188   // together.
189   if (isDwoUnit() && !DD->shareAcrossDWOCUs())
190     return false;
191   return (isa<DIType>(D) ||
192           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
193          !DD->generateTypeUnits();
194 }
195 
196 DIE *DwarfUnit::getDIE(const DINode *D) const {
197   if (isShareableAcrossCUs(D))
198     return DU->getDIE(D);
199   return MDNodeToDieMap.lookup(D);
200 }
201 
202 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
203   if (isShareableAcrossCUs(Desc)) {
204     DU->insertDIE(Desc, D);
205     return;
206   }
207   MDNodeToDieMap.insert(std::make_pair(Desc, D));
208 }
209 
210 void DwarfUnit::insertDIE(DIE *D) {
211   MDNodeToDieMap.insert(std::make_pair(nullptr, D));
212 }
213 
214 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
215   if (DD->getDwarfVersion() >= 4)
216     addAttribute(Die, Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
217   else
218     addAttribute(Die, Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
219 }
220 
221 void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
222                         Optional<dwarf::Form> Form, uint64_t Integer) {
223   if (!Form)
224     Form = DIEInteger::BestForm(false, Integer);
225   assert(Form != dwarf::DW_FORM_implicit_const &&
226          "DW_FORM_implicit_const is used only for signed integers");
227   addAttribute(Die, Attribute, *Form, DIEInteger(Integer));
228 }
229 
230 void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
231                         uint64_t Integer) {
232   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
233 }
234 
235 void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
236                         Optional<dwarf::Form> Form, int64_t Integer) {
237   if (!Form)
238     Form = DIEInteger::BestForm(true, Integer);
239   addAttribute(Die, Attribute, *Form, DIEInteger(Integer));
240 }
241 
242 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
243                         int64_t Integer) {
244   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
245 }
246 
247 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
248                           StringRef String) {
249   if (CUNode->isDebugDirectivesOnly())
250     return;
251 
252   if (DD->useInlineStrings()) {
253     addAttribute(Die, Attribute, dwarf::DW_FORM_string,
254                  new (DIEValueAllocator)
255                      DIEInlineString(String, DIEValueAllocator));
256     return;
257   }
258   dwarf::Form IxForm =
259       isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
260 
261   auto StringPoolEntry =
262       useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index
263           ? DU->getStringPool().getIndexedEntry(*Asm, String)
264           : DU->getStringPool().getEntry(*Asm, String);
265 
266   // For DWARF v5 and beyond, use the smallest strx? form possible.
267   if (useSegmentedStringOffsetsTable()) {
268     IxForm = dwarf::DW_FORM_strx1;
269     unsigned Index = StringPoolEntry.getIndex();
270     if (Index > 0xffffff)
271       IxForm = dwarf::DW_FORM_strx4;
272     else if (Index > 0xffff)
273       IxForm = dwarf::DW_FORM_strx3;
274     else if (Index > 0xff)
275       IxForm = dwarf::DW_FORM_strx2;
276   }
277   addAttribute(Die, Attribute, IxForm, DIEString(StringPoolEntry));
278 }
279 
280 void DwarfUnit::addLabel(DIEValueList &Die, dwarf::Attribute Attribute,
281                          dwarf::Form Form, const MCSymbol *Label) {
282   addAttribute(Die, Attribute, Form, DIELabel(Label));
283 }
284 
285 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
286   addLabel(Die, (dwarf::Attribute)0, Form, Label);
287 }
288 
289 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
290                                  uint64_t Integer) {
291   addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer);
292 }
293 
294 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
295   if (!SplitLineTable)
296     return getCU().getOrCreateSourceID(File);
297   if (!UsedLineTable) {
298     UsedLineTable = true;
299     // This is a split type unit that needs a line table.
300     addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
301   }
302   return SplitLineTable->getFile(
303       File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
304       Asm->OutContext.getDwarfVersion(), File->getSource());
305 }
306 
307 void DwarfUnit::addPoolOpAddress(DIEValueList &Die, const MCSymbol *Label) {
308   bool UseAddrOffsetFormOrExpressions =
309       DD->useAddrOffsetForm() || DD->useAddrOffsetExpressions();
310 
311   const MCSymbol *Base = nullptr;
312   if (Label->isInSection() && UseAddrOffsetFormOrExpressions)
313     Base = DD->getSectionLabel(&Label->getSection());
314 
315   uint32_t Index = DD->getAddressPool().getIndex(Base ? Base : Label);
316 
317   if (DD->getDwarfVersion() >= 5) {
318     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
319     addUInt(Die, dwarf::DW_FORM_addrx, Index);
320   } else {
321     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
322     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, Index);
323   }
324 
325   if (Base && Base != Label) {
326     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_const4u);
327     addLabelDelta(Die, (dwarf::Attribute)0, Label, Base);
328     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
329   }
330 }
331 
332 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
333   if (DD->getDwarfVersion() >= 5) {
334     addPoolOpAddress(Die, Sym);
335     return;
336   }
337 
338   if (DD->useSplitDwarf()) {
339     addPoolOpAddress(Die, Sym);
340     return;
341   }
342 
343   addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
344   addLabel(Die, dwarf::DW_FORM_addr, Sym);
345 }
346 
347 void DwarfUnit::addLabelDelta(DIEValueList &Die, dwarf::Attribute Attribute,
348                               const MCSymbol *Hi, const MCSymbol *Lo) {
349   addAttribute(Die, Attribute, dwarf::DW_FORM_data4,
350                new (DIEValueAllocator) DIEDelta(Hi, Lo));
351 }
352 
353 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
354   addDIEEntry(Die, Attribute, DIEEntry(Entry));
355 }
356 
357 void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
358   // Flag the type unit reference as a declaration so that if it contains
359   // members (implicit special members, static data member definitions, member
360   // declarations for definitions in this CU, etc) consumers don't get confused
361   // and think this is a full definition.
362   addFlag(Die, dwarf::DW_AT_declaration);
363 
364   addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
365                DIEInteger(Signature));
366 }
367 
368 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
369                             DIEEntry Entry) {
370   const DIEUnit *CU = Die.getUnit();
371   const DIEUnit *EntryCU = Entry.getEntry().getUnit();
372   if (!CU)
373     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
374     CU = getUnitDie().getUnit();
375   if (!EntryCU)
376     EntryCU = getUnitDie().getUnit();
377   assert(EntryCU == CU || !DD->useSplitDwarf() || DD->shareAcrossDWOCUs() ||
378          !static_cast<const DwarfUnit*>(CU)->isDwoUnit());
379   addAttribute(Die, Attribute,
380                EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
381                Entry);
382 }
383 
384 DIE &DwarfUnit::createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N) {
385   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag));
386   if (N)
387     insertDIE(N, &Die);
388   return Die;
389 }
390 
391 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
392   Loc->computeSize(Asm->getDwarfFormParams());
393   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
394   addAttribute(Die, Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
395 }
396 
397 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
398                          DIEBlock *Block) {
399   Block->computeSize(Asm->getDwarfFormParams());
400   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
401   addAttribute(Die, Attribute, Form, Block);
402 }
403 
404 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
405                          DIEBlock *Block) {
406   addBlock(Die, Attribute, Block->BestForm(), Block);
407 }
408 
409 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
410   if (Line == 0)
411     return;
412 
413   unsigned FileID = getOrCreateSourceID(File);
414   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
415   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
416 }
417 
418 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
419   assert(V);
420 
421   addSourceLine(Die, V->getLine(), V->getFile());
422 }
423 
424 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
425   assert(G);
426 
427   addSourceLine(Die, G->getLine(), G->getFile());
428 }
429 
430 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
431   assert(SP);
432 
433   addSourceLine(Die, SP->getLine(), SP->getFile());
434 }
435 
436 void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) {
437   assert(L);
438 
439   addSourceLine(Die, L->getLine(), L->getFile());
440 }
441 
442 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
443   assert(Ty);
444 
445   addSourceLine(Die, Ty->getLine(), Ty->getFile());
446 }
447 
448 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
449   assert(Ty);
450 
451   addSourceLine(Die, Ty->getLine(), Ty->getFile());
452 }
453 
454 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
455   // Pass this down to addConstantValue as an unsigned bag of bits.
456   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
457 }
458 
459 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
460                                  const DIType *Ty) {
461   addConstantValue(Die, CI->getValue(), Ty);
462 }
463 
464 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
465   addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
466 }
467 
468 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
469   // FIXME: This is a bit conservative/simple - it emits negative values always
470   // sign extended to 64 bits rather than minimizing the number of bytes.
471   addUInt(Die, dwarf::DW_AT_const_value,
472           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
473 }
474 
475 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
476   addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
477 }
478 
479 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
480   unsigned CIBitWidth = Val.getBitWidth();
481   if (CIBitWidth <= 64) {
482     addConstantValue(Die, Unsigned,
483                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
484     return;
485   }
486 
487   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
488 
489   // Get the raw data form of the large APInt.
490   const uint64_t *Ptr64 = Val.getRawData();
491 
492   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
493   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
494 
495   // Output the constant to DWARF one byte at a time.
496   for (int i = 0; i < NumBytes; i++) {
497     uint8_t c;
498     if (LittleEndian)
499       c = Ptr64[i / 8] >> (8 * (i & 7));
500     else
501       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
502     addUInt(*Block, dwarf::DW_FORM_data1, c);
503   }
504 
505   addBlock(Die, dwarf::DW_AT_const_value, Block);
506 }
507 
508 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
509   if (!LinkageName.empty())
510     addString(Die,
511               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
512                                          : dwarf::DW_AT_MIPS_linkage_name,
513               GlobalValue::dropLLVMManglingEscape(LinkageName));
514 }
515 
516 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
517   // Add template parameters.
518   for (const auto *Element : TParams) {
519     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
520       constructTemplateTypeParameterDIE(Buffer, TTP);
521     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
522       constructTemplateValueParameterDIE(Buffer, TVP);
523   }
524 }
525 
526 /// Add thrown types.
527 void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
528   for (const auto *Ty : ThrownTypes) {
529     DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
530     addType(TT, cast<DIType>(Ty));
531   }
532 }
533 
534 void DwarfUnit::addAccess(DIE &Die, DINode::DIFlags Flags) {
535   if ((Flags & DINode::FlagAccessibility) == DINode::FlagProtected)
536     addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
537             dwarf::DW_ACCESS_protected);
538   else if ((Flags & DINode::FlagAccessibility) == DINode::FlagPrivate)
539     addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
540             dwarf::DW_ACCESS_private);
541   else if ((Flags & DINode::FlagAccessibility) == DINode::FlagPublic)
542     addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
543             dwarf::DW_ACCESS_public);
544 }
545 
546 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
547   if (!Context || isa<DIFile>(Context))
548     return &getUnitDie();
549   if (auto *T = dyn_cast<DIType>(Context))
550     return getOrCreateTypeDIE(T);
551   if (auto *NS = dyn_cast<DINamespace>(Context))
552     return getOrCreateNameSpace(NS);
553   if (auto *SP = dyn_cast<DISubprogram>(Context))
554     return getOrCreateSubprogramDIE(SP);
555   if (auto *M = dyn_cast<DIModule>(Context))
556     return getOrCreateModule(M);
557   return getDIE(Context);
558 }
559 
560 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
561   auto *Context = Ty->getScope();
562   DIE *ContextDIE = getOrCreateContextDIE(Context);
563 
564   if (DIE *TyDIE = getDIE(Ty))
565     return TyDIE;
566 
567   // Create new type.
568   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
569 
570   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
571 
572   updateAcceleratorTables(Context, Ty, TyDIE);
573   return &TyDIE;
574 }
575 
576 DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
577                               const DIType *Ty) {
578   // Create new type.
579   DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty);
580 
581   updateAcceleratorTables(Context, Ty, TyDIE);
582 
583   if (auto *BT = dyn_cast<DIBasicType>(Ty))
584     constructTypeDIE(TyDIE, BT);
585   else if (auto *ST = dyn_cast<DIStringType>(Ty))
586     constructTypeDIE(TyDIE, ST);
587   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
588     constructTypeDIE(TyDIE, STy);
589   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
590     if (DD->generateTypeUnits() && !Ty->isForwardDecl() &&
591         (Ty->getRawName() || CTy->getRawIdentifier())) {
592       // Skip updating the accelerator tables since this is not the full type.
593       if (MDString *TypeId = CTy->getRawIdentifier())
594         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
595       else
596         finishNonUnitTypeDIE(TyDIE, CTy);
597       return &TyDIE;
598     }
599     constructTypeDIE(TyDIE, CTy);
600   } else {
601     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
602   }
603 
604   return &TyDIE;
605 }
606 
607 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
608   if (!TyNode)
609     return nullptr;
610 
611   auto *Ty = cast<DIType>(TyNode);
612 
613   // DW_TAG_restrict_type is not supported in DWARF2
614   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
615     return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
616 
617   // DW_TAG_atomic_type is not supported in DWARF < 5
618   if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
619     return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
620 
621   // Construct the context before querying for the existence of the DIE in case
622   // such construction creates the DIE.
623   auto *Context = Ty->getScope();
624   DIE *ContextDIE = getOrCreateContextDIE(Context);
625   assert(ContextDIE);
626 
627   if (DIE *TyDIE = getDIE(Ty))
628     return TyDIE;
629 
630   return static_cast<DwarfUnit *>(ContextDIE->getUnit())
631       ->createTypeDIE(Context, *ContextDIE, Ty);
632 }
633 
634 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
635                                         const DIType *Ty, const DIE &TyDIE) {
636   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
637     bool IsImplementation = false;
638     if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
639       // A runtime language of 0 actually means C/C++ and that any
640       // non-negative value is some version of Objective-C/C++.
641       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
642     }
643     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
644     DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags);
645 
646     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
647         isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
648       addGlobalType(Ty, TyDIE, Context);
649   }
650 }
651 
652 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
653                         dwarf::Attribute Attribute) {
654   assert(Ty && "Trying to add a type that doesn't exist?");
655   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
656 }
657 
658 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
659   if (!Context)
660     return "";
661 
662   // FIXME: Decide whether to implement this for non-C++ languages.
663   if (!dwarf::isCPlusPlus((dwarf::SourceLanguage)getLanguage()))
664     return "";
665 
666   std::string CS;
667   SmallVector<const DIScope *, 1> Parents;
668   while (!isa<DICompileUnit>(Context)) {
669     Parents.push_back(Context);
670     if (const DIScope *S = Context->getScope())
671       Context = S;
672     else
673       // Structure, etc types will have a NULL context if they're at the top
674       // level.
675       break;
676   }
677 
678   // Reverse iterate over our list to go from the outermost construct to the
679   // innermost.
680   for (const DIScope *Ctx : llvm::reverse(Parents)) {
681     StringRef Name = Ctx->getName();
682     if (Name.empty() && isa<DINamespace>(Ctx))
683       Name = "(anonymous namespace)";
684     if (!Name.empty()) {
685       CS += Name;
686       CS += "::";
687     }
688   }
689   return CS;
690 }
691 
692 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
693   // Get core information.
694   StringRef Name = BTy->getName();
695   // Add name if not anonymous or intermediate type.
696   if (!Name.empty())
697     addString(Buffer, dwarf::DW_AT_name, Name);
698 
699   // An unspecified type only has a name attribute.
700   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
701     return;
702 
703   if (BTy->getTag() != dwarf::DW_TAG_string_type)
704     addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
705             BTy->getEncoding());
706 
707   uint64_t Size = BTy->getSizeInBits() >> 3;
708   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
709 
710   if (BTy->isBigEndian())
711     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big);
712   else if (BTy->isLittleEndian())
713     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
714 }
715 
716 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
717   // Get core information.
718   StringRef Name = STy->getName();
719   // Add name if not anonymous or intermediate type.
720   if (!Name.empty())
721     addString(Buffer, dwarf::DW_AT_name, Name);
722 
723   if (DIVariable *Var = STy->getStringLength()) {
724     if (auto *VarDIE = getDIE(Var))
725       addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
726   } else if (DIExpression *Expr = STy->getStringLengthExp()) {
727     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
728     DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
729     // This is to describe the memory location of the
730     // length of a Fortran deferred length string, so
731     // lock it down as such.
732     DwarfExpr.setMemoryLocationKind();
733     DwarfExpr.addExpression(Expr);
734     addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
735   } else {
736     uint64_t Size = STy->getSizeInBits() >> 3;
737     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
738   }
739 
740   if (DIExpression *Expr = STy->getStringLocationExp()) {
741     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
742     DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
743     // This is to describe the memory location of the
744     // string, so lock it down as such.
745     DwarfExpr.setMemoryLocationKind();
746     DwarfExpr.addExpression(Expr);
747     addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
748   }
749 
750   if (STy->getEncoding()) {
751     // For eventual Unicode support.
752     addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
753             STy->getEncoding());
754   }
755 }
756 
757 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
758   // Get core information.
759   StringRef Name = DTy->getName();
760   uint64_t Size = DTy->getSizeInBits() >> 3;
761   uint16_t Tag = Buffer.getTag();
762 
763   // Map to main type, void will not have a type.
764   const DIType *FromTy = DTy->getBaseType();
765   if (FromTy)
766     addType(Buffer, FromTy);
767 
768   // Add name if not anonymous or intermediate type.
769   if (!Name.empty())
770     addString(Buffer, dwarf::DW_AT_name, Name);
771 
772   addAnnotation(Buffer, DTy->getAnnotations());
773 
774   // If alignment is specified for a typedef , create and insert DW_AT_alignment
775   // attribute in DW_TAG_typedef DIE.
776   if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) {
777     uint32_t AlignInBytes = DTy->getAlignInBytes();
778     if (AlignInBytes > 0)
779       addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
780               AlignInBytes);
781   }
782 
783   // Add size if non-zero (derived types might be zero-sized.)
784   if (Size && Tag != dwarf::DW_TAG_pointer_type
785            && Tag != dwarf::DW_TAG_ptr_to_member_type
786            && Tag != dwarf::DW_TAG_reference_type
787            && Tag != dwarf::DW_TAG_rvalue_reference_type)
788     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
789 
790   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
791     addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
792                 *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType()));
793   // Add source line info if available and TyDesc is not a forward declaration.
794   if (!DTy->isForwardDecl())
795     addSourceLine(Buffer, DTy);
796 
797   // If DWARF address space value is other than None, add it.  The IR
798   // verifier checks that DWARF address space only exists for pointer
799   // or reference types.
800   if (DTy->getDWARFAddressSpace())
801     addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
802             *DTy->getDWARFAddressSpace());
803 }
804 
805 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
806   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
807     const DIType *Ty = Args[i];
808     if (!Ty) {
809       assert(i == N-1 && "Unspecified parameter must be the last argument");
810       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
811     } else {
812       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
813       addType(Arg, Ty);
814       if (Ty->isArtificial())
815         addFlag(Arg, dwarf::DW_AT_artificial);
816     }
817   }
818 }
819 
820 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
821   // Add return type.  A void return won't have a type.
822   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
823   if (Elements.size())
824     if (auto RTy = Elements[0])
825       addType(Buffer, RTy);
826 
827   bool isPrototyped = true;
828   if (Elements.size() == 2 && !Elements[1])
829     isPrototyped = false;
830 
831   constructSubprogramArguments(Buffer, Elements);
832 
833   // Add prototype flag if we're dealing with a C language and the function has
834   // been prototyped.
835   uint16_t Language = getLanguage();
836   if (isPrototyped &&
837       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
838        Language == dwarf::DW_LANG_ObjC))
839     addFlag(Buffer, dwarf::DW_AT_prototyped);
840 
841   // Add a DW_AT_calling_convention if this has an explicit convention.
842   if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
843     addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
844             CTy->getCC());
845 
846   if (CTy->isLValueReference())
847     addFlag(Buffer, dwarf::DW_AT_reference);
848 
849   if (CTy->isRValueReference())
850     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
851 }
852 
853 void DwarfUnit::addAnnotation(DIE &Buffer, DINodeArray Annotations) {
854   if (!Annotations)
855     return;
856 
857   for (const Metadata *Annotation : Annotations->operands()) {
858     const MDNode *MD = cast<MDNode>(Annotation);
859     const MDString *Name = cast<MDString>(MD->getOperand(0));
860     const auto &Value = MD->getOperand(1);
861 
862     DIE &AnnotationDie = createAndAddDIE(dwarf::DW_TAG_LLVM_annotation, Buffer);
863     addString(AnnotationDie, dwarf::DW_AT_name, Name->getString());
864     if (const auto *Data = dyn_cast<MDString>(Value))
865       addString(AnnotationDie, dwarf::DW_AT_const_value, Data->getString());
866     else if (const auto *Data = dyn_cast<ConstantAsMetadata>(Value))
867       addConstantValue(AnnotationDie, Data->getValue()->getUniqueInteger(),
868                        /*Unsigned=*/true);
869     else
870       assert(false && "Unsupported annotation value type");
871   }
872 }
873 
874 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
875   // Add name if not anonymous or intermediate type.
876   StringRef Name = CTy->getName();
877 
878   uint64_t Size = CTy->getSizeInBits() >> 3;
879   uint16_t Tag = Buffer.getTag();
880 
881   switch (Tag) {
882   case dwarf::DW_TAG_array_type:
883     constructArrayTypeDIE(Buffer, CTy);
884     break;
885   case dwarf::DW_TAG_enumeration_type:
886     constructEnumTypeDIE(Buffer, CTy);
887     break;
888   case dwarf::DW_TAG_variant_part:
889   case dwarf::DW_TAG_structure_type:
890   case dwarf::DW_TAG_union_type:
891   case dwarf::DW_TAG_class_type:
892   case dwarf::DW_TAG_namelist: {
893     // Emit the discriminator for a variant part.
894     DIDerivedType *Discriminator = nullptr;
895     if (Tag == dwarf::DW_TAG_variant_part) {
896       Discriminator = CTy->getDiscriminator();
897       if (Discriminator) {
898         // DWARF says:
899         //    If the variant part has a discriminant, the discriminant is
900         //    represented by a separate debugging information entry which is
901         //    a child of the variant part entry.
902         DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
903         addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
904       }
905     }
906 
907     // Add template parameters to a class, structure or union types.
908     if (Tag == dwarf::DW_TAG_class_type ||
909         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
910       addTemplateParams(Buffer, CTy->getTemplateParams());
911 
912     // Add elements to structure type.
913     DINodeArray Elements = CTy->getElements();
914     for (const auto *Element : Elements) {
915       if (!Element)
916         continue;
917       if (auto *SP = dyn_cast<DISubprogram>(Element))
918         getOrCreateSubprogramDIE(SP);
919       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
920         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
921           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
922           addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
923         } else if (DDTy->isStaticMember()) {
924           getOrCreateStaticMemberDIE(DDTy);
925         } else if (Tag == dwarf::DW_TAG_variant_part) {
926           // When emitting a variant part, wrap each member in
927           // DW_TAG_variant.
928           DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
929           if (const ConstantInt *CI =
930               dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
931             if (DD->isUnsignedDIType(Discriminator->getBaseType()))
932               addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
933             else
934               addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
935           }
936           constructMemberDIE(Variant, DDTy);
937         } else {
938           constructMemberDIE(Buffer, DDTy);
939         }
940       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
941         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
942         StringRef PropertyName = Property->getName();
943         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
944         if (Property->getType())
945           addType(ElemDie, Property->getType());
946         addSourceLine(ElemDie, Property);
947         StringRef GetterName = Property->getGetterName();
948         if (!GetterName.empty())
949           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
950         StringRef SetterName = Property->getSetterName();
951         if (!SetterName.empty())
952           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
953         if (unsigned PropertyAttributes = Property->getAttributes())
954           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
955                   PropertyAttributes);
956       } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
957         if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
958           DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
959           constructTypeDIE(VariantPart, Composite);
960         }
961       } else if (Tag == dwarf::DW_TAG_namelist) {
962         auto *Var = dyn_cast<DINode>(Element);
963         auto *VarDIE = getDIE(Var);
964         if (VarDIE) {
965           DIE &ItemDie = createAndAddDIE(dwarf::DW_TAG_namelist_item, Buffer);
966           addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
967         }
968       }
969     }
970 
971     if (CTy->isAppleBlockExtension())
972       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
973 
974     if (CTy->getExportSymbols())
975       addFlag(Buffer, dwarf::DW_AT_export_symbols);
976 
977     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
978     // inside C++ composite types to point to the base class with the vtable.
979     // Rust uses DW_AT_containing_type to link a vtable to the type
980     // for which it was created.
981     if (auto *ContainingType = CTy->getVTableHolder())
982       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
983                   *getOrCreateTypeDIE(ContainingType));
984 
985     if (CTy->isObjcClassComplete())
986       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
987 
988     // Add the type's non-standard calling convention.
989     // DW_CC_pass_by_value/DW_CC_pass_by_reference are introduced in DWARF 5.
990     if (!Asm->TM.Options.DebugStrictDwarf || DD->getDwarfVersion() >= 5) {
991       uint8_t CC = 0;
992       if (CTy->isTypePassByValue())
993         CC = dwarf::DW_CC_pass_by_value;
994       else if (CTy->isTypePassByReference())
995         CC = dwarf::DW_CC_pass_by_reference;
996       if (CC)
997         addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
998                 CC);
999     }
1000     break;
1001   }
1002   default:
1003     break;
1004   }
1005 
1006   // Add name if not anonymous or intermediate type.
1007   if (!Name.empty())
1008     addString(Buffer, dwarf::DW_AT_name, Name);
1009 
1010   addAnnotation(Buffer, CTy->getAnnotations());
1011 
1012   if (Tag == dwarf::DW_TAG_enumeration_type ||
1013       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1014       Tag == dwarf::DW_TAG_union_type) {
1015     // Add size if non-zero (derived types might be zero-sized.)
1016     // Ignore the size if it's a non-enum forward decl.
1017     // TODO: Do we care about size for enum forward declarations?
1018     if (Size &&
1019         (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
1020       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
1021     else if (!CTy->isForwardDecl())
1022       // Add zero size if it is not a forward declaration.
1023       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
1024 
1025     // If we're a forward decl, say so.
1026     if (CTy->isForwardDecl())
1027       addFlag(Buffer, dwarf::DW_AT_declaration);
1028 
1029     // Add accessibility info if available.
1030     addAccess(Buffer, CTy->getFlags());
1031 
1032     // Add source line info if available.
1033     if (!CTy->isForwardDecl())
1034       addSourceLine(Buffer, CTy);
1035 
1036     // No harm in adding the runtime language to the declaration.
1037     unsigned RLang = CTy->getRuntimeLang();
1038     if (RLang)
1039       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1040               RLang);
1041 
1042     // Add align info if available.
1043     if (uint32_t AlignInBytes = CTy->getAlignInBytes())
1044       addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1045               AlignInBytes);
1046   }
1047 }
1048 
1049 void DwarfUnit::constructTemplateTypeParameterDIE(
1050     DIE &Buffer, const DITemplateTypeParameter *TP) {
1051   DIE &ParamDIE =
1052       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1053   // Add the type if it exists, it could be void and therefore no type.
1054   if (TP->getType())
1055     addType(ParamDIE, TP->getType());
1056   if (!TP->getName().empty())
1057     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1058   if (TP->isDefault() && (DD->getDwarfVersion() >= 5))
1059     addFlag(ParamDIE, dwarf::DW_AT_default_value);
1060 }
1061 
1062 void DwarfUnit::constructTemplateValueParameterDIE(
1063     DIE &Buffer, const DITemplateValueParameter *VP) {
1064   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1065 
1066   // Add the type if there is one, template template and template parameter
1067   // packs will not have a type.
1068   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1069     addType(ParamDIE, VP->getType());
1070   if (!VP->getName().empty())
1071     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1072   if (VP->isDefault() && (DD->getDwarfVersion() >= 5))
1073     addFlag(ParamDIE, dwarf::DW_AT_default_value);
1074   if (Metadata *Val = VP->getValue()) {
1075     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1076       addConstantValue(ParamDIE, CI, VP->getType());
1077     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1078       // We cannot describe the location of dllimport'd entities: the
1079       // computation of their address requires loads from the IAT.
1080       if (!GV->hasDLLImportStorageClass()) {
1081         // For declaration non-type template parameters (such as global values
1082         // and functions)
1083         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1084         addOpAddress(*Loc, Asm->getSymbol(GV));
1085         // Emit DW_OP_stack_value to use the address as the immediate value of
1086         // the parameter, rather than a pointer to it.
1087         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1088         addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1089       }
1090     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1091       assert(isa<MDString>(Val));
1092       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1093                 cast<MDString>(Val)->getString());
1094     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1095       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1096     }
1097   }
1098 }
1099 
1100 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1101   // Construct the context before querying for the existence of the DIE in case
1102   // such construction creates the DIE.
1103   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1104 
1105   if (DIE *NDie = getDIE(NS))
1106     return NDie;
1107   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1108 
1109   StringRef Name = NS->getName();
1110   if (!Name.empty())
1111     addString(NDie, dwarf::DW_AT_name, NS->getName());
1112   else
1113     Name = "(anonymous namespace)";
1114   DD->addAccelNamespace(*CUNode, Name, NDie);
1115   addGlobalName(Name, NDie, NS->getScope());
1116   if (NS->getExportSymbols())
1117     addFlag(NDie, dwarf::DW_AT_export_symbols);
1118   return &NDie;
1119 }
1120 
1121 DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
1122   // Construct the context before querying for the existence of the DIE in case
1123   // such construction creates the DIE.
1124   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
1125 
1126   if (DIE *MDie = getDIE(M))
1127     return MDie;
1128   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
1129 
1130   if (!M->getName().empty()) {
1131     addString(MDie, dwarf::DW_AT_name, M->getName());
1132     addGlobalName(M->getName(), MDie, M->getScope());
1133   }
1134   if (!M->getConfigurationMacros().empty())
1135     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1136               M->getConfigurationMacros());
1137   if (!M->getIncludePath().empty())
1138     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1139   if (!M->getAPINotesFile().empty())
1140     addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
1141   if (M->getFile())
1142     addUInt(MDie, dwarf::DW_AT_decl_file, None,
1143             getOrCreateSourceID(M->getFile()));
1144   if (M->getLineNo())
1145     addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo());
1146   if (M->getIsDecl())
1147     addFlag(MDie, dwarf::DW_AT_declaration);
1148 
1149   return &MDie;
1150 }
1151 
1152 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1153   // Construct the context before querying for the existence of the DIE in case
1154   // such construction creates the DIE (as is the case for member function
1155   // declarations).
1156   DIE *ContextDIE =
1157       Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope());
1158 
1159   if (DIE *SPDie = getDIE(SP))
1160     return SPDie;
1161 
1162   if (auto *SPDecl = SP->getDeclaration()) {
1163     if (!Minimal) {
1164       // Add subprogram definitions to the CU die directly.
1165       ContextDIE = &getUnitDie();
1166       // Build the decl now to ensure it precedes the definition.
1167       getOrCreateSubprogramDIE(SPDecl);
1168     }
1169   }
1170 
1171   // DW_TAG_inlined_subroutine may refer to this DIE.
1172   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1173 
1174   // Stop here and fill this in later, depending on whether or not this
1175   // subprogram turns out to have inlined instances or not.
1176   if (SP->isDefinition())
1177     return &SPDie;
1178 
1179   static_cast<DwarfUnit *>(SPDie.getUnit())
1180       ->applySubprogramAttributes(SP, SPDie);
1181   return &SPDie;
1182 }
1183 
1184 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1185                                                     DIE &SPDie, bool Minimal) {
1186   DIE *DeclDie = nullptr;
1187   StringRef DeclLinkageName;
1188   if (auto *SPDecl = SP->getDeclaration()) {
1189     if (!Minimal) {
1190       DITypeRefArray DeclArgs, DefinitionArgs;
1191       DeclArgs = SPDecl->getType()->getTypeArray();
1192       DefinitionArgs = SP->getType()->getTypeArray();
1193 
1194       if (DeclArgs.size() && DefinitionArgs.size())
1195         if (DefinitionArgs[0] != nullptr && DeclArgs[0] != DefinitionArgs[0])
1196           addType(SPDie, DefinitionArgs[0]);
1197 
1198       DeclDie = getDIE(SPDecl);
1199       assert(DeclDie && "This DIE should've already been constructed when the "
1200                         "definition DIE was created in "
1201                         "getOrCreateSubprogramDIE");
1202       // Look at the Decl's linkage name only if we emitted it.
1203       if (DD->useAllLinkageNames())
1204         DeclLinkageName = SPDecl->getLinkageName();
1205       unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
1206       unsigned DefID = getOrCreateSourceID(SP->getFile());
1207       if (DeclID != DefID)
1208         addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
1209 
1210       if (SP->getLine() != SPDecl->getLine())
1211         addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
1212     }
1213   }
1214 
1215   // Add function template parameters.
1216   addTemplateParams(SPDie, SP->getTemplateParams());
1217 
1218   // Add the linkage name if we have one and it isn't in the Decl.
1219   StringRef LinkageName = SP->getLinkageName();
1220   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1221           LinkageName == DeclLinkageName) &&
1222          "decl has a linkage name and it is different");
1223   if (DeclLinkageName.empty() &&
1224       // Always emit it for abstract subprograms.
1225       (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
1226     addLinkageName(SPDie, LinkageName);
1227 
1228   if (!DeclDie)
1229     return false;
1230 
1231   // Refer to the function declaration where all the other attributes will be
1232   // found.
1233   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1234   return true;
1235 }
1236 
1237 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1238                                           bool SkipSPAttributes) {
1239   // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
1240   // and its source location.
1241   bool SkipSPSourceLocation = SkipSPAttributes &&
1242                               !CUNode->getDebugInfoForProfiling();
1243   if (!SkipSPSourceLocation)
1244     if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes))
1245       return;
1246 
1247   // Constructors and operators for anonymous aggregates do not have names.
1248   if (!SP->getName().empty())
1249     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1250 
1251   addAnnotation(SPDie, SP->getAnnotations());
1252 
1253   if (!SkipSPSourceLocation)
1254     addSourceLine(SPDie, SP);
1255 
1256   // Skip the rest of the attributes under -gmlt to save space.
1257   if (SkipSPAttributes)
1258     return;
1259 
1260   // Add the prototype if we have a prototype and we have a C like
1261   // language.
1262   uint16_t Language = getLanguage();
1263   if (SP->isPrototyped() &&
1264       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1265        Language == dwarf::DW_LANG_ObjC))
1266     addFlag(SPDie, dwarf::DW_AT_prototyped);
1267 
1268   if (SP->isObjCDirect())
1269     addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
1270 
1271   unsigned CC = 0;
1272   DITypeRefArray Args;
1273   if (const DISubroutineType *SPTy = SP->getType()) {
1274     Args = SPTy->getTypeArray();
1275     CC = SPTy->getCC();
1276   }
1277 
1278   // Add a DW_AT_calling_convention if this has an explicit convention.
1279   if (CC && CC != dwarf::DW_CC_normal)
1280     addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1281 
1282   // Add a return type. If this is a type like a C/C++ void type we don't add a
1283   // return type.
1284   if (Args.size())
1285     if (auto Ty = Args[0])
1286       addType(SPDie, Ty);
1287 
1288   unsigned VK = SP->getVirtuality();
1289   if (VK) {
1290     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1291     if (SP->getVirtualIndex() != -1u) {
1292       DIELoc *Block = getDIELoc();
1293       addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1294       addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1295       addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1296     }
1297     ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType()));
1298   }
1299 
1300   if (!SP->isDefinition()) {
1301     addFlag(SPDie, dwarf::DW_AT_declaration);
1302 
1303     // Add arguments. Do not add arguments for subprogram definition. They will
1304     // be handled while processing variables.
1305     constructSubprogramArguments(SPDie, Args);
1306   }
1307 
1308   addThrownTypes(SPDie, SP->getThrownTypes());
1309 
1310   if (SP->isArtificial())
1311     addFlag(SPDie, dwarf::DW_AT_artificial);
1312 
1313   if (!SP->isLocalToUnit())
1314     addFlag(SPDie, dwarf::DW_AT_external);
1315 
1316   if (DD->useAppleExtensionAttributes()) {
1317     if (SP->isOptimized())
1318       addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1319 
1320     if (unsigned isa = Asm->getISAEncoding())
1321       addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1322   }
1323 
1324   if (SP->isLValueReference())
1325     addFlag(SPDie, dwarf::DW_AT_reference);
1326 
1327   if (SP->isRValueReference())
1328     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1329 
1330   if (SP->isNoReturn())
1331     addFlag(SPDie, dwarf::DW_AT_noreturn);
1332 
1333   addAccess(SPDie, SP->getFlags());
1334 
1335   if (SP->isExplicit())
1336     addFlag(SPDie, dwarf::DW_AT_explicit);
1337 
1338   if (SP->isMainSubprogram())
1339     addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1340   if (SP->isPure())
1341     addFlag(SPDie, dwarf::DW_AT_pure);
1342   if (SP->isElemental())
1343     addFlag(SPDie, dwarf::DW_AT_elemental);
1344   if (SP->isRecursive())
1345     addFlag(SPDie, dwarf::DW_AT_recursive);
1346 
1347   if (!SP->getTargetFuncName().empty())
1348     addString(SPDie, dwarf::DW_AT_trampoline, SP->getTargetFuncName());
1349 
1350   if (DD->getDwarfVersion() >= 5 && SP->isDeleted())
1351     addFlag(SPDie, dwarf::DW_AT_deleted);
1352 }
1353 
1354 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1355                                      DIE *IndexTy) {
1356   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1357   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1358 
1359   // The LowerBound value defines the lower bounds which is typically zero for
1360   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1361   // Count == -1 then the array is unbounded and we do not emit
1362   // DW_AT_lower_bound and DW_AT_count attributes.
1363   int64_t DefaultLowerBound = getDefaultLowerBound();
1364 
1365   auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1366                                DISubrange::BoundType Bound) -> void {
1367     if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
1368       if (auto *VarDIE = getDIE(BV))
1369         addDIEEntry(DW_Subrange, Attr, *VarDIE);
1370     } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
1371       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1372       DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1373       DwarfExpr.setMemoryLocationKind();
1374       DwarfExpr.addExpression(BE);
1375       addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
1376     } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) {
1377       if (Attr == dwarf::DW_AT_count) {
1378         if (BI->getSExtValue() != -1)
1379           addUInt(DW_Subrange, Attr, None, BI->getSExtValue());
1380       } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1381                  BI->getSExtValue() != DefaultLowerBound)
1382         addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
1383     }
1384   };
1385 
1386   AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
1387 
1388   AddBoundTypeEntry(dwarf::DW_AT_count, SR->getCount());
1389 
1390   AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound());
1391 
1392   AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride());
1393 }
1394 
1395 void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
1396                                             const DIGenericSubrange *GSR,
1397                                             DIE *IndexTy) {
1398   DIE &DwGenericSubrange =
1399       createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
1400   addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
1401 
1402   int64_t DefaultLowerBound = getDefaultLowerBound();
1403 
1404   auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
1405                                DIGenericSubrange::BoundType Bound) -> void {
1406     if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
1407       if (auto *VarDIE = getDIE(BV))
1408         addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
1409     } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
1410       if (BE->isConstant() &&
1411           DIExpression::SignedOrUnsignedConstant::SignedConstant ==
1412               *BE->isConstant()) {
1413         if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1414             static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
1415           addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
1416                   BE->getElement(1));
1417       } else {
1418         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1419         DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1420         DwarfExpr.setMemoryLocationKind();
1421         DwarfExpr.addExpression(BE);
1422         addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
1423       }
1424     }
1425   };
1426 
1427   AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound());
1428   AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount());
1429   AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound());
1430   AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
1431 }
1432 
1433 DIE *DwarfUnit::getIndexTyDie() {
1434   if (IndexTyDie)
1435     return IndexTyDie;
1436   // Construct an integer type to use for indexes.
1437   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
1438   StringRef Name = "__ARRAY_SIZE_TYPE__";
1439   addString(*IndexTyDie, dwarf::DW_AT_name, Name);
1440   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1441   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1442           dwarf::getArrayIndexTypeEncoding(
1443               (dwarf::SourceLanguage)getLanguage()));
1444   DD->addAccelType(*CUNode, Name, *IndexTyDie, /*Flags*/ 0);
1445   return IndexTyDie;
1446 }
1447 
1448 /// Returns true if the vector's size differs from the sum of sizes of elements
1449 /// the user specified.  This can occur if the vector has been rounded up to
1450 /// fit memory alignment constraints.
1451 static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1452   assert(CTy && CTy->isVector() && "Composite type is not a vector");
1453   const uint64_t ActualSize = CTy->getSizeInBits();
1454 
1455   // Obtain the size of each element in the vector.
1456   DIType *BaseTy = CTy->getBaseType();
1457   assert(BaseTy && "Unknown vector element type.");
1458   const uint64_t ElementSize = BaseTy->getSizeInBits();
1459 
1460   // Locate the number of elements in the vector.
1461   const DINodeArray Elements = CTy->getElements();
1462   assert(Elements.size() == 1 &&
1463          Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1464          "Invalid vector element array, expected one element of type subrange");
1465   const auto Subrange = cast<DISubrange>(Elements[0]);
1466   const auto NumVecElements =
1467       Subrange->getCount()
1468           ? Subrange->getCount().get<ConstantInt *>()->getSExtValue()
1469           : 0;
1470 
1471   // Ensure we found the element count and that the actual size is wide
1472   // enough to contain the requested size.
1473   assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
1474   return ActualSize != (NumVecElements * ElementSize);
1475 }
1476 
1477 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1478   if (CTy->isVector()) {
1479     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1480     if (hasVectorBeenPadded(CTy))
1481       addUInt(Buffer, dwarf::DW_AT_byte_size, None,
1482               CTy->getSizeInBits() / CHAR_BIT);
1483   }
1484 
1485   if (DIVariable *Var = CTy->getDataLocation()) {
1486     if (auto *VarDIE = getDIE(Var))
1487       addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
1488   } else if (DIExpression *Expr = CTy->getDataLocationExp()) {
1489     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1490     DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1491     DwarfExpr.setMemoryLocationKind();
1492     DwarfExpr.addExpression(Expr);
1493     addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
1494   }
1495 
1496   if (DIVariable *Var = CTy->getAssociated()) {
1497     if (auto *VarDIE = getDIE(Var))
1498       addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
1499   } else if (DIExpression *Expr = CTy->getAssociatedExp()) {
1500     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1501     DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1502     DwarfExpr.setMemoryLocationKind();
1503     DwarfExpr.addExpression(Expr);
1504     addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
1505   }
1506 
1507   if (DIVariable *Var = CTy->getAllocated()) {
1508     if (auto *VarDIE = getDIE(Var))
1509       addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
1510   } else if (DIExpression *Expr = CTy->getAllocatedExp()) {
1511     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1512     DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1513     DwarfExpr.setMemoryLocationKind();
1514     DwarfExpr.addExpression(Expr);
1515     addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
1516   }
1517 
1518   if (auto *RankConst = CTy->getRankConst()) {
1519     addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
1520             RankConst->getSExtValue());
1521   } else if (auto *RankExpr = CTy->getRankExp()) {
1522     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1523     DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
1524     DwarfExpr.setMemoryLocationKind();
1525     DwarfExpr.addExpression(RankExpr);
1526     addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
1527   }
1528 
1529   // Emit the element type.
1530   addType(Buffer, CTy->getBaseType());
1531 
1532   // Get an anonymous type for index type.
1533   // FIXME: This type should be passed down from the front end
1534   // as different languages may have different sizes for indexes.
1535   DIE *IdxTy = getIndexTyDie();
1536 
1537   // Add subranges to array type.
1538   DINodeArray Elements = CTy->getElements();
1539   for (DINode *E : Elements) {
1540     // FIXME: Should this really be such a loose cast?
1541     if (auto *Element = dyn_cast_or_null<DINode>(E)) {
1542       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1543         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1544       else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
1545         constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
1546                                     IdxTy);
1547     }
1548   }
1549 }
1550 
1551 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1552   const DIType *DTy = CTy->getBaseType();
1553   bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
1554   if (DTy) {
1555     if (DD->getDwarfVersion() >= 3)
1556       addType(Buffer, DTy);
1557     if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
1558       addFlag(Buffer, dwarf::DW_AT_enum_class);
1559   }
1560 
1561   auto *Context = CTy->getScope();
1562   bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
1563       isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
1564   DINodeArray Elements = CTy->getElements();
1565 
1566   // Add enumerators to enumeration type.
1567   for (const DINode *E : Elements) {
1568     auto *Enum = dyn_cast_or_null<DIEnumerator>(E);
1569     if (Enum) {
1570       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1571       StringRef Name = Enum->getName();
1572       addString(Enumerator, dwarf::DW_AT_name, Name);
1573       addConstantValue(Enumerator, Enum->getValue(), IsUnsigned);
1574       if (IndexEnumerators)
1575         addGlobalName(Name, Enumerator, Context);
1576     }
1577   }
1578 }
1579 
1580 void DwarfUnit::constructContainingTypeDIEs() {
1581   for (auto &P : ContainingTypeMap) {
1582     DIE &SPDie = *P.first;
1583     const DINode *D = P.second;
1584     if (!D)
1585       continue;
1586     DIE *NDie = getDIE(D);
1587     if (!NDie)
1588       continue;
1589     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1590   }
1591 }
1592 
1593 DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1594   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1595   StringRef Name = DT->getName();
1596   if (!Name.empty())
1597     addString(MemberDie, dwarf::DW_AT_name, Name);
1598 
1599   addAnnotation(MemberDie, DT->getAnnotations());
1600 
1601   if (DIType *Resolved = DT->getBaseType())
1602     addType(MemberDie, Resolved);
1603 
1604   addSourceLine(MemberDie, DT);
1605 
1606   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1607 
1608     // For C++, virtual base classes are not at fixed offset. Use following
1609     // expression to extract appropriate offset from vtable.
1610     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1611 
1612     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1613     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1614     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1615     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1616     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1617     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1618     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1619     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1620 
1621     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1622   } else {
1623     uint64_t Size = DT->getSizeInBits();
1624     uint64_t FieldSize = DD->getBaseTypeSize(DT);
1625     uint32_t AlignInBytes = DT->getAlignInBytes();
1626     uint64_t OffsetInBytes;
1627 
1628     bool IsBitfield = FieldSize && Size != FieldSize;
1629     if (IsBitfield) {
1630       // Handle bitfield, assume bytes are 8 bits.
1631       if (DD->useDWARF2Bitfields())
1632         addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1633       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1634 
1635       uint64_t Offset = DT->getOffsetInBits();
1636       // We can't use DT->getAlignInBits() here: AlignInBits for member type
1637       // is non-zero if and only if alignment was forced (e.g. _Alignas()),
1638       // which can't be done with bitfields. Thus we use FieldSize here.
1639       uint32_t AlignInBits = FieldSize;
1640       uint32_t AlignMask = ~(AlignInBits - 1);
1641       // The bits from the start of the storage unit to the start of the field.
1642       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1643       // The byte offset of the field's aligned storage unit inside the struct.
1644       OffsetInBytes = (Offset - StartBitOffset) / 8;
1645 
1646       if (DD->useDWARF2Bitfields()) {
1647         uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1648         uint64_t FieldOffset = (HiMark - FieldSize);
1649         Offset -= FieldOffset;
1650 
1651         // Maybe we need to work from the other end.
1652         if (Asm->getDataLayout().isLittleEndian())
1653           Offset = FieldSize - (Offset + Size);
1654 
1655         addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1656         OffsetInBytes = FieldOffset >> 3;
1657       } else {
1658         addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
1659       }
1660     } else {
1661       // This is not a bitfield.
1662       OffsetInBytes = DT->getOffsetInBits() / 8;
1663       if (AlignInBytes)
1664         addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1665                 AlignInBytes);
1666     }
1667 
1668     if (DD->getDwarfVersion() <= 2) {
1669       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1670       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1671       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1672       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1673     } else if (!IsBitfield || DD->useDWARF2Bitfields()) {
1674       // In DWARF v3, DW_FORM_data4/8 in DW_AT_data_member_location are
1675       // interpreted as location-list pointers. Interpreting constants as
1676       // pointers is not expected, so we use DW_FORM_udata to encode the
1677       // constants here.
1678       if (DD->getDwarfVersion() == 3)
1679         addUInt(MemberDie, dwarf::DW_AT_data_member_location,
1680                 dwarf::DW_FORM_udata, OffsetInBytes);
1681       else
1682         addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1683                 OffsetInBytes);
1684     }
1685   }
1686 
1687   addAccess(MemberDie, DT->getFlags());
1688 
1689   if (DT->isVirtual())
1690     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1691             dwarf::DW_VIRTUALITY_virtual);
1692 
1693   // Objective-C properties.
1694   if (DINode *PNode = DT->getObjCProperty())
1695     if (DIE *PDie = getDIE(PNode))
1696       addAttribute(MemberDie, dwarf::DW_AT_APPLE_property,
1697                    dwarf::DW_FORM_ref4, DIEEntry(*PDie));
1698 
1699   if (DT->isArtificial())
1700     addFlag(MemberDie, dwarf::DW_AT_artificial);
1701 
1702   return MemberDie;
1703 }
1704 
1705 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1706   if (!DT)
1707     return nullptr;
1708 
1709   // Construct the context before querying for the existence of the DIE in case
1710   // such construction creates the DIE.
1711   DIE *ContextDIE = getOrCreateContextDIE(DT->getScope());
1712   assert(dwarf::isType(ContextDIE->getTag()) &&
1713          "Static member should belong to a type.");
1714 
1715   if (DIE *StaticMemberDIE = getDIE(DT))
1716     return StaticMemberDIE;
1717 
1718   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1719 
1720   const DIType *Ty = DT->getBaseType();
1721 
1722   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1723   addType(StaticMemberDIE, Ty);
1724   addSourceLine(StaticMemberDIE, DT);
1725   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1726   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1727 
1728   // FIXME: We could omit private if the parent is a class_type, and
1729   // public if the parent is something else.
1730   addAccess(StaticMemberDIE, DT->getFlags());
1731 
1732   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1733     addConstantValue(StaticMemberDIE, CI, Ty);
1734   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1735     addConstantFPValue(StaticMemberDIE, CFP);
1736 
1737   if (uint32_t AlignInBytes = DT->getAlignInBytes())
1738     addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1739             AlignInBytes);
1740 
1741   return &StaticMemberDIE;
1742 }
1743 
1744 void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
1745   // Emit size of content not including length itself
1746   if (!DD->useSectionsAsReferences())
1747     EndLabel = Asm->emitDwarfUnitLength(
1748         isDwoUnit() ? "debug_info_dwo" : "debug_info", "Length of Unit");
1749   else
1750     Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(),
1751                              "Length of Unit");
1752 
1753   Asm->OutStreamer->AddComment("DWARF version number");
1754   unsigned Version = DD->getDwarfVersion();
1755   Asm->emitInt16(Version);
1756 
1757   // DWARF v5 reorders the address size and adds a unit type.
1758   if (Version >= 5) {
1759     Asm->OutStreamer->AddComment("DWARF Unit Type");
1760     Asm->emitInt8(UT);
1761     Asm->OutStreamer->AddComment("Address Size (in bytes)");
1762     Asm->emitInt8(Asm->MAI->getCodePointerSize());
1763   }
1764 
1765   // We share one abbreviations table across all units so it's always at the
1766   // start of the section. Use a relocatable offset where needed to ensure
1767   // linking doesn't invalidate that offset.
1768   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1769   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1770   if (UseOffsets)
1771     Asm->emitDwarfLengthOrOffset(0);
1772   else
1773     Asm->emitDwarfSymbolReference(
1774         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
1775 
1776   if (Version <= 4) {
1777     Asm->OutStreamer->AddComment("Address Size (in bytes)");
1778     Asm->emitInt8(Asm->MAI->getCodePointerSize());
1779   }
1780 }
1781 
1782 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1783   DwarfUnit::emitCommonHeader(UseOffsets,
1784                               DD->useSplitDwarf() ? dwarf::DW_UT_split_type
1785                                                   : dwarf::DW_UT_type);
1786   Asm->OutStreamer->AddComment("Type Signature");
1787   Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
1788   Asm->OutStreamer->AddComment("Type DIE Offset");
1789   // In a skeleton type unit there is no type DIE so emit a zero offset.
1790   Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
1791 }
1792 
1793 void DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
1794                                 const MCSymbol *Hi, const MCSymbol *Lo) {
1795   addAttribute(Die, Attribute, DD->getDwarfSectionOffsetForm(),
1796                new (DIEValueAllocator) DIEDelta(Hi, Lo));
1797 }
1798 
1799 void DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
1800                                 const MCSymbol *Label, const MCSymbol *Sec) {
1801   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1802     addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label);
1803   else
1804     addSectionDelta(Die, Attribute, Label, Sec);
1805 }
1806 
1807 bool DwarfTypeUnit::isDwoUnit() const {
1808   // Since there are no skeleton type units, all type units are dwo type units
1809   // when split DWARF is being used.
1810   return DD->useSplitDwarf();
1811 }
1812 
1813 void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
1814                                   const DIScope *Context) {
1815   getCU().addGlobalNameForTypeUnit(Name, Context);
1816 }
1817 
1818 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1819                                   const DIScope *Context) {
1820   getCU().addGlobalTypeUnitType(Ty, Context);
1821 }
1822 
1823 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
1824   if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1825     return nullptr;
1826   if (isDwoUnit())
1827     return nullptr;
1828   return getSection()->getBeginSymbol();
1829 }
1830 
1831 void DwarfUnit::addStringOffsetsStart() {
1832   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1833   addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
1834                   DU->getStringOffsetsStartSym(),
1835                   TLOF.getDwarfStrOffSection()->getBeginSymbol());
1836 }
1837 
1838 void DwarfUnit::addRnglistsBase() {
1839   assert(DD->getDwarfVersion() >= 5 &&
1840          "DW_AT_rnglists_base requires DWARF version 5 or later");
1841   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1842   addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
1843                   DU->getRnglistsTableBaseSym(),
1844                   TLOF.getDwarfRnglistsSection()->getBeginSymbol());
1845 }
1846 
1847 void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
1848   DD->getAddressPool().resetUsedFlag(true);
1849 }
1850