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