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