• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "LLVMContextImpl.h"
23 
24 using namespace llvm;
25 using namespace llvm::dwarf;
26 
DIBuilder(Module & m,bool AllowUnresolvedNodes)27 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
28   : M(m), VMContext(M.getContext()), CUNode(nullptr),
29       DeclareFn(nullptr), ValueFn(nullptr),
30       AllowUnresolvedNodes(AllowUnresolvedNodes) {}
31 
trackIfUnresolved(MDNode * N)32 void DIBuilder::trackIfUnresolved(MDNode *N) {
33   if (!N)
34     return;
35   if (N->isResolved())
36     return;
37 
38   assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
39   UnresolvedNodes.emplace_back(N);
40 }
41 
finalize()42 void DIBuilder::finalize() {
43   if (!CUNode) {
44     assert(!AllowUnresolvedNodes &&
45            "creating type nodes without a CU is not supported");
46     return;
47   }
48 
49   CUNode->replaceEnumTypes(MDTuple::get(VMContext, AllEnumTypes));
50 
51   SmallVector<Metadata *, 16> RetainValues;
52   // Declarations and definitions of the same type may be retained. Some
53   // clients RAUW these pairs, leaving duplicates in the retained types
54   // list. Use a set to remove the duplicates while we transform the
55   // TrackingVHs back into Values.
56   SmallPtrSet<Metadata *, 16> RetainSet;
57   for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
58     if (RetainSet.insert(AllRetainTypes[I]).second)
59       RetainValues.push_back(AllRetainTypes[I]);
60 
61   if (!RetainValues.empty())
62     CUNode->replaceRetainedTypes(MDTuple::get(VMContext, RetainValues));
63 
64   DISubprogramArray SPs = MDTuple::get(VMContext, AllSubprograms);
65   auto resolveVariables = [&](DISubprogram *SP) {
66     MDTuple *Temp = SP->getVariables().get();
67     if (!Temp)
68       return;
69 
70     SmallVector<Metadata *, 4> Variables;
71 
72     auto PV = PreservedVariables.find(SP);
73     if (PV != PreservedVariables.end())
74       Variables.append(PV->second.begin(), PV->second.end());
75 
76     DINodeArray AV = getOrCreateArray(Variables);
77     TempMDTuple(Temp)->replaceAllUsesWith(AV.get());
78   };
79   for (auto *SP : SPs)
80     resolveVariables(SP);
81   for (auto *N : RetainValues)
82     if (auto *SP = dyn_cast<DISubprogram>(N))
83       resolveVariables(SP);
84 
85   if (!AllGVs.empty())
86     CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));
87 
88   if (!AllImportedModules.empty())
89     CUNode->replaceImportedEntities(MDTuple::get(
90         VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
91                                                AllImportedModules.end())));
92 
93   // Now that all temp nodes have been replaced or deleted, resolve remaining
94   // cycles.
95   for (const auto &N : UnresolvedNodes)
96     if (N && !N->isResolved())
97       N->resolveCycles();
98   UnresolvedNodes.clear();
99 
100   // Can't handle unresolved nodes anymore.
101   AllowUnresolvedNodes = false;
102 }
103 
104 /// If N is compile unit return NULL otherwise return N.
getNonCompileUnitScope(DIScope * N)105 static DIScope *getNonCompileUnitScope(DIScope *N) {
106   if (!N || isa<DICompileUnit>(N))
107     return nullptr;
108   return cast<DIScope>(N);
109 }
110 
createCompileUnit(unsigned Lang,StringRef Filename,StringRef Directory,StringRef Producer,bool isOptimized,StringRef Flags,unsigned RunTimeVer,StringRef SplitName,DICompileUnit::DebugEmissionKind Kind,uint64_t DWOId)111 DICompileUnit *DIBuilder::createCompileUnit(
112     unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer,
113     bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
114     DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId) {
115 
116   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
117           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
118          "Invalid Language tag");
119   assert(!Filename.empty() &&
120          "Unable to create compile unit without filename");
121 
122   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
123   CUNode = DICompileUnit::getDistinct(
124       VMContext, Lang, DIFile::get(VMContext, Filename, Directory), Producer,
125       isOptimized, Flags, RunTimeVer, SplitName, Kind, nullptr, nullptr,
126       nullptr, nullptr, nullptr, DWOId);
127 
128   // Create a named metadata so that it is easier to find cu in a module.
129   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
130   NMD->addOperand(CUNode);
131   trackIfUnresolved(CUNode);
132   return CUNode;
133 }
134 
135 static DIImportedEntity *
createImportedModule(LLVMContext & C,dwarf::Tag Tag,DIScope * Context,Metadata * NS,unsigned Line,StringRef Name,SmallVectorImpl<TrackingMDNodeRef> & AllImportedModules)136 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context,
137                      Metadata *NS, unsigned Line, StringRef Name,
138                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
139   unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size();
140   auto *M = DIImportedEntity::get(C, Tag, Context, DINodeRef(NS), Line, Name);
141   if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
142     // A new Imported Entity was just added to the context.
143     // Add it to the Imported Modules list.
144     AllImportedModules.emplace_back(M);
145   return M;
146 }
147 
createImportedModule(DIScope * Context,DINamespace * NS,unsigned Line)148 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
149                                                   DINamespace *NS,
150                                                   unsigned Line) {
151   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
152                                 Context, NS, Line, StringRef(), AllImportedModules);
153 }
154 
createImportedModule(DIScope * Context,DIImportedEntity * NS,unsigned Line)155 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
156                                                   DIImportedEntity *NS,
157                                                   unsigned Line) {
158   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
159                                 Context, NS, Line, StringRef(), AllImportedModules);
160 }
161 
createImportedModule(DIScope * Context,DIModule * M,unsigned Line)162 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M,
163                                                   unsigned Line) {
164   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
165                                 Context, M, Line, StringRef(), AllImportedModules);
166 }
167 
createImportedDeclaration(DIScope * Context,DINode * Decl,unsigned Line,StringRef Name)168 DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context,
169                                                        DINode *Decl,
170                                                        unsigned Line,
171                                                        StringRef Name) {
172   // Make sure to use the unique identifier based metadata reference for
173   // types that have one.
174   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
175                                 Context, Decl, Line, Name, AllImportedModules);
176 }
177 
createFile(StringRef Filename,StringRef Directory)178 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory) {
179   return DIFile::get(VMContext, Filename, Directory);
180 }
181 
createEnumerator(StringRef Name,int64_t Val)182 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
183   assert(!Name.empty() && "Unable to create enumerator without name");
184   return DIEnumerator::get(VMContext, Val, Name);
185 }
186 
createUnspecifiedType(StringRef Name)187 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
188   assert(!Name.empty() && "Unable to create type without name");
189   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
190 }
191 
createNullPtrType()192 DIBasicType *DIBuilder::createNullPtrType() {
193   return createUnspecifiedType("decltype(nullptr)");
194 }
195 
createBasicType(StringRef Name,uint64_t SizeInBits,uint64_t AlignInBits,unsigned Encoding)196 DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
197                                         uint64_t AlignInBits,
198                                         unsigned Encoding) {
199   assert(!Name.empty() && "Unable to create type without name");
200   return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
201                           AlignInBits, Encoding);
202 }
203 
createQualifiedType(unsigned Tag,DIType * FromTy)204 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
205   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0,
206                             0, 0, 0);
207 }
208 
createPointerType(DIType * PointeeTy,uint64_t SizeInBits,uint64_t AlignInBits,StringRef Name)209 DIDerivedType *DIBuilder::createPointerType(DIType *PointeeTy,
210                                             uint64_t SizeInBits,
211                                             uint64_t AlignInBits,
212                                             StringRef Name) {
213   // FIXME: Why is there a name here?
214   return DIDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
215                             nullptr, 0, nullptr, PointeeTy, SizeInBits,
216                             AlignInBits, 0, 0);
217 }
218 
createMemberPointerType(DIType * PointeeTy,DIType * Base,uint64_t SizeInBits,uint64_t AlignInBits,unsigned Flags)219 DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
220                                                   DIType *Base,
221                                                   uint64_t SizeInBits,
222                                                   uint64_t AlignInBits,
223                                                   unsigned Flags) {
224   return DIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
225                             nullptr, 0, nullptr, PointeeTy, SizeInBits,
226                             AlignInBits, 0, Flags, Base);
227 }
228 
createReferenceType(unsigned Tag,DIType * RTy,uint64_t SizeInBits,uint64_t AlignInBits)229 DIDerivedType *DIBuilder::createReferenceType(unsigned Tag, DIType *RTy,
230                                               uint64_t SizeInBits,
231                                               uint64_t AlignInBits) {
232   assert(RTy && "Unable to create reference type");
233   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, RTy,
234                             SizeInBits, AlignInBits, 0, 0);
235 }
236 
createTypedef(DIType * Ty,StringRef Name,DIFile * File,unsigned LineNo,DIScope * Context)237 DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name,
238                                         DIFile *File, unsigned LineNo,
239                                         DIScope *Context) {
240   return DIDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name, File,
241                             LineNo, getNonCompileUnitScope(Context), Ty, 0, 0,
242                             0, 0);
243 }
244 
createFriend(DIType * Ty,DIType * FriendTy)245 DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) {
246   assert(Ty && "Invalid type!");
247   assert(FriendTy && "Invalid friend type!");
248   return DIDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0, Ty,
249                             FriendTy, 0, 0, 0, 0);
250 }
251 
createInheritance(DIType * Ty,DIType * BaseTy,uint64_t BaseOffset,unsigned Flags)252 DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy,
253                                             uint64_t BaseOffset,
254                                             unsigned Flags) {
255   assert(Ty && "Unable to create inheritance");
256   return DIDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
257                             0, Ty, BaseTy, 0, 0, BaseOffset, Flags);
258 }
259 
createMemberType(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,uint64_t OffsetInBits,unsigned Flags,DIType * Ty)260 DIDerivedType *DIBuilder::createMemberType(DIScope *Scope, StringRef Name,
261                                            DIFile *File, unsigned LineNumber,
262                                            uint64_t SizeInBits,
263                                            uint64_t AlignInBits,
264                                            uint64_t OffsetInBits,
265                                            unsigned Flags, DIType *Ty) {
266   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
267                             LineNumber, getNonCompileUnitScope(Scope), Ty,
268                             SizeInBits, AlignInBits, OffsetInBits, Flags);
269 }
270 
getConstantOrNull(Constant * C)271 static ConstantAsMetadata *getConstantOrNull(Constant *C) {
272   if (C)
273     return ConstantAsMetadata::get(C);
274   return nullptr;
275 }
276 
createBitFieldMemberType(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,uint64_t OffsetInBits,uint64_t StorageOffsetInBits,unsigned Flags,DIType * Ty)277 DIDerivedType *DIBuilder::createBitFieldMemberType(
278     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
279     uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
280     uint64_t StorageOffsetInBits, unsigned Flags, DIType *Ty) {
281   Flags |= DINode::FlagBitField;
282   return DIDerivedType::get(
283       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
284       getNonCompileUnitScope(Scope), Ty, SizeInBits, AlignInBits, OffsetInBits,
285       Flags, ConstantAsMetadata::get(ConstantInt::get(
286                  IntegerType::get(VMContext, 64), StorageOffsetInBits)));
287 }
288 
createStaticMemberType(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNumber,DIType * Ty,unsigned Flags,llvm::Constant * Val)289 DIDerivedType *DIBuilder::createStaticMemberType(DIScope *Scope, StringRef Name,
290                                                  DIFile *File,
291                                                  unsigned LineNumber,
292                                                  DIType *Ty, unsigned Flags,
293                                                  llvm::Constant *Val) {
294   Flags |= DINode::FlagStaticMember;
295   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
296                             LineNumber, getNonCompileUnitScope(Scope), Ty, 0, 0,
297                             0, Flags, getConstantOrNull(Val));
298 }
299 
createObjCIVar(StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,uint64_t OffsetInBits,unsigned Flags,DIType * Ty,MDNode * PropertyNode)300 DIDerivedType *DIBuilder::createObjCIVar(StringRef Name, DIFile *File,
301                                          unsigned LineNumber,
302                                          uint64_t SizeInBits,
303                                          uint64_t AlignInBits,
304                                          uint64_t OffsetInBits, unsigned Flags,
305                                          DIType *Ty, MDNode *PropertyNode) {
306   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
307                             LineNumber, getNonCompileUnitScope(File), Ty,
308                             SizeInBits, AlignInBits, OffsetInBits, Flags,
309                             PropertyNode);
310 }
311 
312 DIObjCProperty *
createObjCProperty(StringRef Name,DIFile * File,unsigned LineNumber,StringRef GetterName,StringRef SetterName,unsigned PropertyAttributes,DIType * Ty)313 DIBuilder::createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber,
314                               StringRef GetterName, StringRef SetterName,
315                               unsigned PropertyAttributes, DIType *Ty) {
316   return DIObjCProperty::get(VMContext, Name, File, LineNumber, GetterName,
317                              SetterName, PropertyAttributes, Ty);
318 }
319 
320 DITemplateTypeParameter *
createTemplateTypeParameter(DIScope * Context,StringRef Name,DIType * Ty)321 DIBuilder::createTemplateTypeParameter(DIScope *Context, StringRef Name,
322                                        DIType *Ty) {
323   assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit");
324   return DITemplateTypeParameter::get(VMContext, Name, Ty);
325 }
326 
327 static DITemplateValueParameter *
createTemplateValueParameterHelper(LLVMContext & VMContext,unsigned Tag,DIScope * Context,StringRef Name,DIType * Ty,Metadata * MD)328 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
329                                    DIScope *Context, StringRef Name, DIType *Ty,
330                                    Metadata *MD) {
331   assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit");
332   return DITemplateValueParameter::get(VMContext, Tag, Name, Ty, MD);
333 }
334 
335 DITemplateValueParameter *
createTemplateValueParameter(DIScope * Context,StringRef Name,DIType * Ty,Constant * Val)336 DIBuilder::createTemplateValueParameter(DIScope *Context, StringRef Name,
337                                         DIType *Ty, Constant *Val) {
338   return createTemplateValueParameterHelper(
339       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
340       getConstantOrNull(Val));
341 }
342 
343 DITemplateValueParameter *
createTemplateTemplateParameter(DIScope * Context,StringRef Name,DIType * Ty,StringRef Val)344 DIBuilder::createTemplateTemplateParameter(DIScope *Context, StringRef Name,
345                                            DIType *Ty, StringRef Val) {
346   return createTemplateValueParameterHelper(
347       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
348       MDString::get(VMContext, Val));
349 }
350 
351 DITemplateValueParameter *
createTemplateParameterPack(DIScope * Context,StringRef Name,DIType * Ty,DINodeArray Val)352 DIBuilder::createTemplateParameterPack(DIScope *Context, StringRef Name,
353                                        DIType *Ty, DINodeArray Val) {
354   return createTemplateValueParameterHelper(
355       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
356       Val.get());
357 }
358 
createClassType(DIScope * Context,StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,uint64_t OffsetInBits,unsigned Flags,DIType * DerivedFrom,DINodeArray Elements,DIType * VTableHolder,MDNode * TemplateParams,StringRef UniqueIdentifier)359 DICompositeType *DIBuilder::createClassType(
360     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
361     uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
362     unsigned Flags, DIType *DerivedFrom, DINodeArray Elements,
363     DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) {
364   assert((!Context || isa<DIScope>(Context)) &&
365          "createClassType should be called with a valid Context");
366 
367   auto *R = DICompositeType::get(
368       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
369       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits,
370       OffsetInBits, Flags, Elements, 0, VTableHolder,
371       cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
372   trackIfUnresolved(R);
373   return R;
374 }
375 
createStructType(DIScope * Context,StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,unsigned Flags,DIType * DerivedFrom,DINodeArray Elements,unsigned RunTimeLang,DIType * VTableHolder,StringRef UniqueIdentifier)376 DICompositeType *DIBuilder::createStructType(
377     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
378     uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
379     DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
380     DIType *VTableHolder, StringRef UniqueIdentifier) {
381   auto *R = DICompositeType::get(
382       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
383       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits, 0,
384       Flags, Elements, RunTimeLang, VTableHolder, nullptr, UniqueIdentifier);
385   trackIfUnresolved(R);
386   return R;
387 }
388 
createUnionType(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,unsigned Flags,DINodeArray Elements,unsigned RunTimeLang,StringRef UniqueIdentifier)389 DICompositeType *DIBuilder::createUnionType(
390     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
391     uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
392     DINodeArray Elements, unsigned RunTimeLang, StringRef UniqueIdentifier) {
393   auto *R = DICompositeType::get(
394       VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
395       getNonCompileUnitScope(Scope), nullptr, SizeInBits, AlignInBits, 0, Flags,
396       Elements, RunTimeLang, nullptr, nullptr, UniqueIdentifier);
397   trackIfUnresolved(R);
398   return R;
399 }
400 
createSubroutineType(DITypeRefArray ParameterTypes,unsigned Flags,unsigned CC)401 DISubroutineType *DIBuilder::createSubroutineType(DITypeRefArray ParameterTypes,
402                                                   unsigned Flags, unsigned CC) {
403   return DISubroutineType::get(VMContext, Flags, CC, ParameterTypes);
404 }
405 
createExternalTypeRef(unsigned Tag,DIFile * File,StringRef UniqueIdentifier)406 DICompositeType *DIBuilder::createExternalTypeRef(unsigned Tag, DIFile *File,
407                                                   StringRef UniqueIdentifier) {
408   assert(!UniqueIdentifier.empty() && "external type ref without uid");
409   return DICompositeType::get(VMContext, Tag, "", nullptr, 0, nullptr, nullptr,
410                               0, 0, 0, DINode::FlagExternalTypeRef, nullptr, 0,
411                               nullptr, nullptr, UniqueIdentifier);
412 }
413 
createEnumerationType(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNumber,uint64_t SizeInBits,uint64_t AlignInBits,DINodeArray Elements,DIType * UnderlyingType,StringRef UniqueIdentifier)414 DICompositeType *DIBuilder::createEnumerationType(
415     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
416     uint64_t SizeInBits, uint64_t AlignInBits, DINodeArray Elements,
417     DIType *UnderlyingType, StringRef UniqueIdentifier) {
418   auto *CTy = DICompositeType::get(
419       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
420       getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0,
421       0, Elements, 0, nullptr, nullptr, UniqueIdentifier);
422   AllEnumTypes.push_back(CTy);
423   trackIfUnresolved(CTy);
424   return CTy;
425 }
426 
createArrayType(uint64_t Size,uint64_t AlignInBits,DIType * Ty,DINodeArray Subscripts)427 DICompositeType *DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
428                                             DIType *Ty,
429                                             DINodeArray Subscripts) {
430   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
431                                  nullptr, 0, nullptr, Ty, Size, AlignInBits, 0,
432                                  0, Subscripts, 0, nullptr);
433   trackIfUnresolved(R);
434   return R;
435 }
436 
createVectorType(uint64_t Size,uint64_t AlignInBits,DIType * Ty,DINodeArray Subscripts)437 DICompositeType *DIBuilder::createVectorType(uint64_t Size,
438                                              uint64_t AlignInBits, DIType *Ty,
439                                              DINodeArray Subscripts) {
440   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
441                                  nullptr, 0, nullptr, Ty, Size, AlignInBits, 0,
442                                  DINode::FlagVector, Subscripts, 0, nullptr);
443   trackIfUnresolved(R);
444   return R;
445 }
446 
createTypeWithFlags(LLVMContext & Context,DIType * Ty,unsigned FlagsToSet)447 static DIType *createTypeWithFlags(LLVMContext &Context, DIType *Ty,
448                                    unsigned FlagsToSet) {
449   auto NewTy = Ty->clone();
450   NewTy->setFlags(NewTy->getFlags() | FlagsToSet);
451   return MDNode::replaceWithUniqued(std::move(NewTy));
452 }
453 
createArtificialType(DIType * Ty)454 DIType *DIBuilder::createArtificialType(DIType *Ty) {
455   // FIXME: Restrict this to the nodes where it's valid.
456   if (Ty->isArtificial())
457     return Ty;
458   return createTypeWithFlags(VMContext, Ty, DINode::FlagArtificial);
459 }
460 
createObjectPointerType(DIType * Ty)461 DIType *DIBuilder::createObjectPointerType(DIType *Ty) {
462   // FIXME: Restrict this to the nodes where it's valid.
463   if (Ty->isObjectPointer())
464     return Ty;
465   unsigned Flags = DINode::FlagObjectPointer | DINode::FlagArtificial;
466   return createTypeWithFlags(VMContext, Ty, Flags);
467 }
468 
retainType(DIScope * T)469 void DIBuilder::retainType(DIScope *T) {
470   assert(T && "Expected non-null type");
471   assert((isa<DIType>(T) || (isa<DISubprogram>(T) &&
472                              cast<DISubprogram>(T)->isDefinition() == false)) &&
473          "Expected type or subprogram declaration");
474   AllRetainTypes.emplace_back(T);
475 }
476 
createUnspecifiedParameter()477 DIBasicType *DIBuilder::createUnspecifiedParameter() { return nullptr; }
478 
479 DICompositeType *
createForwardDecl(unsigned Tag,StringRef Name,DIScope * Scope,DIFile * F,unsigned Line,unsigned RuntimeLang,uint64_t SizeInBits,uint64_t AlignInBits,StringRef UniqueIdentifier)480 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIScope *Scope,
481                              DIFile *F, unsigned Line, unsigned RuntimeLang,
482                              uint64_t SizeInBits, uint64_t AlignInBits,
483                              StringRef UniqueIdentifier) {
484   // FIXME: Define in terms of createReplaceableForwardDecl() by calling
485   // replaceWithUniqued().
486   auto *RetTy = DICompositeType::get(
487       VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr,
488       SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl, nullptr, RuntimeLang,
489       nullptr, nullptr, UniqueIdentifier);
490   trackIfUnresolved(RetTy);
491   return RetTy;
492 }
493 
createReplaceableCompositeType(unsigned Tag,StringRef Name,DIScope * Scope,DIFile * F,unsigned Line,unsigned RuntimeLang,uint64_t SizeInBits,uint64_t AlignInBits,unsigned Flags,StringRef UniqueIdentifier)494 DICompositeType *DIBuilder::createReplaceableCompositeType(
495     unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
496     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
497     unsigned Flags, StringRef UniqueIdentifier) {
498   auto *RetTy =
499       DICompositeType::getTemporary(
500           VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr,
501           SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
502           nullptr, UniqueIdentifier)
503           .release();
504   trackIfUnresolved(RetTy);
505   return RetTy;
506 }
507 
getOrCreateArray(ArrayRef<Metadata * > Elements)508 DINodeArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
509   return MDTuple::get(VMContext, Elements);
510 }
511 
getOrCreateTypeArray(ArrayRef<Metadata * > Elements)512 DITypeRefArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
513   SmallVector<llvm::Metadata *, 16> Elts;
514   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
515     if (Elements[i] && isa<MDNode>(Elements[i]))
516       Elts.push_back(cast<DIType>(Elements[i]));
517     else
518       Elts.push_back(Elements[i]);
519   }
520   return DITypeRefArray(MDNode::get(VMContext, Elts));
521 }
522 
getOrCreateSubrange(int64_t Lo,int64_t Count)523 DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
524   return DISubrange::get(VMContext, Count, Lo);
525 }
526 
checkGlobalVariableScope(DIScope * Context)527 static void checkGlobalVariableScope(DIScope *Context) {
528 #ifndef NDEBUG
529   if (auto *CT =
530           dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context)))
531     assert(CT->getIdentifier().empty() &&
532            "Context of a global variable should not be a type with identifier");
533 #endif
534 }
535 
createGlobalVariable(DIScope * Context,StringRef Name,StringRef LinkageName,DIFile * F,unsigned LineNumber,DIType * Ty,bool isLocalToUnit,Constant * Val,MDNode * Decl)536 DIGlobalVariable *DIBuilder::createGlobalVariable(
537     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
538     unsigned LineNumber, DIType *Ty, bool isLocalToUnit, Constant *Val,
539     MDNode *Decl) {
540   checkGlobalVariableScope(Context);
541 
542   auto *N = DIGlobalVariable::getDistinct(
543       VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
544       LineNumber, Ty, isLocalToUnit, true, Val,
545       cast_or_null<DIDerivedType>(Decl));
546   AllGVs.push_back(N);
547   return N;
548 }
549 
createTempGlobalVariableFwdDecl(DIScope * Context,StringRef Name,StringRef LinkageName,DIFile * F,unsigned LineNumber,DIType * Ty,bool isLocalToUnit,Constant * Val,MDNode * Decl)550 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
551     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
552     unsigned LineNumber, DIType *Ty, bool isLocalToUnit, Constant *Val,
553     MDNode *Decl) {
554   checkGlobalVariableScope(Context);
555 
556   return DIGlobalVariable::getTemporary(
557              VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
558              LineNumber, Ty, isLocalToUnit, false, Val,
559              cast_or_null<DIDerivedType>(Decl))
560       .release();
561 }
562 
createLocalVariable(LLVMContext & VMContext,DenseMap<MDNode *,SmallVector<TrackingMDNodeRef,1>> & PreservedVariables,DIScope * Scope,StringRef Name,unsigned ArgNo,DIFile * File,unsigned LineNo,DIType * Ty,bool AlwaysPreserve,unsigned Flags)563 static DILocalVariable *createLocalVariable(
564     LLVMContext &VMContext,
565     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
566     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
567     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, unsigned Flags) {
568   // FIXME: Why getNonCompileUnitScope()?
569   // FIXME: Why is "!Context" okay here?
570   // FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT
571   // the only valid scopes)?
572   DIScope *Context = getNonCompileUnitScope(Scope);
573 
574   auto *Node =
575       DILocalVariable::get(VMContext, cast_or_null<DILocalScope>(Context), Name,
576                            File, LineNo, Ty, ArgNo, Flags);
577   if (AlwaysPreserve) {
578     // The optimizer may remove local variables. If there is an interest
579     // to preserve variable info in such situation then stash it in a
580     // named mdnode.
581     DISubprogram *Fn = getDISubprogram(Scope);
582     assert(Fn && "Missing subprogram for local variable");
583     PreservedVariables[Fn].emplace_back(Node);
584   }
585   return Node;
586 }
587 
createAutoVariable(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNo,DIType * Ty,bool AlwaysPreserve,unsigned Flags)588 DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name,
589                                                DIFile *File, unsigned LineNo,
590                                                DIType *Ty, bool AlwaysPreserve,
591                                                unsigned Flags) {
592   return createLocalVariable(VMContext, PreservedVariables, Scope, Name,
593                              /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve,
594                              Flags);
595 }
596 
createParameterVariable(DIScope * Scope,StringRef Name,unsigned ArgNo,DIFile * File,unsigned LineNo,DIType * Ty,bool AlwaysPreserve,unsigned Flags)597 DILocalVariable *DIBuilder::createParameterVariable(
598     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
599     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, unsigned Flags) {
600   assert(ArgNo && "Expected non-zero argument number for parameter");
601   return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo,
602                              File, LineNo, Ty, AlwaysPreserve, Flags);
603 }
604 
createExpression(ArrayRef<uint64_t> Addr)605 DIExpression *DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
606   return DIExpression::get(VMContext, Addr);
607 }
608 
createExpression(ArrayRef<int64_t> Signed)609 DIExpression *DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
610   // TODO: Remove the callers of this signed version and delete.
611   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
612   return createExpression(Addr);
613 }
614 
createBitPieceExpression(unsigned OffsetInBytes,unsigned SizeInBytes)615 DIExpression *DIBuilder::createBitPieceExpression(unsigned OffsetInBytes,
616                                                   unsigned SizeInBytes) {
617   uint64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBytes, SizeInBytes};
618   return DIExpression::get(VMContext, Addr);
619 }
620 
621 template <class... Ts>
getSubprogram(bool IsDistinct,Ts &&...Args)622 static DISubprogram *getSubprogram(bool IsDistinct, Ts &&... Args) {
623   if (IsDistinct)
624     return DISubprogram::getDistinct(std::forward<Ts>(Args)...);
625   return DISubprogram::get(std::forward<Ts>(Args)...);
626 }
627 
createFunction(DIScope * Context,StringRef Name,StringRef LinkageName,DIFile * File,unsigned LineNo,DISubroutineType * Ty,bool isLocalToUnit,bool isDefinition,unsigned ScopeLine,unsigned Flags,bool isOptimized,DITemplateParameterArray TParams,DISubprogram * Decl)628 DISubprogram *DIBuilder::createFunction(
629     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
630     unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
631     bool isDefinition, unsigned ScopeLine, unsigned Flags, bool isOptimized,
632     DITemplateParameterArray TParams, DISubprogram *Decl) {
633   auto *Node = getSubprogram(
634       /* IsDistinct = */ isDefinition, VMContext,
635       getNonCompileUnitScope(Context), Name, LinkageName, File, LineNo, Ty,
636       isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, 0, Flags,
637       isOptimized, isDefinition ? CUNode : nullptr, TParams, Decl,
638       MDTuple::getTemporary(VMContext, None).release());
639 
640   if (isDefinition)
641     AllSubprograms.push_back(Node);
642   trackIfUnresolved(Node);
643   return Node;
644 }
645 
createTempFunctionFwdDecl(DIScope * Context,StringRef Name,StringRef LinkageName,DIFile * File,unsigned LineNo,DISubroutineType * Ty,bool isLocalToUnit,bool isDefinition,unsigned ScopeLine,unsigned Flags,bool isOptimized,DITemplateParameterArray TParams,DISubprogram * Decl)646 DISubprogram *DIBuilder::createTempFunctionFwdDecl(
647     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
648     unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
649     bool isDefinition, unsigned ScopeLine, unsigned Flags, bool isOptimized,
650     DITemplateParameterArray TParams, DISubprogram *Decl) {
651   return DISubprogram::getTemporary(
652              VMContext, getNonCompileUnitScope(Context), Name, LinkageName,
653              File, LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine, nullptr,
654              0, 0, 0, Flags, isOptimized, isDefinition ? CUNode : nullptr,
655              TParams, Decl, nullptr)
656       .release();
657 }
658 
659 DISubprogram *
createMethod(DIScope * Context,StringRef Name,StringRef LinkageName,DIFile * F,unsigned LineNo,DISubroutineType * Ty,bool isLocalToUnit,bool isDefinition,unsigned VK,unsigned VIndex,int ThisAdjustment,DIType * VTableHolder,unsigned Flags,bool isOptimized,DITemplateParameterArray TParams)660 DIBuilder::createMethod(DIScope *Context, StringRef Name, StringRef LinkageName,
661                         DIFile *F, unsigned LineNo, DISubroutineType *Ty,
662                         bool isLocalToUnit, bool isDefinition, unsigned VK,
663                         unsigned VIndex, int ThisAdjustment,
664                         DIType *VTableHolder, unsigned Flags, bool isOptimized,
665                         DITemplateParameterArray TParams) {
666   assert(getNonCompileUnitScope(Context) &&
667          "Methods should have both a Context and a context that isn't "
668          "the compile unit.");
669   // FIXME: Do we want to use different scope/lines?
670   auto *SP = getSubprogram(
671       /* IsDistinct = */ isDefinition, VMContext, cast<DIScope>(Context), Name,
672       LinkageName, F, LineNo, Ty, isLocalToUnit, isDefinition, LineNo,
673       VTableHolder, VK, VIndex, ThisAdjustment, Flags, isOptimized,
674       isDefinition ? CUNode : nullptr, TParams, nullptr, nullptr);
675 
676   if (isDefinition)
677     AllSubprograms.push_back(SP);
678   trackIfUnresolved(SP);
679   return SP;
680 }
681 
createNameSpace(DIScope * Scope,StringRef Name,DIFile * File,unsigned LineNo)682 DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name,
683                                         DIFile *File, unsigned LineNo) {
684   return DINamespace::get(VMContext, getNonCompileUnitScope(Scope), File, Name,
685                           LineNo);
686 }
687 
createModule(DIScope * Scope,StringRef Name,StringRef ConfigurationMacros,StringRef IncludePath,StringRef ISysRoot)688 DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name,
689                                   StringRef ConfigurationMacros,
690                                   StringRef IncludePath,
691                                   StringRef ISysRoot) {
692  return DIModule::get(VMContext, getNonCompileUnitScope(Scope), Name,
693                       ConfigurationMacros, IncludePath, ISysRoot);
694 }
695 
createLexicalBlockFile(DIScope * Scope,DIFile * File,unsigned Discriminator)696 DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope,
697                                                       DIFile *File,
698                                                       unsigned Discriminator) {
699   return DILexicalBlockFile::get(VMContext, Scope, File, Discriminator);
700 }
701 
createLexicalBlock(DIScope * Scope,DIFile * File,unsigned Line,unsigned Col)702 DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope, DIFile *File,
703                                               unsigned Line, unsigned Col) {
704   // Make these distinct, to avoid merging two lexical blocks on the same
705   // file/line/column.
706   return DILexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
707                                      File, Line, Col);
708 }
709 
getDbgIntrinsicValueImpl(LLVMContext & VMContext,Value * V)710 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
711   assert(V && "no value passed to dbg intrinsic");
712   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
713 }
714 
withDebugLoc(Instruction * I,const DILocation * DL)715 static Instruction *withDebugLoc(Instruction *I, const DILocation *DL) {
716   I->setDebugLoc(const_cast<DILocation *>(DL));
717   return I;
718 }
719 
insertDeclare(Value * Storage,DILocalVariable * VarInfo,DIExpression * Expr,const DILocation * DL,Instruction * InsertBefore)720 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
721                                       DIExpression *Expr, const DILocation *DL,
722                                       Instruction *InsertBefore) {
723   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.declare");
724   assert(DL && "Expected debug loc");
725   assert(DL->getScope()->getSubprogram() ==
726              VarInfo->getScope()->getSubprogram() &&
727          "Expected matching subprograms");
728   if (!DeclareFn)
729     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
730 
731   trackIfUnresolved(VarInfo);
732   trackIfUnresolved(Expr);
733   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
734                    MetadataAsValue::get(VMContext, VarInfo),
735                    MetadataAsValue::get(VMContext, Expr)};
736   return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertBefore), DL);
737 }
738 
insertDeclare(Value * Storage,DILocalVariable * VarInfo,DIExpression * Expr,const DILocation * DL,BasicBlock * InsertAtEnd)739 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
740                                       DIExpression *Expr, const DILocation *DL,
741                                       BasicBlock *InsertAtEnd) {
742   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.declare");
743   assert(DL && "Expected debug loc");
744   assert(DL->getScope()->getSubprogram() ==
745              VarInfo->getScope()->getSubprogram() &&
746          "Expected matching subprograms");
747   if (!DeclareFn)
748     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
749 
750   trackIfUnresolved(VarInfo);
751   trackIfUnresolved(Expr);
752   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
753                    MetadataAsValue::get(VMContext, VarInfo),
754                    MetadataAsValue::get(VMContext, Expr)};
755 
756   // If this block already has a terminator then insert this intrinsic
757   // before the terminator.
758   if (TerminatorInst *T = InsertAtEnd->getTerminator())
759     return withDebugLoc(CallInst::Create(DeclareFn, Args, "", T), DL);
760   return withDebugLoc(CallInst::Create(DeclareFn, Args, "", InsertAtEnd), DL);
761 }
762 
insertDbgValueIntrinsic(Value * V,uint64_t Offset,DILocalVariable * VarInfo,DIExpression * Expr,const DILocation * DL,Instruction * InsertBefore)763 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
764                                                 DILocalVariable *VarInfo,
765                                                 DIExpression *Expr,
766                                                 const DILocation *DL,
767                                                 Instruction *InsertBefore) {
768   assert(V && "no value passed to dbg.value");
769   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.value");
770   assert(DL && "Expected debug loc");
771   assert(DL->getScope()->getSubprogram() ==
772              VarInfo->getScope()->getSubprogram() &&
773          "Expected matching subprograms");
774   if (!ValueFn)
775     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
776 
777   trackIfUnresolved(VarInfo);
778   trackIfUnresolved(Expr);
779   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
780                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
781                    MetadataAsValue::get(VMContext, VarInfo),
782                    MetadataAsValue::get(VMContext, Expr)};
783   return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertBefore), DL);
784 }
785 
insertDbgValueIntrinsic(Value * V,uint64_t Offset,DILocalVariable * VarInfo,DIExpression * Expr,const DILocation * DL,BasicBlock * InsertAtEnd)786 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
787                                                 DILocalVariable *VarInfo,
788                                                 DIExpression *Expr,
789                                                 const DILocation *DL,
790                                                 BasicBlock *InsertAtEnd) {
791   assert(V && "no value passed to dbg.value");
792   assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.value");
793   assert(DL && "Expected debug loc");
794   assert(DL->getScope()->getSubprogram() ==
795              VarInfo->getScope()->getSubprogram() &&
796          "Expected matching subprograms");
797   if (!ValueFn)
798     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
799 
800   trackIfUnresolved(VarInfo);
801   trackIfUnresolved(Expr);
802   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
803                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
804                    MetadataAsValue::get(VMContext, VarInfo),
805                    MetadataAsValue::get(VMContext, Expr)};
806 
807   return withDebugLoc(CallInst::Create(ValueFn, Args, "", InsertAtEnd), DL);
808 }
809 
replaceVTableHolder(DICompositeType * & T,DICompositeType * VTableHolder)810 void DIBuilder::replaceVTableHolder(DICompositeType *&T,
811                                     DICompositeType *VTableHolder) {
812   {
813     TypedTrackingMDRef<DICompositeType> N(T);
814     N->replaceVTableHolder(VTableHolder);
815     T = N.get();
816   }
817 
818   // If this didn't create a self-reference, just return.
819   if (T != VTableHolder)
820     return;
821 
822   // Look for unresolved operands.  T will drop RAUW support, orphaning any
823   // cycles underneath it.
824   if (T->isResolved())
825     for (const MDOperand &O : T->operands())
826       if (auto *N = dyn_cast_or_null<MDNode>(O))
827         trackIfUnresolved(N);
828 }
829 
replaceArrays(DICompositeType * & T,DINodeArray Elements,DINodeArray TParams)830 void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements,
831                               DINodeArray TParams) {
832   {
833     TypedTrackingMDRef<DICompositeType> N(T);
834     if (Elements)
835       N->replaceElements(Elements);
836     if (TParams)
837       N->replaceTemplateParams(DITemplateParameterArray(TParams));
838     T = N.get();
839   }
840 
841   // If T isn't resolved, there's no problem.
842   if (!T->isResolved())
843     return;
844 
845   // If T is resolved, it may be due to a self-reference cycle.  Track the
846   // arrays explicitly if they're unresolved, or else the cycles will be
847   // orphaned.
848   if (Elements)
849     trackIfUnresolved(Elements.get());
850   if (TParams)
851     trackIfUnresolved(TParams.get());
852 }
853