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