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