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