1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
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 implements the DIBuilder.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/DIBuilder.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Dwarf.h"
22 
23 using namespace llvm;
24 using namespace llvm::dwarf;
25 
26 namespace {
27 class HeaderBuilder {
28   /// \brief Whether there are any fields yet.
29   ///
30   /// Note that this is not equivalent to \c Chars.empty(), since \a concat()
31   /// may have been called already with an empty string.
32   bool IsEmpty;
33   SmallVector<char, 256> Chars;
34 
35 public:
36   HeaderBuilder() : IsEmpty(true) {}
37   HeaderBuilder(const HeaderBuilder &X) : IsEmpty(X.IsEmpty), Chars(X.Chars) {}
38   HeaderBuilder(HeaderBuilder &&X)
39       : IsEmpty(X.IsEmpty), Chars(std::move(X.Chars)) {}
40 
41   template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
42     if (IsEmpty)
43       IsEmpty = false;
44     else
45       Chars.push_back(0);
46     Twine(X).toVector(Chars);
47     return *this;
48   }
49 
50   MDString *get(LLVMContext &Context) const {
51     return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
52   }
53 
54   static HeaderBuilder get(unsigned Tag) {
55     return HeaderBuilder().concat("0x" + Twine::utohexstr(Tag));
56   }
57 };
58 }
59 
60 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
61     : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
62       TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
63       DeclareFn(nullptr), ValueFn(nullptr),
64       AllowUnresolvedNodes(AllowUnresolvedNodes) {}
65 
66 void DIBuilder::trackIfUnresolved(MDNode *N) {
67   if (!N)
68     return;
69   if (N->isResolved())
70     return;
71 
72   assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
73   UnresolvedNodes.emplace_back(N);
74 }
75 
76 void DIBuilder::finalize() {
77   DIArray Enums = getOrCreateArray(AllEnumTypes);
78   DIType(TempEnumTypes).replaceAllUsesWith(Enums);
79 
80   SmallVector<Metadata *, 16> RetainValues;
81   // Declarations and definitions of the same type may be retained. Some
82   // clients RAUW these pairs, leaving duplicates in the retained types
83   // list. Use a set to remove the duplicates while we transform the
84   // TrackingVHs back into Values.
85   SmallPtrSet<Metadata *, 16> RetainSet;
86   for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
87     if (RetainSet.insert(AllRetainTypes[I]).second)
88       RetainValues.push_back(AllRetainTypes[I]);
89   DIArray RetainTypes = getOrCreateArray(RetainValues);
90   DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
91 
92   DIArray SPs = getOrCreateArray(AllSubprograms);
93   DIType(TempSubprograms).replaceAllUsesWith(SPs);
94   for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
95     DISubprogram SP(SPs.getElement(i));
96     if (MDNode *Temp = SP.getVariablesNodes()) {
97       SmallVector<Metadata *, 4> Variables;
98       for (Metadata *V : PreservedVariables.lookup(SP))
99         Variables.push_back(V);
100       DIArray AV = getOrCreateArray(Variables);
101       DIType(Temp).replaceAllUsesWith(AV);
102     }
103   }
104 
105   DIArray GVs = getOrCreateArray(AllGVs);
106   DIType(TempGVs).replaceAllUsesWith(GVs);
107 
108   SmallVector<Metadata *, 16> RetainValuesI;
109   for (unsigned I = 0, E = AllImportedModules.size(); I < E; I++)
110     RetainValuesI.push_back(AllImportedModules[I]);
111   DIArray IMs = getOrCreateArray(RetainValuesI);
112   DIType(TempImportedModules).replaceAllUsesWith(IMs);
113 
114   // Now that all temp nodes have been replaced or deleted, resolve remaining
115   // cycles.
116   for (const auto &N : UnresolvedNodes)
117     if (N && !N->isResolved())
118       N->resolveCycles();
119   UnresolvedNodes.clear();
120 
121   // Can't handle unresolved nodes anymore.
122   AllowUnresolvedNodes = false;
123 }
124 
125 /// If N is compile unit return NULL otherwise return N.
126 static MDNode *getNonCompileUnitScope(MDNode *N) {
127   if (DIDescriptor(N).isCompileUnit())
128     return nullptr;
129   return N;
130 }
131 
132 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
133                                   StringRef Directory) {
134   assert(!Filename.empty() && "Unable to create file without name");
135   Metadata *Pair[] = {MDString::get(VMContext, Filename),
136                       MDString::get(VMContext, Directory)};
137   return MDNode::get(VMContext, Pair);
138 }
139 
140 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
141                                            StringRef Directory,
142                                            StringRef Producer, bool isOptimized,
143                                            StringRef Flags, unsigned RunTimeVer,
144                                            StringRef SplitName,
145                                            DebugEmissionKind Kind,
146                                            bool EmitDebugInfo) {
147 
148   assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) ||
149           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
150          "Invalid Language tag");
151   assert(!Filename.empty() &&
152          "Unable to create compile unit without filename");
153   Metadata *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)};
154   TempEnumTypes = MDNode::getTemporary(VMContext, TElts).release();
155 
156   TempRetainTypes = MDNode::getTemporary(VMContext, TElts).release();
157 
158   TempSubprograms = MDNode::getTemporary(VMContext, TElts).release();
159 
160   TempGVs = MDNode::getTemporary(VMContext, TElts).release();
161 
162   TempImportedModules = MDNode::getTemporary(VMContext, TElts).release();
163 
164   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
165                           .concat(Lang)
166                           .concat(Producer)
167                           .concat(isOptimized)
168                           .concat(Flags)
169                           .concat(RunTimeVer)
170                           .concat(SplitName)
171                           .concat(Kind)
172                           .get(VMContext),
173                       createFilePathPair(VMContext, Filename, Directory),
174                       TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
175                       TempImportedModules};
176 
177   MDNode *CUNode = MDNode::get(VMContext, Elts);
178 
179   // Create a named metadata so that it is easier to find cu in a module.
180   // Note that we only generate this when the caller wants to actually
181   // emit debug information. When we are only interested in tracking
182   // source line locations throughout the backend, we prevent codegen from
183   // emitting debug info in the final output by not generating llvm.dbg.cu.
184   if (EmitDebugInfo) {
185     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
186     NMD->addOperand(CUNode);
187   }
188 
189   trackIfUnresolved(CUNode);
190   return DICompileUnit(CUNode);
191 }
192 
193 static DIImportedEntity
194 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
195                      Metadata *NS, unsigned Line, StringRef Name,
196                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
197   const MDNode *R;
198   Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
199                       Context, NS};
200   R = MDNode::get(C, Elts);
201   DIImportedEntity M(R);
202   assert(M.Verify() && "Imported module should be valid");
203   AllImportedModules.emplace_back(M.get());
204   return M;
205 }
206 
207 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
208                                                  DINameSpace NS,
209                                                  unsigned Line) {
210   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
211                                 Context, NS, Line, StringRef(), AllImportedModules);
212 }
213 
214 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
215                                                  DIImportedEntity NS,
216                                                  unsigned Line) {
217   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
218                                 Context, NS, Line, StringRef(), AllImportedModules);
219 }
220 
221 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
222                                                       DIDescriptor Decl,
223                                                       unsigned Line, StringRef Name) {
224   // Make sure to use the unique identifier based metadata reference for
225   // types that have one.
226   Metadata *V =
227       Decl.isType() ? static_cast<Metadata *>(DIType(Decl).getRef()) : Decl;
228   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
229                                 Context, V, Line, Name,
230                                 AllImportedModules);
231 }
232 
233 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
234                                                       DIImportedEntity Imp,
235                                                       unsigned Line, StringRef Name) {
236   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
237                                 Context, Imp, Line, Name, AllImportedModules);
238 }
239 
240 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
241   Metadata *Elts[] = {
242       HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
243       createFilePathPair(VMContext, Filename, Directory)};
244   return DIFile(MDNode::get(VMContext, Elts));
245 }
246 
247 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
248   assert(!Name.empty() && "Unable to create enumerator without name");
249   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
250                           .concat(Name)
251                           .concat(Val)
252                           .get(VMContext)};
253   return DIEnumerator(MDNode::get(VMContext, Elts));
254 }
255 
256 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
257   assert(!Name.empty() && "Unable to create type without name");
258   // Unspecified types are encoded in DIBasicType format. Line number, filename,
259   // size, alignment, offset and flags are always empty here.
260   Metadata *Elts[] = {
261       HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
262           .concat(Name)
263           .concat(0)
264           .concat(0)
265           .concat(0)
266           .concat(0)
267           .concat(0)
268           .concat(0)
269           .get(VMContext),
270       nullptr, // Filename
271       nullptr  // Unused
272   };
273   return DIBasicType(MDNode::get(VMContext, Elts));
274 }
275 
276 DIBasicType DIBuilder::createNullPtrType() {
277   return createUnspecifiedType("decltype(nullptr)");
278 }
279 
280 DIBasicType
281 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
282                            uint64_t AlignInBits, unsigned Encoding) {
283   assert(!Name.empty() && "Unable to create type without name");
284   // Basic types are encoded in DIBasicType format. Line number, filename,
285   // offset and flags are always empty here.
286   Metadata *Elts[] = {
287       HeaderBuilder::get(dwarf::DW_TAG_base_type)
288           .concat(Name)
289           .concat(0) // Line
290           .concat(SizeInBits)
291           .concat(AlignInBits)
292           .concat(0) // Offset
293           .concat(0) // Flags
294           .concat(Encoding)
295           .get(VMContext),
296       nullptr, // Filename
297       nullptr  // Unused
298   };
299   return DIBasicType(MDNode::get(VMContext, Elts));
300 }
301 
302 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
303   // Qualified types are encoded in DIDerivedType format.
304   Metadata *Elts[] = {HeaderBuilder::get(Tag)
305                           .concat(StringRef()) // Name
306                           .concat(0)           // Line
307                           .concat(0)           // Size
308                           .concat(0)           // Align
309                           .concat(0)           // Offset
310                           .concat(0)           // Flags
311                           .get(VMContext),
312                       nullptr, // Filename
313                       nullptr, // Unused
314                       FromTy.getRef()};
315   return DIDerivedType(MDNode::get(VMContext, Elts));
316 }
317 
318 DIDerivedType
319 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
320                              uint64_t AlignInBits, StringRef Name) {
321   // Pointer types are encoded in DIDerivedType format.
322   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
323                           .concat(Name)
324                           .concat(0) // Line
325                           .concat(SizeInBits)
326                           .concat(AlignInBits)
327                           .concat(0) // Offset
328                           .concat(0) // Flags
329                           .get(VMContext),
330                       nullptr, // Filename
331                       nullptr, // Unused
332                       PointeeTy.getRef()};
333   return DIDerivedType(MDNode::get(VMContext, Elts));
334 }
335 
336 DIDerivedType
337 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
338                                    uint64_t SizeInBits, uint64_t AlignInBits) {
339   // Pointer types are encoded in DIDerivedType format.
340   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
341                           .concat(StringRef())
342                           .concat(0) // Line
343                           .concat(SizeInBits) // Size
344                           .concat(AlignInBits) // Align
345                           .concat(0) // Offset
346                           .concat(0) // Flags
347                           .get(VMContext),
348                       nullptr, // Filename
349                       nullptr, // Unused
350                       PointeeTy.getRef(), Base.getRef()};
351   return DIDerivedType(MDNode::get(VMContext, Elts));
352 }
353 
354 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
355   assert(RTy.isType() && "Unable to create reference type");
356   // References are encoded in DIDerivedType format.
357   Metadata *Elts[] = {HeaderBuilder::get(Tag)
358                           .concat(StringRef()) // Name
359                           .concat(0)           // Line
360                           .concat(0)           // Size
361                           .concat(0)           // Align
362                           .concat(0)           // Offset
363                           .concat(0)           // Flags
364                           .get(VMContext),
365                       nullptr, // Filename
366                       nullptr, // TheCU,
367                       RTy.getRef()};
368   return DIDerivedType(MDNode::get(VMContext, Elts));
369 }
370 
371 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
372                                        unsigned LineNo, DIDescriptor Context) {
373   // typedefs are encoded in DIDerivedType format.
374   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
375                           .concat(Name)
376                           .concat(LineNo)
377                           .concat(0) // Size
378                           .concat(0) // Align
379                           .concat(0) // Offset
380                           .concat(0) // Flags
381                           .get(VMContext),
382                       File.getFileNode(),
383                       DIScope(getNonCompileUnitScope(Context)).getRef(),
384                       Ty.getRef()};
385   return DIDerivedType(MDNode::get(VMContext, Elts));
386 }
387 
388 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
389   // typedefs are encoded in DIDerivedType format.
390   assert(Ty.isType() && "Invalid type!");
391   assert(FriendTy.isType() && "Invalid friend type!");
392   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
393                           .concat(StringRef()) // Name
394                           .concat(0)           // Line
395                           .concat(0)           // Size
396                           .concat(0)           // Align
397                           .concat(0)           // Offset
398                           .concat(0)           // Flags
399                           .get(VMContext),
400                       nullptr, Ty.getRef(), FriendTy.getRef()};
401   return DIDerivedType(MDNode::get(VMContext, Elts));
402 }
403 
404 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
405                                            uint64_t BaseOffset,
406                                            unsigned Flags) {
407   assert(Ty.isType() && "Unable to create inheritance");
408   // TAG_inheritance is encoded in DIDerivedType format.
409   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
410                           .concat(StringRef()) // Name
411                           .concat(0)           // Line
412                           .concat(0)           // Size
413                           .concat(0)           // Align
414                           .concat(BaseOffset)
415                           .concat(Flags)
416                           .get(VMContext),
417                       nullptr, Ty.getRef(), BaseTy.getRef()};
418   return DIDerivedType(MDNode::get(VMContext, Elts));
419 }
420 
421 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
422                                           DIFile File, unsigned LineNumber,
423                                           uint64_t SizeInBits,
424                                           uint64_t AlignInBits,
425                                           uint64_t OffsetInBits, unsigned Flags,
426                                           DIType Ty) {
427   // TAG_member is encoded in DIDerivedType format.
428   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
429                           .concat(Name)
430                           .concat(LineNumber)
431                           .concat(SizeInBits)
432                           .concat(AlignInBits)
433                           .concat(OffsetInBits)
434                           .concat(Flags)
435                           .get(VMContext),
436                       File.getFileNode(),
437                       DIScope(getNonCompileUnitScope(Scope)).getRef(),
438                       Ty.getRef()};
439   return DIDerivedType(MDNode::get(VMContext, Elts));
440 }
441 
442 static Metadata *getConstantOrNull(Constant *C) {
443   if (C)
444     return ConstantAsMetadata::get(C);
445   return nullptr;
446 }
447 
448 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
449                                                 StringRef Name, DIFile File,
450                                                 unsigned LineNumber, DIType Ty,
451                                                 unsigned Flags,
452                                                 llvm::Constant *Val) {
453   // TAG_member is encoded in DIDerivedType format.
454   Flags |= DIDescriptor::FlagStaticMember;
455   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
456                           .concat(Name)
457                           .concat(LineNumber)
458                           .concat(0) // Size
459                           .concat(0) // Align
460                           .concat(0) // Offset
461                           .concat(Flags)
462                           .get(VMContext),
463                       File.getFileNode(),
464                       DIScope(getNonCompileUnitScope(Scope)).getRef(),
465                       Ty.getRef(), getConstantOrNull(Val)};
466   return DIDerivedType(MDNode::get(VMContext, Elts));
467 }
468 
469 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
470                                         unsigned LineNumber,
471                                         uint64_t SizeInBits,
472                                         uint64_t AlignInBits,
473                                         uint64_t OffsetInBits, unsigned Flags,
474                                         DIType Ty, MDNode *PropertyNode) {
475   // TAG_member is encoded in DIDerivedType format.
476   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
477                           .concat(Name)
478                           .concat(LineNumber)
479                           .concat(SizeInBits)
480                           .concat(AlignInBits)
481                           .concat(OffsetInBits)
482                           .concat(Flags)
483                           .get(VMContext),
484                       File.getFileNode(), getNonCompileUnitScope(File), Ty,
485                       PropertyNode};
486   return DIDerivedType(MDNode::get(VMContext, Elts));
487 }
488 
489 DIObjCProperty
490 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
491                               StringRef GetterName, StringRef SetterName,
492                               unsigned PropertyAttributes, DIType Ty) {
493   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
494                           .concat(Name)
495                           .concat(LineNumber)
496                           .concat(GetterName)
497                           .concat(SetterName)
498                           .concat(PropertyAttributes)
499                           .get(VMContext),
500                       File, Ty};
501   return DIObjCProperty(MDNode::get(VMContext, Elts));
502 }
503 
504 DITemplateTypeParameter
505 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
506                                        DIType Ty, MDNode *File, unsigned LineNo,
507                                        unsigned ColumnNo) {
508   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
509                           .concat(Name)
510                           .concat(LineNo)
511                           .concat(ColumnNo)
512                           .get(VMContext),
513                       DIScope(getNonCompileUnitScope(Context)).getRef(),
514                       Ty.getRef(), File};
515   return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
516 }
517 
518 static DITemplateValueParameter createTemplateValueParameterHelper(
519     LLVMContext &VMContext, unsigned Tag, DIDescriptor Context, StringRef Name,
520     DIType Ty, Metadata *MD, MDNode *File, unsigned LineNo, unsigned ColumnNo) {
521   Metadata *Elts[] = {
522       HeaderBuilder::get(Tag).concat(Name).concat(LineNo).concat(ColumnNo).get(
523           VMContext),
524       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD, File};
525   return DITemplateValueParameter(MDNode::get(VMContext, Elts));
526 }
527 
528 DITemplateValueParameter
529 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
530                                         DIType Ty, Constant *Val, MDNode *File,
531                                         unsigned LineNo, unsigned ColumnNo) {
532   return createTemplateValueParameterHelper(
533       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
534       getConstantOrNull(Val), File, LineNo, ColumnNo);
535 }
536 
537 DITemplateValueParameter
538 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
539                                            DIType Ty, StringRef Val,
540                                            MDNode *File, unsigned LineNo,
541                                            unsigned ColumnNo) {
542   return createTemplateValueParameterHelper(
543       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
544       MDString::get(VMContext, Val), File, LineNo, ColumnNo);
545 }
546 
547 DITemplateValueParameter
548 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
549                                        DIType Ty, DIArray Val,
550                                        MDNode *File, unsigned LineNo,
551                                        unsigned ColumnNo) {
552   return createTemplateValueParameterHelper(
553       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
554       Val, File, LineNo, ColumnNo);
555 }
556 
557 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
558                                            DIFile File, unsigned LineNumber,
559                                            uint64_t SizeInBits,
560                                            uint64_t AlignInBits,
561                                            uint64_t OffsetInBits,
562                                            unsigned Flags, DIType DerivedFrom,
563                                            DIArray Elements,
564                                            DIType VTableHolder,
565                                            MDNode *TemplateParams,
566                                            StringRef UniqueIdentifier) {
567   assert((!Context || Context.isScope() || Context.isType()) &&
568          "createClassType should be called with a valid Context");
569   // TAG_class_type is encoded in DICompositeType format.
570   Metadata *Elts[] = {
571       HeaderBuilder::get(dwarf::DW_TAG_class_type)
572           .concat(Name)
573           .concat(LineNumber)
574           .concat(SizeInBits)
575           .concat(AlignInBits)
576           .concat(OffsetInBits)
577           .concat(Flags)
578           .concat(0)
579           .get(VMContext),
580       File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
581       DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
582       UniqueIdentifier.empty() ? nullptr
583                                : MDString::get(VMContext, UniqueIdentifier)};
584   DICompositeType R(MDNode::get(VMContext, Elts));
585   assert(R.isCompositeType() &&
586          "createClassType should return a DICompositeType");
587   if (!UniqueIdentifier.empty())
588     retainType(R);
589   return R;
590 }
591 
592 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
593                                             StringRef Name, DIFile File,
594                                             unsigned LineNumber,
595                                             uint64_t SizeInBits,
596                                             uint64_t AlignInBits,
597                                             unsigned Flags, DIType DerivedFrom,
598                                             DIArray Elements,
599                                             unsigned RunTimeLang,
600                                             DIType VTableHolder,
601                                             StringRef UniqueIdentifier) {
602  // TAG_structure_type is encoded in DICompositeType format.
603   Metadata *Elts[] = {
604       HeaderBuilder::get(dwarf::DW_TAG_structure_type)
605           .concat(Name)
606           .concat(LineNumber)
607           .concat(SizeInBits)
608           .concat(AlignInBits)
609           .concat(0)
610           .concat(Flags)
611           .concat(RunTimeLang)
612           .get(VMContext),
613       File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
614       DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
615       UniqueIdentifier.empty() ? nullptr
616                                : MDString::get(VMContext, UniqueIdentifier)};
617   DICompositeType R(MDNode::get(VMContext, Elts));
618   assert(R.isCompositeType() &&
619          "createStructType should return a DICompositeType");
620   if (!UniqueIdentifier.empty())
621     retainType(R);
622   return R;
623 }
624 
625 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
626                                            DIFile File, unsigned LineNumber,
627                                            uint64_t SizeInBits,
628                                            uint64_t AlignInBits, unsigned Flags,
629                                            DIArray Elements,
630                                            unsigned RunTimeLang,
631                                            StringRef UniqueIdentifier) {
632   // TAG_union_type is encoded in DICompositeType format.
633   Metadata *Elts[] = {
634       HeaderBuilder::get(dwarf::DW_TAG_union_type)
635           .concat(Name)
636           .concat(LineNumber)
637           .concat(SizeInBits)
638           .concat(AlignInBits)
639           .concat(0) // Offset
640           .concat(Flags)
641           .concat(RunTimeLang)
642           .get(VMContext),
643       File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
644       nullptr, Elements, nullptr, nullptr,
645       UniqueIdentifier.empty() ? nullptr
646                                : MDString::get(VMContext, UniqueIdentifier)};
647   DICompositeType R(MDNode::get(VMContext, Elts));
648   if (!UniqueIdentifier.empty())
649     retainType(R);
650   return R;
651 }
652 
653 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
654                                                  DITypeArray ParameterTypes,
655                                                  unsigned Flags) {
656   // TAG_subroutine_type is encoded in DICompositeType format.
657   Metadata *Elts[] = {
658       HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
659           .concat(StringRef())
660           .concat(0)     // Line
661           .concat(0)     // Size
662           .concat(0)     // Align
663           .concat(0)     // Offset
664           .concat(Flags) // Flags
665           .concat(0)
666           .get(VMContext),
667       nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
668       nullptr // Type Identifer
669   };
670   return DISubroutineType(MDNode::get(VMContext, Elts));
671 }
672 
673 DICompositeType DIBuilder::createEnumerationType(
674     DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
675     uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
676     DIType UnderlyingType, StringRef UniqueIdentifier) {
677   // TAG_enumeration_type is encoded in DICompositeType format.
678   Metadata *Elts[] = {
679       HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
680           .concat(Name)
681           .concat(LineNumber)
682           .concat(SizeInBits)
683           .concat(AlignInBits)
684           .concat(0) // Offset
685           .concat(0) // Flags
686           .concat(0)
687           .get(VMContext),
688       File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
689       UnderlyingType.getRef(), Elements, nullptr, nullptr,
690       UniqueIdentifier.empty() ? nullptr
691                                : MDString::get(VMContext, UniqueIdentifier)};
692   DICompositeType CTy(MDNode::get(VMContext, Elts));
693   AllEnumTypes.push_back(CTy);
694   if (!UniqueIdentifier.empty())
695     retainType(CTy);
696   return CTy;
697 }
698 
699 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
700                                            DIType Ty, DIArray Subscripts) {
701   // TAG_array_type is encoded in DICompositeType format.
702   Metadata *Elts[] = {
703       HeaderBuilder::get(dwarf::DW_TAG_array_type)
704           .concat(StringRef())
705           .concat(0) // Line
706           .concat(Size)
707           .concat(AlignInBits)
708           .concat(0) // Offset
709           .concat(0) // Flags
710           .concat(0)
711           .get(VMContext),
712       nullptr, // Filename/Directory,
713       nullptr, // Unused
714       Ty.getRef(), Subscripts, nullptr, nullptr,
715       nullptr // Type Identifer
716   };
717   return DICompositeType(MDNode::get(VMContext, Elts));
718 }
719 
720 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
721                                             DIType Ty, DIArray Subscripts) {
722   // A vector is an array type with the FlagVector flag applied.
723   Metadata *Elts[] = {
724       HeaderBuilder::get(dwarf::DW_TAG_array_type)
725           .concat("")
726           .concat(0) // Line
727           .concat(Size)
728           .concat(AlignInBits)
729           .concat(0) // Offset
730           .concat(DIType::FlagVector)
731           .concat(0)
732           .get(VMContext),
733       nullptr, // Filename/Directory,
734       nullptr, // Unused
735       Ty.getRef(), Subscripts, nullptr, nullptr,
736       nullptr // Type Identifer
737   };
738   return DICompositeType(MDNode::get(VMContext, Elts));
739 }
740 
741 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
742                                           unsigned FlagsToSet) {
743   DIHeaderFieldIterator I(Header);
744   std::advance(I, 6);
745 
746   unsigned Flags;
747   if (I->getAsInteger(0, Flags))
748     Flags = 0;
749   Flags |= FlagsToSet;
750 
751   return HeaderBuilder()
752       .concat(I.getPrefix())
753       .concat(Flags)
754       .concat(I.getSuffix());
755 }
756 
757 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
758                                   unsigned FlagsToSet) {
759   SmallVector<Metadata *, 9> Elts;
760   MDNode *N = Ty;
761   assert(N && "Unexpected input DIType!");
762   // Update header field.
763   Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
764   for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
765     Elts.push_back(N->getOperand(I));
766 
767   return DIType(MDNode::get(Context, Elts));
768 }
769 
770 DIType DIBuilder::createArtificialType(DIType Ty) {
771   if (Ty.isArtificial())
772     return Ty;
773   return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
774 }
775 
776 DIType DIBuilder::createObjectPointerType(DIType Ty) {
777   if (Ty.isObjectPointer())
778     return Ty;
779   unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
780   return createTypeWithFlags(VMContext, Ty, Flags);
781 }
782 
783 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
784 
785 DIBasicType DIBuilder::createUnspecifiedParameter() {
786   return DIBasicType();
787 }
788 
789 DICompositeType
790 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
791                              DIFile F, unsigned Line, unsigned RuntimeLang,
792                              uint64_t SizeInBits, uint64_t AlignInBits,
793                              StringRef UniqueIdentifier) {
794   // Create a temporary MDNode.
795   Metadata *Elts[] = {
796       HeaderBuilder::get(Tag)
797           .concat(Name)
798           .concat(Line)
799           .concat(SizeInBits)
800           .concat(AlignInBits)
801           .concat(0) // Offset
802           .concat(DIDescriptor::FlagFwdDecl)
803           .concat(RuntimeLang)
804           .get(VMContext),
805       F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
806       DIArray(), nullptr,
807       nullptr, // TemplateParams
808       UniqueIdentifier.empty() ? nullptr
809                                : MDString::get(VMContext, UniqueIdentifier)};
810   MDNode *Node = MDNode::get(VMContext, Elts);
811   DICompositeType RetTy(Node);
812   assert(RetTy.isCompositeType() &&
813          "createForwardDecl result should be a DIType");
814   if (!UniqueIdentifier.empty())
815     retainType(RetTy);
816   return RetTy;
817 }
818 
819 DICompositeType DIBuilder::createReplaceableForwardDecl(
820     unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
821     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
822     StringRef UniqueIdentifier) {
823   // Create a temporary MDNode.
824   Metadata *Elts[] = {
825       HeaderBuilder::get(Tag)
826           .concat(Name)
827           .concat(Line)
828           .concat(SizeInBits)
829           .concat(AlignInBits)
830           .concat(0) // Offset
831           .concat(DIDescriptor::FlagFwdDecl)
832           .concat(RuntimeLang)
833           .get(VMContext),
834       F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
835       DIArray(), nullptr,
836       nullptr, // TemplateParams
837       UniqueIdentifier.empty() ? nullptr
838                                : MDString::get(VMContext, UniqueIdentifier)};
839   DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
840   assert(RetTy.isCompositeType() &&
841          "createReplaceableForwardDecl result should be a DIType");
842   if (!UniqueIdentifier.empty())
843     retainType(RetTy);
844   return RetTy;
845 }
846 
847 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
848   return DIArray(MDNode::get(VMContext, Elements));
849 }
850 
851 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
852   SmallVector<llvm::Metadata *, 16> Elts;
853   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
854     if (Elements[i] && isa<MDNode>(Elements[i]))
855       Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
856     else
857       Elts.push_back(Elements[i]);
858   }
859   return DITypeArray(MDNode::get(VMContext, Elts));
860 }
861 
862 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
863   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
864                           .concat(Lo)
865                           .concat(Count)
866                           .get(VMContext)};
867 
868   return DISubrange(MDNode::get(VMContext, Elts));
869 }
870 
871 static DIGlobalVariable createGlobalVariableHelper(
872     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
873     StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
874     bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
875     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
876 
877   MDNode *TheCtx = getNonCompileUnitScope(Context);
878   if (DIScope(TheCtx).isCompositeType()) {
879     assert(!DICompositeType(TheCtx).getIdentifier() &&
880            "Context of a global variable should not be a type with identifier");
881   }
882 
883   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
884                           .concat(Name)
885                           .concat(Name)
886                           .concat(LinkageName)
887                           .concat(LineNumber)
888                           .concat(isLocalToUnit)
889                           .concat(isDefinition)
890                           .get(VMContext),
891                       TheCtx, F, Ty, getConstantOrNull(Val),
892                       DIDescriptor(Decl)};
893 
894   return DIGlobalVariable(CreateFunc(Elts));
895 }
896 
897 DIGlobalVariable DIBuilder::createGlobalVariable(
898     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
899     unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
900     MDNode *Decl) {
901   return createGlobalVariableHelper(
902       VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
903       Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
904         MDNode *Node = MDNode::get(VMContext, Elts);
905         AllGVs.push_back(Node);
906         return Node;
907       });
908 }
909 
910 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
911     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
912     unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
913     MDNode *Decl) {
914   return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
915                                     LineNumber, Ty, isLocalToUnit, Val, Decl,
916                                     false, [&](ArrayRef<Metadata *> Elts) {
917     return MDNode::getTemporary(VMContext, Elts).release();
918   });
919 }
920 
921 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
922                                           StringRef Name, DIFile File,
923                                           unsigned LineNo, DITypeRef Ty,
924                                           bool AlwaysPreserve, unsigned Flags,
925                                           unsigned ArgNo) {
926   DIDescriptor Context(getNonCompileUnitScope(Scope));
927   assert((!Context || Context.isScope()) &&
928          "createLocalVariable should be called with a valid Context");
929   Metadata *Elts[] = {HeaderBuilder::get(Tag)
930                           .concat(Name)
931                           .concat(LineNo | (ArgNo << 24))
932                           .concat(Flags)
933                           .get(VMContext),
934                       getNonCompileUnitScope(Scope), File, Ty};
935   MDNode *Node = MDNode::get(VMContext, Elts);
936   if (AlwaysPreserve) {
937     // The optimizer may remove local variable. If there is an interest
938     // to preserve variable info in such situation then stash it in a
939     // named mdnode.
940     DISubprogram Fn(getDISubprogram(Scope));
941     assert(Fn && "Missing subprogram for local variable");
942     PreservedVariables[Fn].emplace_back(Node);
943   }
944   DIVariable RetVar(Node);
945   assert(RetVar.isVariable() &&
946          "createLocalVariable should return a valid DIVariable");
947   return RetVar;
948 }
949 
950 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Addr) {
951   auto Header = HeaderBuilder::get(DW_TAG_expression);
952   for (int64_t I : Addr)
953     Header.concat(I);
954   Metadata *Elts[] = {Header.get(VMContext)};
955   return DIExpression(MDNode::get(VMContext, Elts));
956 }
957 
958 DIExpression DIBuilder::createPieceExpression(unsigned OffsetInBytes,
959                                               unsigned SizeInBytes) {
960   int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
961   return createExpression(Addr);
962 }
963 
964 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
965                                        StringRef LinkageName, DIFile File,
966                                        unsigned LineNo, DICompositeType Ty,
967                                        bool isLocalToUnit, bool isDefinition,
968                                        unsigned ScopeLine, unsigned Flags,
969                                        bool isOptimized, Function *Fn,
970                                        MDNode *TParams, MDNode *Decl) {
971   // dragonegg does not generate identifier for types, so using an empty map
972   // to resolve the context should be fine.
973   DITypeIdentifierMap EmptyMap;
974   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
975                         LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
976                         Flags, isOptimized, Fn, TParams, Decl);
977 }
978 
979 static DISubprogram createFunctionHelper(
980     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
981     StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
982     bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
983     bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
984     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
985   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
986          "function types should be subroutines");
987   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
988                           .concat(Name)
989                           .concat(Name)
990                           .concat(LinkageName)
991                           .concat(LineNo)
992                           .concat(isLocalToUnit)
993                           .concat(isDefinition)
994                           .concat(0)
995                           .concat(0)
996                           .concat(Flags)
997                           .concat(isOptimized)
998                           .concat(ScopeLine)
999                           .get(VMContext),
1000                       File.getFileNode(),
1001                       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1002                       nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1003 
1004   DISubprogram S(CreateFunc(Elts));
1005   assert(S.isSubprogram() &&
1006          "createFunction should return a valid DISubprogram");
1007   return S;
1008 }
1009 
1010 
1011 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1012                                        StringRef LinkageName, DIFile File,
1013                                        unsigned LineNo, DICompositeType Ty,
1014                                        bool isLocalToUnit, bool isDefinition,
1015                                        unsigned ScopeLine, unsigned Flags,
1016                                        bool isOptimized, Function *Fn,
1017                                        MDNode *TParams, MDNode *Decl) {
1018   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1019                               LineNo, Ty, isLocalToUnit, isDefinition,
1020                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1021                               MDNode::getTemporary(VMContext, None).release(),
1022                               [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1023     MDNode *Node = MDNode::get(VMContext, Elts);
1024     // Create a named metadata so that we
1025     // do not lose this mdnode.
1026     if (isDefinition)
1027       AllSubprograms.push_back(Node);
1028     return Node;
1029   });
1030 }
1031 
1032 DISubprogram
1033 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1034                                      StringRef LinkageName, DIFile File,
1035                                      unsigned LineNo, DICompositeType Ty,
1036                                      bool isLocalToUnit, bool isDefinition,
1037                                      unsigned ScopeLine, unsigned Flags,
1038                                      bool isOptimized, Function *Fn,
1039                                      MDNode *TParams, MDNode *Decl) {
1040   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1041                               LineNo, Ty, isLocalToUnit, isDefinition,
1042                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1043                               nullptr, [&](ArrayRef<Metadata *> Elts) {
1044     return MDNode::getTemporary(VMContext, Elts).release();
1045   });
1046 }
1047 
1048 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1049                                      StringRef LinkageName, DIFile F,
1050                                      unsigned LineNo, DICompositeType Ty,
1051                                      bool isLocalToUnit, bool isDefinition,
1052                                      unsigned VK, unsigned VIndex,
1053                                      DIType VTableHolder, unsigned Flags,
1054                                      bool isOptimized, Function *Fn,
1055                                      MDNode *TParam) {
1056   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1057          "function types should be subroutines");
1058   assert(getNonCompileUnitScope(Context) &&
1059          "Methods should have both a Context and a context that isn't "
1060          "the compile unit.");
1061   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1062                           .concat(Name)
1063                           .concat(Name)
1064                           .concat(LinkageName)
1065                           .concat(LineNo)
1066                           .concat(isLocalToUnit)
1067                           .concat(isDefinition)
1068                           .concat(VK)
1069                           .concat(VIndex)
1070                           .concat(Flags)
1071                           .concat(isOptimized)
1072                           .concat(LineNo)
1073                           // FIXME: Do we want to use different scope/lines?
1074                           .get(VMContext),
1075                       F.getFileNode(), DIScope(Context).getRef(), Ty,
1076                       VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1077                       nullptr, nullptr};
1078   MDNode *Node = MDNode::get(VMContext, Elts);
1079   if (isDefinition)
1080     AllSubprograms.push_back(Node);
1081   DISubprogram S(Node);
1082   assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1083   return S;
1084 }
1085 
1086 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1087                                        DIFile File, unsigned LineNo) {
1088   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1089                           .concat(Name)
1090                           .concat(LineNo)
1091                           .get(VMContext),
1092                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1093   DINameSpace R(MDNode::get(VMContext, Elts));
1094   assert(R.Verify() &&
1095          "createNameSpace should return a verifiable DINameSpace");
1096   return R;
1097 }
1098 
1099 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1100                                                      DIFile File,
1101                                                      unsigned Discriminator) {
1102   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1103                           .concat(Discriminator)
1104                           .get(VMContext),
1105                       File.getFileNode(), Scope};
1106   DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1107   assert(
1108       R.Verify() &&
1109       "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1110   return R;
1111 }
1112 
1113 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1114                                              unsigned Line, unsigned Col) {
1115   // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1116   // I believe the right way is to have a self-referential element in the node.
1117   // Also: why do we bother with line/column - they're not used and the
1118   // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1119   // for uniquing, yet then we have this other solution (because line/col were
1120   // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1121 
1122   // Defeat MDNode uniquing for lexical blocks by using unique id.
1123   static unsigned int unique_id = 0;
1124   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1125                           .concat(Line)
1126                           .concat(Col)
1127                           .concat(unique_id++)
1128                           .get(VMContext),
1129                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1130   DILexicalBlock R(MDNode::get(VMContext, Elts));
1131   assert(R.Verify() &&
1132          "createLexicalBlock should return a verifiable DILexicalBlock");
1133   return R;
1134 }
1135 
1136 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1137   assert(V && "no value passed to dbg intrinsic");
1138   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1139 }
1140 
1141 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1142                                       DIExpression Expr,
1143                                       Instruction *InsertBefore) {
1144   assert(VarInfo.isVariable() &&
1145          "empty or invalid DIVariable passed to dbg.declare");
1146   if (!DeclareFn)
1147     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1148 
1149   trackIfUnresolved(VarInfo);
1150   trackIfUnresolved(Expr);
1151   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1152                    MetadataAsValue::get(VMContext, VarInfo),
1153                    MetadataAsValue::get(VMContext, Expr)};
1154   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1155 }
1156 
1157 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1158                                       DIExpression Expr,
1159                                       BasicBlock *InsertAtEnd) {
1160   assert(VarInfo.isVariable() &&
1161          "empty or invalid DIVariable passed to dbg.declare");
1162   if (!DeclareFn)
1163     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1164 
1165   trackIfUnresolved(VarInfo);
1166   trackIfUnresolved(Expr);
1167   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1168                    MetadataAsValue::get(VMContext, VarInfo),
1169                    MetadataAsValue::get(VMContext, Expr)};
1170 
1171   // If this block already has a terminator then insert this intrinsic
1172   // before the terminator.
1173   if (TerminatorInst *T = InsertAtEnd->getTerminator())
1174     return CallInst::Create(DeclareFn, Args, "", T);
1175   else
1176     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1177 }
1178 
1179 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1180                                                 DIVariable VarInfo,
1181                                                 DIExpression Expr,
1182                                                 Instruction *InsertBefore) {
1183   assert(V && "no value passed to dbg.value");
1184   assert(VarInfo.isVariable() &&
1185          "empty or invalid DIVariable passed to dbg.value");
1186   if (!ValueFn)
1187     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1188 
1189   trackIfUnresolved(VarInfo);
1190   trackIfUnresolved(Expr);
1191   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1192                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1193                    MetadataAsValue::get(VMContext, VarInfo),
1194                    MetadataAsValue::get(VMContext, Expr)};
1195   return CallInst::Create(ValueFn, Args, "", InsertBefore);
1196 }
1197 
1198 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1199                                                 DIVariable VarInfo,
1200                                                 DIExpression Expr,
1201                                                 BasicBlock *InsertAtEnd) {
1202   assert(V && "no value passed to dbg.value");
1203   assert(VarInfo.isVariable() &&
1204          "empty or invalid DIVariable passed to dbg.value");
1205   if (!ValueFn)
1206     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1207 
1208   trackIfUnresolved(VarInfo);
1209   trackIfUnresolved(Expr);
1210   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1211                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1212                    MetadataAsValue::get(VMContext, VarInfo),
1213                    MetadataAsValue::get(VMContext, Expr)};
1214   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1215 }
1216 
1217 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1218   T.setContainingType(VTableHolder);
1219 
1220   // If this didn't create a self-reference, just return.
1221   if (T != VTableHolder)
1222     return;
1223 
1224   // Look for unresolved operands.  T has dropped RAUW support and is already
1225   // marked resolved, orphaning any cycles underneath it.
1226   assert(T->isResolved() && "Expected self-reference to be resolved");
1227   for (const MDOperand &O : T->operands())
1228     if (auto *N = dyn_cast_or_null<MDNode>(O))
1229       trackIfUnresolved(N);
1230 }
1231 
1232 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1233                               DIArray TParams) {
1234   T.setArrays(Elements, TParams);
1235 
1236   // If T isn't resolved, there's no problem.
1237   if (!T->isResolved())
1238     return;
1239 
1240   // If "T" is resolved, it may be due to a self-reference cycle.  Track the
1241   // arrays explicitly if they're unresolved, or else the cycles will be
1242   // orphaned.
1243   if (Elements)
1244     trackIfUnresolved(Elements);
1245   if (TParams)
1246     trackIfUnresolved(TParams);
1247 }
1248