Movatterモバイル変換

[0]ホーム
URL:

LLVM 20.0.0git
DIBuilder.cpp
Go to the documentation of this file.
1//===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the DIBuilder.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/IR/DIBuilder.h"
14#include "LLVMContextImpl.h"
15#include "llvm/ADT/APInt.h"
16#include "llvm/ADT/APSInt.h"
17#include "llvm/BinaryFormat/Dwarf.h"
18#include "llvm/IR/Constants.h"
19#include "llvm/IR/DebugInfo.h"
20#include "llvm/IR/IRBuilder.h"
21#include "llvm/IR/Module.h"
22#include <optional>
23
24using namespacellvm;
25using namespacellvm::dwarf;
26
27DIBuilder::DIBuilder(Module &m,bool AllowUnresolvedNodes,DICompileUnit *CU)
28 : M(m), VMContext(M.getContext()), CUNode(CU), DeclareFn(nullptr),
29 ValueFn(nullptr), LabelFn(nullptr), AssignFn(nullptr),
30 AllowUnresolvedNodes(AllowUnresolvedNodes) {
31if (CUNode) {
32if (constauto &ETs = CUNode->getEnumTypes())
33 AllEnumTypes.assign(ETs.begin(), ETs.end());
34if (constauto &RTs = CUNode->getRetainedTypes())
35 AllRetainTypes.assign(RTs.begin(), RTs.end());
36if (constauto &GVs = CUNode->getGlobalVariables())
37 AllGVs.assign(GVs.begin(), GVs.end());
38if (constauto &IMs = CUNode->getImportedEntities())
39 ImportedModules.assign(IMs.begin(), IMs.end());
40if (constauto &MNs = CUNode->getMacros())
41 AllMacrosPerParent.insert({nullptr, {MNs.begin(), MNs.end()}});
42 }
43}
44
45void DIBuilder::trackIfUnresolved(MDNode *N) {
46if (!N)
47return;
48if (N->isResolved())
49return;
50
51assert(AllowUnresolvedNodes &&"Cannot handle unresolved nodes");
52 UnresolvedNodes.emplace_back(N);
53}
54
55voidDIBuilder::finalizeSubprogram(DISubprogram *SP) {
56auto PN = SubprogramTrackedNodes.find(SP);
57if (PN != SubprogramTrackedNodes.end())
58 SP->replaceRetainedNodes(
59MDTuple::get(VMContext,SmallVector<Metadata *, 16>(PN->second.begin(),
60 PN->second.end())));
61}
62
63voidDIBuilder::finalize() {
64if (!CUNode) {
65assert(!AllowUnresolvedNodes &&
66"creating type nodes without a CU is not supported");
67return;
68 }
69
70if (!AllEnumTypes.empty())
71 CUNode->replaceEnumTypes(MDTuple::get(
72 VMContext,SmallVector<Metadata *, 16>(AllEnumTypes.begin(),
73 AllEnumTypes.end())));
74
75SmallVector<Metadata *, 16> RetainValues;
76// Declarations and definitions of the same type may be retained. Some
77// clients RAUW these pairs, leaving duplicates in the retained types
78// list. Use a set to remove the duplicates while we transform the
79// TrackingVHs back into Values.
80SmallPtrSet<Metadata *, 16> RetainSet;
81for (constTrackingMDNodeRef &N : AllRetainTypes)
82if (RetainSet.insert(N).second)
83 RetainValues.push_back(N);
84
85if (!RetainValues.empty())
86 CUNode->replaceRetainedTypes(MDTuple::get(VMContext, RetainValues));
87
88for (auto *SP : AllSubprograms)
89finalizeSubprogram(SP);
90for (auto *N : RetainValues)
91if (auto *SP = dyn_cast<DISubprogram>(N))
92finalizeSubprogram(SP);
93
94if (!AllGVs.empty())
95 CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));
96
97if (!ImportedModules.empty())
98 CUNode->replaceImportedEntities(MDTuple::get(
99 VMContext,SmallVector<Metadata *, 16>(ImportedModules.begin(),
100 ImportedModules.end())));
101
102for (constauto &I : AllMacrosPerParent) {
103// DIMacroNode's with nullptr parent are DICompileUnit direct children.
104if (!I.first) {
105 CUNode->replaceMacros(MDTuple::get(VMContext,I.second.getArrayRef()));
106continue;
107 }
108// Otherwise, it must be a temporary DIMacroFile that need to be resolved.
109auto *TMF = cast<DIMacroFile>(I.first);
110auto *MF =DIMacroFile::get(VMContext,dwarf::DW_MACINFO_start_file,
111 TMF->getLine(), TMF->getFile(),
112getOrCreateMacroArray(I.second.getArrayRef()));
113replaceTemporary(llvm::TempDIMacroNode(TMF), MF);
114 }
115
116// Now that all temp nodes have been replaced or deleted, resolve remaining
117// cycles.
118for (constauto &N : UnresolvedNodes)
119if (N && !N->isResolved())
120N->resolveCycles();
121 UnresolvedNodes.clear();
122
123// Can't handle unresolved nodes anymore.
124 AllowUnresolvedNodes =false;
125}
126
127/// If N is compile unit return NULL otherwise return N.
128staticDIScope *getNonCompileUnitScope(DIScope *N) {
129if (!N || isa<DICompileUnit>(N))
130returnnullptr;
131return cast<DIScope>(N);
132}
133
134DICompileUnit *DIBuilder::createCompileUnit(
135unsigned Lang,DIFile *File,StringRef Producer,bool isOptimized,
136StringRef Flags,unsigned RunTimeVer,StringRef SplitName,
137DICompileUnit::DebugEmissionKind Kind,uint64_t DWOId,
138bool SplitDebugInlining,bool DebugInfoForProfiling,
139DICompileUnit::DebugNameTableKind NameTableKind,bool RangesBaseAddress,
140StringRef SysRoot,StringRef SDK) {
141
142assert(((Lang <= dwarf::DW_LANG_Metal && Lang >= dwarf::DW_LANG_C89) ||
143 (Lang <= dwarf::DW_LANG_hi_user && Lang >=dwarf::DW_LANG_lo_user)) &&
144"Invalid Language tag");
145
146assert(!CUNode &&"Can only make one compile unit per DIBuilder instance");
147 CUNode =DICompileUnit::getDistinct(
148 VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
149 SplitName, Kind,nullptr,nullptr,nullptr,nullptr,nullptr, DWOId,
150 SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
151 RangesBaseAddress, SysRoot, SDK);
152
153// Create a named metadata so that it is easier to find cu in a module.
154NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
155 NMD->addOperand(CUNode);
156 trackIfUnresolved(CUNode);
157return CUNode;
158}
159
160staticDIImportedEntity *
161createImportedModule(LLVMContext &C,dwarf::TagTag,DIScope *Context,
162Metadata *NS,DIFile *File,unsigned Line,StringRefName,
163 DINodeArray Elements,
164SmallVectorImpl<TrackingMDNodeRef> &ImportedModules) {
165if (Line)
166assert(File &&"Source location has line number but no file");
167unsigned EntitiesCount =C.pImpl->DIImportedEntitys.size();
168auto *M =DIImportedEntity::get(C,Tag, Context, cast_or_null<DINode>(NS),
169 File, Line,Name, Elements);
170if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
171// A new Imported Entity was just added to the context.
172// Add it to the Imported Modules list.
173 ImportedModules.emplace_back(M);
174return M;
175}
176
177DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
178DINamespace *NS,DIFile *File,
179unsigned Line,
180 DINodeArray Elements) {
181 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
182 Context, NS, File, Line,StringRef(), Elements,
183 getImportTrackingVector(Context));
184}
185
186DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
187DIImportedEntity *NS,
188DIFile *File,unsigned Line,
189 DINodeArray Elements) {
190 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
191 Context, NS, File, Line,StringRef(), Elements,
192 getImportTrackingVector(Context));
193}
194
195DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,DIModule *M,
196DIFile *File,unsigned Line,
197 DINodeArray Elements) {
198 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
199 Context, M, File, Line,StringRef(), Elements,
200 getImportTrackingVector(Context));
201}
202
203DIImportedEntity *
204DIBuilder::createImportedDeclaration(DIScope *Context,DINode *Decl,
205DIFile *File,unsigned Line,
206StringRefName, DINodeArray Elements) {
207// Make sure to use the unique identifier based metadata reference for
208// types that have one.
209 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
210 Context, Decl, File, Line,Name, Elements,
211 getImportTrackingVector(Context));
212}
213
214DIFile *DIBuilder::createFile(StringRef Filename,StringRef Directory,
215 std::optional<DIFile::ChecksumInfo<StringRef>> CS,
216 std::optional<StringRef> Source) {
217returnDIFile::get(VMContext, Filename, Directory, CS, Source);
218}
219
220DIMacro *DIBuilder::createMacro(DIMacroFile *Parent,unsigned LineNumber,
221unsigned MacroType,StringRefName,
222StringRefValue) {
223assert(!Name.empty() &&"Unable to create macro without name");
224assert((MacroType ==dwarf::DW_MACINFO_undef ||
225 MacroType ==dwarf::DW_MACINFO_define) &&
226"Unexpected macro type");
227auto *M =DIMacro::get(VMContext, MacroType, LineNumber,Name,Value);
228 AllMacrosPerParent[Parent].insert(M);
229return M;
230}
231
232DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent,
233unsigned LineNumber,DIFile *File) {
234auto *MF =DIMacroFile::getTemporary(VMContext,dwarf::DW_MACINFO_start_file,
235 LineNumber, File, DIMacroNodeArray())
236 .release();
237 AllMacrosPerParent[Parent].insert(MF);
238// Add the new temporary DIMacroFile to the macro per parent map as a parent.
239// This is needed to assure DIMacroFile with no children to have an entry in
240// the map. Otherwise, it will not be resolved in DIBuilder::finalize().
241 AllMacrosPerParent.insert({MF, {}});
242return MF;
243}
244
245DIEnumerator *DIBuilder::createEnumerator(StringRefName,uint64_t Val,
246bool IsUnsigned) {
247assert(!Name.empty() &&"Unable to create enumerator without name");
248returnDIEnumerator::get(VMContext,APInt(64, Val, !IsUnsigned), IsUnsigned,
249Name);
250}
251
252DIEnumerator *DIBuilder::createEnumerator(StringRefName,constAPSInt &Value) {
253assert(!Name.empty() &&"Unable to create enumerator without name");
254returnDIEnumerator::get(VMContext,APInt(Value),Value.isUnsigned(),Name);
255}
256
257DIBasicType *DIBuilder::createUnspecifiedType(StringRefName) {
258assert(!Name.empty() &&"Unable to create type without name");
259returnDIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type,Name);
260}
261
262DIBasicType *DIBuilder::createNullPtrType() {
263returncreateUnspecifiedType("decltype(nullptr)");
264}
265
266DIBasicType *DIBuilder::createBasicType(StringRefName,uint64_t SizeInBits,
267unsigned Encoding,
268DINode::DIFlags Flags,
269uint32_t NumExtraInhabitants) {
270assert(!Name.empty() &&"Unable to create type without name");
271returnDIBasicType::get(VMContext, dwarf::DW_TAG_base_type,Name, SizeInBits,
272 0, Encoding, NumExtraInhabitants, Flags);
273}
274
275DIStringType *DIBuilder::createStringType(StringRefName,uint64_t SizeInBits) {
276assert(!Name.empty() &&"Unable to create type without name");
277returnDIStringType::get(VMContext, dwarf::DW_TAG_string_type,Name,
278 SizeInBits, 0);
279}
280
281DIStringType *DIBuilder::createStringType(StringRefName,
282DIVariable *StringLength,
283DIExpression *StrLocationExp) {
284assert(!Name.empty() &&"Unable to create type without name");
285returnDIStringType::get(VMContext, dwarf::DW_TAG_string_type,Name,
286 StringLength,nullptr, StrLocationExp, 0, 0, 0);
287}
288
289DIStringType *DIBuilder::createStringType(StringRefName,
290DIExpression *StringLengthExp,
291DIExpression *StrLocationExp) {
292assert(!Name.empty() &&"Unable to create type without name");
293returnDIStringType::get(VMContext, dwarf::DW_TAG_string_type,Name,nullptr,
294 StringLengthExp, StrLocationExp, 0, 0, 0);
295}
296
297DIDerivedType *DIBuilder::createQualifiedType(unsignedTag,DIType *FromTy) {
298returnDIDerivedType::get(VMContext,Tag,"",nullptr, 0,nullptr, FromTy, 0,
299 0, 0, std::nullopt, std::nullopt, DINode::FlagZero);
300}
301
302DIDerivedType *DIBuilder::createPtrAuthQualifiedType(
303DIType *FromTy,unsigned Key,bool IsAddressDiscriminated,
304unsigned ExtraDiscriminator,bool IsaPointer,
305bool AuthenticatesNullValues) {
306returnDIDerivedType::get(VMContext, dwarf::DW_TAG_LLVM_ptrauth_type,"",
307nullptr, 0,nullptr, FromTy, 0, 0, 0, std::nullopt,
308 std::optional<DIDerivedType::PtrAuthData>(
309 std::in_place, Key, IsAddressDiscriminated,
310 ExtraDiscriminator, IsaPointer,
311 AuthenticatesNullValues),
312 DINode::FlagZero);
313}
314
315DIDerivedType *
316DIBuilder::createPointerType(DIType *PointeeTy,uint64_t SizeInBits,
317uint32_t AlignInBits,
318 std::optional<unsigned> DWARFAddressSpace,
319StringRefName, DINodeArrayAnnotations) {
320// FIXME: Why is there a name here?
321returnDIDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type,Name,
322nullptr, 0,nullptr, PointeeTy, SizeInBits,
323 AlignInBits, 0, DWARFAddressSpace, std::nullopt,
324 DINode::FlagZero,nullptr,Annotations);
325}
326
327DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
328DIType *Base,
329uint64_t SizeInBits,
330uint32_t AlignInBits,
331DINode::DIFlags Flags) {
332returnDIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type,"",
333nullptr, 0,nullptr, PointeeTy, SizeInBits,
334 AlignInBits, 0, std::nullopt, std::nullopt, Flags,
335Base);
336}
337
338DIDerivedType *
339DIBuilder::createReferenceType(unsignedTag,DIType *RTy,uint64_t SizeInBits,
340uint32_t AlignInBits,
341 std::optional<unsigned> DWARFAddressSpace) {
342assert(RTy &&"Unable to create reference type");
343returnDIDerivedType::get(VMContext,Tag,"",nullptr, 0,nullptr, RTy,
344 SizeInBits, AlignInBits, 0, DWARFAddressSpace, {},
345 DINode::FlagZero);
346}
347
348DIDerivedType *DIBuilder::createTypedef(DIType *Ty,StringRefName,
349DIFile *File,unsigned LineNo,
350DIScope *Context,uint32_t AlignInBits,
351DINode::DIFlags Flags,
352 DINodeArrayAnnotations) {
353returnDIDerivedType::get(VMContext, dwarf::DW_TAG_typedef,Name, File,
354 LineNo,getNonCompileUnitScope(Context), Ty, 0,
355 AlignInBits, 0, std::nullopt, std::nullopt, Flags,
356nullptr,Annotations);
357}
358
359DIDerivedType *
360DIBuilder::createTemplateAlias(DIType *Ty,StringRefName,DIFile *File,
361unsigned LineNo,DIScope *Context,
362 DINodeArray TParams,uint32_t AlignInBits,
363DINode::DIFlags Flags, DINodeArrayAnnotations) {
364returnDIDerivedType::get(VMContext, dwarf::DW_TAG_template_alias,Name, File,
365 LineNo,getNonCompileUnitScope(Context), Ty, 0,
366 AlignInBits, 0, std::nullopt, std::nullopt, Flags,
367 TParams.get(),Annotations);
368}
369
370DIDerivedType *DIBuilder::createFriend(DIType *Ty,DIType *FriendTy) {
371assert(Ty &&"Invalid type!");
372assert(FriendTy &&"Invalid friend type!");
373returnDIDerivedType::get(VMContext, dwarf::DW_TAG_friend,"",nullptr, 0, Ty,
374 FriendTy, 0, 0, 0, std::nullopt, std::nullopt,
375 DINode::FlagZero);
376}
377
378DIDerivedType *DIBuilder::createInheritance(DIType *Ty,DIType *BaseTy,
379uint64_t BaseOffset,
380uint32_t VBPtrOffset,
381DINode::DIFlags Flags) {
382assert(Ty &&"Unable to create inheritance");
383Metadata *ExtraData =ConstantAsMetadata::get(
384 ConstantInt::get(IntegerType::get(VMContext, 32), VBPtrOffset));
385returnDIDerivedType::get(VMContext, dwarf::DW_TAG_inheritance,"",nullptr,
386 0, Ty,BaseTy, 0, 0, BaseOffset, std::nullopt,
387 std::nullopt, Flags, ExtraData);
388}
389
390DIDerivedType *DIBuilder::createMemberType(
391DIScope *Scope,StringRefName,DIFile *File,unsigned LineNumber,
392uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,
393DINode::DIFlags Flags,DIType *Ty, DINodeArrayAnnotations) {
394returnDIDerivedType::get(VMContext, dwarf::DW_TAG_member,Name, File,
395 LineNumber,getNonCompileUnitScope(Scope), Ty,
396 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
397 std::nullopt, Flags,nullptr,Annotations);
398}
399
400staticConstantAsMetadata *getConstantOrNull(Constant *C) {
401if (C)
402returnConstantAsMetadata::get(C);
403returnnullptr;
404}
405
406DIDerivedType *DIBuilder::createVariantMemberType(
407DIScope *Scope,StringRefName,DIFile *File,unsigned LineNumber,
408uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,
409Constant *Discriminant,DINode::DIFlags Flags,DIType *Ty) {
410returnDIDerivedType::get(
411 VMContext, dwarf::DW_TAG_member,Name, File, LineNumber,
412getNonCompileUnitScope(Scope), Ty, SizeInBits, AlignInBits, OffsetInBits,
413 std::nullopt, std::nullopt, Flags,getConstantOrNull(Discriminant));
414}
415
416DIDerivedType *DIBuilder::createBitFieldMemberType(
417DIScope *Scope,StringRefName,DIFile *File,unsigned LineNumber,
418uint64_t SizeInBits,uint64_t OffsetInBits,uint64_t StorageOffsetInBits,
419DINode::DIFlags Flags,DIType *Ty, DINodeArrayAnnotations) {
420 Flags |= DINode::FlagBitField;
421returnDIDerivedType::get(
422 VMContext, dwarf::DW_TAG_member,Name, File, LineNumber,
423getNonCompileUnitScope(Scope), Ty, SizeInBits,/*AlignInBits=*/0,
424 OffsetInBits, std::nullopt, std::nullopt, Flags,
425ConstantAsMetadata::get(ConstantInt::get(IntegerType::get(VMContext, 64),
426 StorageOffsetInBits)),
427Annotations);
428}
429
430DIDerivedType *
431DIBuilder::createStaticMemberType(DIScope *Scope,StringRefName,DIFile *File,
432unsigned LineNumber,DIType *Ty,
433DINode::DIFlags Flags,llvm::Constant *Val,
434unsignedTag,uint32_t AlignInBits) {
435 Flags |= DINode::FlagStaticMember;
436returnDIDerivedType::get(VMContext,Tag,Name, File, LineNumber,
437getNonCompileUnitScope(Scope), Ty, 0, AlignInBits,
438 0, std::nullopt, std::nullopt, Flags,
439getConstantOrNull(Val));
440}
441
442DIDerivedType *
443DIBuilder::createObjCIVar(StringRefName,DIFile *File,unsigned LineNumber,
444uint64_t SizeInBits,uint32_t AlignInBits,
445uint64_t OffsetInBits,DINode::DIFlags Flags,
446DIType *Ty,MDNode *PropertyNode) {
447returnDIDerivedType::get(VMContext, dwarf::DW_TAG_member,Name, File,
448 LineNumber,getNonCompileUnitScope(File), Ty,
449 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
450 std::nullopt, Flags, PropertyNode);
451}
452
453DIObjCProperty *
454DIBuilder::createObjCProperty(StringRefName,DIFile *File,unsigned LineNumber,
455StringRef GetterName,StringRef SetterName,
456unsigned PropertyAttributes,DIType *Ty) {
457returnDIObjCProperty::get(VMContext,Name, File, LineNumber, GetterName,
458 SetterName, PropertyAttributes, Ty);
459}
460
461DITemplateTypeParameter *
462DIBuilder::createTemplateTypeParameter(DIScope *Context,StringRefName,
463DIType *Ty,bool isDefault) {
464assert((!Context || isa<DICompileUnit>(Context)) &&"Expected compile unit");
465returnDITemplateTypeParameter::get(VMContext,Name, Ty, isDefault);
466}
467
468staticDITemplateValueParameter *
469createTemplateValueParameterHelper(LLVMContext &VMContext,unsignedTag,
470DIScope *Context,StringRefName,DIType *Ty,
471bool IsDefault,Metadata *MD) {
472assert((!Context || isa<DICompileUnit>(Context)) &&"Expected compile unit");
473returnDITemplateValueParameter::get(VMContext,Tag,Name, Ty, IsDefault, MD);
474}
475
476DITemplateValueParameter *
477DIBuilder::createTemplateValueParameter(DIScope *Context,StringRefName,
478DIType *Ty,bool isDefault,
479Constant *Val) {
480returncreateTemplateValueParameterHelper(
481 VMContext, dwarf::DW_TAG_template_value_parameter, Context,Name, Ty,
482 isDefault,getConstantOrNull(Val));
483}
484
485DITemplateValueParameter *
486DIBuilder::createTemplateTemplateParameter(DIScope *Context,StringRefName,
487DIType *Ty,StringRef Val,
488bool IsDefault) {
489returncreateTemplateValueParameterHelper(
490 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context,Name, Ty,
491 IsDefault,MDString::get(VMContext, Val));
492}
493
494DITemplateValueParameter *
495DIBuilder::createTemplateParameterPack(DIScope *Context,StringRefName,
496DIType *Ty, DINodeArray Val) {
497returncreateTemplateValueParameterHelper(
498 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context,Name, Ty,
499false, Val.get());
500}
501
502DICompositeType *DIBuilder::createClassType(
503DIScope *Context,StringRefName,DIFile *File,unsigned LineNumber,
504uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,
505DINode::DIFlags Flags,DIType *DerivedFrom, DINodeArray Elements,
506unsigned RunTimeLang,DIType *VTableHolder,MDNode *TemplateParams,
507StringRef UniqueIdentifier) {
508assert((!Context || isa<DIScope>(Context)) &&
509"createClassType should be called with a valid Context");
510
511auto *R =DICompositeType::get(
512 VMContext, dwarf::DW_TAG_class_type,Name, File, LineNumber,
513getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits,
514 OffsetInBits, Flags, Elements, RunTimeLang, VTableHolder,
515 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
516 trackIfUnresolved(R);
517return R;
518}
519
520DICompositeType *DIBuilder::createStructType(
521DIScope *Context,StringRefName,DIFile *File,unsigned LineNumber,
522uint64_t SizeInBits,uint32_t AlignInBits,DINode::DIFlags Flags,
523DIType *DerivedFrom, DINodeArray Elements,unsigned RunTimeLang,
524DIType *VTableHolder,StringRef UniqueIdentifier,DIType *Specification,
525uint32_t NumExtraInhabitants) {
526auto *R =DICompositeType::get(
527 VMContext, dwarf::DW_TAG_structure_type,Name, File, LineNumber,
528getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits, 0,
529 Flags, Elements, RunTimeLang, VTableHolder,nullptr, UniqueIdentifier,
530nullptr,nullptr,nullptr,nullptr,nullptr,nullptr, Specification,
531 NumExtraInhabitants);
532 trackIfUnresolved(R);
533return R;
534}
535
536DICompositeType *DIBuilder::createUnionType(
537DIScope *Scope,StringRefName,DIFile *File,unsigned LineNumber,
538uint64_t SizeInBits,uint32_t AlignInBits,DINode::DIFlags Flags,
539 DINodeArray Elements,unsigned RunTimeLang,StringRef UniqueIdentifier) {
540auto *R =DICompositeType::get(
541 VMContext, dwarf::DW_TAG_union_type,Name, File, LineNumber,
542getNonCompileUnitScope(Scope),nullptr, SizeInBits, AlignInBits, 0, Flags,
543 Elements, RunTimeLang,nullptr,nullptr, UniqueIdentifier);
544 trackIfUnresolved(R);
545return R;
546}
547
548DICompositeType *
549DIBuilder::createVariantPart(DIScope *Scope,StringRefName,DIFile *File,
550unsigned LineNumber,uint64_t SizeInBits,
551uint32_t AlignInBits,DINode::DIFlags Flags,
552DIDerivedType *Discriminator, DINodeArray Elements,
553StringRef UniqueIdentifier) {
554auto *R =DICompositeType::get(
555 VMContext, dwarf::DW_TAG_variant_part,Name, File, LineNumber,
556getNonCompileUnitScope(Scope),nullptr, SizeInBits, AlignInBits, 0, Flags,
557 Elements, 0,nullptr,nullptr, UniqueIdentifier, Discriminator);
558 trackIfUnresolved(R);
559return R;
560}
561
562DISubroutineType *DIBuilder::createSubroutineType(DITypeRefArray ParameterTypes,
563DINode::DIFlags Flags,
564unsignedCC) {
565returnDISubroutineType::get(VMContext, Flags,CC, ParameterTypes);
566}
567
568DICompositeType *
569DIBuilder::createEnumerationType(DIScope *Scope,StringRefName,DIFile *File,
570unsigned LineNumber,uint64_t SizeInBits,
571uint32_t AlignInBits, DINodeArray Elements,
572DIType *UnderlyingType,unsigned RunTimeLang,
573StringRef UniqueIdentifier,bool IsScoped) {
574auto *CTy =DICompositeType::get(
575 VMContext, dwarf::DW_TAG_enumeration_type,Name, File, LineNumber,
576getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0,
577 IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements,
578 RunTimeLang,nullptr,nullptr, UniqueIdentifier);
579 AllEnumTypes.emplace_back(CTy);
580 trackIfUnresolved(CTy);
581return CTy;
582}
583
584DIDerivedType *DIBuilder::createSetType(DIScope *Scope,StringRefName,
585DIFile *File,unsigned LineNo,
586uint64_t SizeInBits,
587uint32_t AlignInBits,DIType *Ty) {
588auto *R =DIDerivedType::get(VMContext, dwarf::DW_TAG_set_type,Name, File,
589 LineNo,getNonCompileUnitScope(Scope), Ty,
590 SizeInBits, AlignInBits, 0, std::nullopt,
591 std::nullopt, DINode::FlagZero);
592 trackIfUnresolved(R);
593return R;
594}
595
596DICompositeType *
597DIBuilder::createArrayType(uint64_tSize,uint32_t AlignInBits,DIType *Ty,
598 DINodeArray Subscripts,
599PointerUnion<DIExpression *, DIVariable *>DL,
600PointerUnion<DIExpression *, DIVariable *> AS,
601PointerUnion<DIExpression *, DIVariable *> AL,
602PointerUnion<DIExpression *, DIVariable *> RK) {
603auto *R =DICompositeType::get(
604 VMContext, dwarf::DW_TAG_array_type,"",nullptr, 0,nullptr, Ty,Size,
605 AlignInBits, 0, DINode::FlagZero, Subscripts, 0,nullptr,nullptr,"",
606nullptr,
607 isa<DIExpression *>(DL) ? (Metadata *)cast<DIExpression *>(DL)
608 : (Metadata *)cast<DIVariable *>(DL),
609 isa<DIExpression *>(AS) ? (Metadata *)cast<DIExpression *>(AS)
610 : (Metadata *)cast<DIVariable *>(AS),
611 isa<DIExpression *>(AL) ? (Metadata *)cast<DIExpression *>(AL)
612 : (Metadata *)cast<DIVariable *>(AL),
613 isa<DIExpression *>(RK) ? (Metadata *)cast<DIExpression *>(RK)
614 : (Metadata *)cast<DIVariable *>(RK));
615 trackIfUnresolved(R);
616return R;
617}
618
619DICompositeType *DIBuilder::createVectorType(uint64_tSize,
620uint32_t AlignInBits,DIType *Ty,
621 DINodeArray Subscripts) {
622auto *R =DICompositeType::get(VMContext, dwarf::DW_TAG_array_type,"",
623nullptr, 0,nullptr, Ty,Size, AlignInBits, 0,
624 DINode::FlagVector, Subscripts, 0,nullptr);
625 trackIfUnresolved(R);
626return R;
627}
628
629DISubprogram *DIBuilder::createArtificialSubprogram(DISubprogram *SP) {
630auto NewSP = SP->cloneWithFlags(SP->getFlags() | DINode::FlagArtificial);
631returnMDNode::replaceWithDistinct(std::move(NewSP));
632}
633
634staticDIType *createTypeWithFlags(constDIType *Ty,
635DINode::DIFlags FlagsToSet) {
636auto NewTy = Ty->cloneWithFlags(Ty->getFlags() | FlagsToSet);
637returnMDNode::replaceWithUniqued(std::move(NewTy));
638}
639
640DIType *DIBuilder::createArtificialType(DIType *Ty) {
641// FIXME: Restrict this to the nodes where it's valid.
642if (Ty->isArtificial())
643return Ty;
644returncreateTypeWithFlags(Ty, DINode::FlagArtificial);
645}
646
647DIType *DIBuilder::createObjectPointerType(DIType *Ty,bool Implicit) {
648// FIXME: Restrict this to the nodes where it's valid.
649if (Ty->isObjectPointer())
650return Ty;
651DINode::DIFlags Flags = DINode::FlagObjectPointer;
652
653if (Implicit)
654 Flags |= DINode::FlagArtificial;
655
656returncreateTypeWithFlags(Ty, Flags);
657}
658
659voidDIBuilder::retainType(DIScope *T) {
660assert(T &&"Expected non-null type");
661assert((isa<DIType>(T) || (isa<DISubprogram>(T) &&
662 cast<DISubprogram>(T)->isDefinition() ==false)) &&
663"Expected type or subprogram declaration");
664 AllRetainTypes.emplace_back(T);
665}
666
667DIBasicType *DIBuilder::createUnspecifiedParameter() {returnnullptr; }
668
669DICompositeType *
670DIBuilder::createForwardDecl(unsignedTag,StringRefName,DIScope *Scope,
671DIFile *F,unsigned Line,unsigned RuntimeLang,
672uint64_t SizeInBits,uint32_t AlignInBits,
673StringRef UniqueIdentifier) {
674// FIXME: Define in terms of createReplaceableForwardDecl() by calling
675// replaceWithUniqued().
676auto *RetTy =DICompositeType::get(
677 VMContext,Tag,Name,F, Line,getNonCompileUnitScope(Scope),nullptr,
678 SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl,nullptr, RuntimeLang,
679nullptr,nullptr, UniqueIdentifier);
680 trackIfUnresolved(RetTy);
681returnRetTy;
682}
683
684DICompositeType *DIBuilder::createReplaceableCompositeType(
685unsignedTag,StringRefName,DIScope *Scope,DIFile *F,unsigned Line,
686unsigned RuntimeLang,uint64_t SizeInBits,uint32_t AlignInBits,
687DINode::DIFlags Flags,StringRef UniqueIdentifier,
688 DINodeArrayAnnotations) {
689auto *RetTy =
690DICompositeType::getTemporary(
691 VMContext,Tag,Name,F, Line,getNonCompileUnitScope(Scope),nullptr,
692 SizeInBits, AlignInBits, 0, Flags,nullptr, RuntimeLang,nullptr,
693nullptr, UniqueIdentifier,nullptr,nullptr,nullptr,nullptr,
694nullptr,Annotations)
695 .release();
696 trackIfUnresolved(RetTy);
697returnRetTy;
698}
699
700DINodeArrayDIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
701returnMDTuple::get(VMContext, Elements);
702}
703
704DIMacroNodeArray
705DIBuilder::getOrCreateMacroArray(ArrayRef<Metadata *> Elements) {
706returnMDTuple::get(VMContext, Elements);
707}
708
709DITypeRefArrayDIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
710SmallVector<llvm::Metadata *, 16> Elts;
711for (Metadata *E : Elements) {
712if (isa_and_nonnull<MDNode>(E))
713 Elts.push_back(cast<DIType>(E));
714else
715 Elts.push_back(E);
716 }
717returnDITypeRefArray(MDNode::get(VMContext, Elts));
718}
719
720DISubrange *DIBuilder::getOrCreateSubrange(int64_tLo, int64_t Count) {
721auto *LB =ConstantAsMetadata::get(
722ConstantInt::getSigned(Type::getInt64Ty(VMContext),Lo));
723auto *CountNode =ConstantAsMetadata::get(
724ConstantInt::getSigned(Type::getInt64Ty(VMContext), Count));
725returnDISubrange::get(VMContext, CountNode, LB,nullptr,nullptr);
726}
727
728DISubrange *DIBuilder::getOrCreateSubrange(int64_tLo,Metadata *CountNode) {
729auto *LB =ConstantAsMetadata::get(
730ConstantInt::getSigned(Type::getInt64Ty(VMContext),Lo));
731returnDISubrange::get(VMContext, CountNode, LB,nullptr,nullptr);
732}
733
734DISubrange *DIBuilder::getOrCreateSubrange(Metadata *CountNode,Metadata *LB,
735Metadata *UB,Metadata *Stride) {
736returnDISubrange::get(VMContext, CountNode, LB, UB, Stride);
737}
738
739DIGenericSubrange *DIBuilder::getOrCreateGenericSubrange(
740DIGenericSubrange::BoundType CountNode,DIGenericSubrange::BoundType LB,
741DIGenericSubrange::BoundType UB,DIGenericSubrange::BoundType Stride) {
742auto ConvToMetadata = [&](DIGenericSubrange::BoundType Bound) ->Metadata * {
743return isa<DIExpression *>(Bound) ? (Metadata *)cast<DIExpression *>(Bound)
744 : (Metadata *)cast<DIVariable *>(Bound);
745 };
746returnDIGenericSubrange::get(VMContext, ConvToMetadata(CountNode),
747 ConvToMetadata(LB), ConvToMetadata(UB),
748 ConvToMetadata(Stride));
749}
750
751staticvoidcheckGlobalVariableScope(DIScope *Context) {
752#ifndef NDEBUG
753if (auto *CT =
754 dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context)))
755assert(CT->getIdentifier().empty() &&
756"Context of a global variable should not be a type with identifier");
757#endif
758}
759
760DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
761DIScope *Context,StringRefName,StringRefLinkageName,DIFile *F,
762unsigned LineNumber,DIType *Ty,bool IsLocalToUnit,bool isDefined,
763DIExpression *Expr,MDNode *Decl,MDTuple *TemplateParams,
764uint32_t AlignInBits, DINodeArrayAnnotations) {
765checkGlobalVariableScope(Context);
766
767auto *GV =DIGlobalVariable::getDistinct(
768 VMContext, cast_or_null<DIScope>(Context),Name,LinkageName,F,
769 LineNumber, Ty, IsLocalToUnit, isDefined,
770 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
771Annotations);
772if (!Expr)
773 Expr =createExpression();
774auto *N =DIGlobalVariableExpression::get(VMContext, GV, Expr);
775 AllGVs.push_back(N);
776returnN;
777}
778
779DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
780DIScope *Context,StringRefName,StringRefLinkageName,DIFile *F,
781unsigned LineNumber,DIType *Ty,bool IsLocalToUnit,MDNode *Decl,
782MDTuple *TemplateParams,uint32_t AlignInBits) {
783checkGlobalVariableScope(Context);
784
785returnDIGlobalVariable::getTemporary(
786 VMContext, cast_or_null<DIScope>(Context),Name,LinkageName,F,
787 LineNumber, Ty, IsLocalToUnit,false,
788 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
789nullptr)
790 .release();
791}
792
793staticDILocalVariable *createLocalVariable(
794LLVMContext &VMContext,
795SmallVectorImpl<TrackingMDNodeRef> &PreservedNodes,
796DIScope *Context,StringRefName,unsigned ArgNo,DIFile *File,
797unsigned LineNo,DIType *Ty,bool AlwaysPreserve,DINode::DIFlags Flags,
798uint32_t AlignInBits, DINodeArrayAnnotations =nullptr) {
799// FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT
800// the only valid scopes)?
801auto *Scope = cast<DILocalScope>(Context);
802auto *Node =DILocalVariable::get(VMContext, Scope,Name, File, LineNo, Ty,
803 ArgNo, Flags, AlignInBits,Annotations);
804if (AlwaysPreserve) {
805// The optimizer may remove local variables. If there is an interest
806// to preserve variable info in such situation then stash it in a
807// named mdnode.
808 PreservedNodes.emplace_back(Node);
809 }
810returnNode;
811}
812
813DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope,StringRefName,
814DIFile *File,unsigned LineNo,
815DIType *Ty,bool AlwaysPreserve,
816DINode::DIFlags Flags,
817uint32_t AlignInBits) {
818assert(Scope && isa<DILocalScope>(Scope) &&
819"Unexpected scope for a local variable.");
820returncreateLocalVariable(
821 VMContext, getSubprogramNodesTrackingVector(Scope), Scope,Name,
822/* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve, Flags, AlignInBits);
823}
824
825DILocalVariable *DIBuilder::createParameterVariable(
826DIScope *Scope,StringRefName,unsigned ArgNo,DIFile *File,
827unsigned LineNo,DIType *Ty,bool AlwaysPreserve,DINode::DIFlags Flags,
828 DINodeArrayAnnotations) {
829assert(ArgNo &&"Expected non-zero argument number for parameter");
830assert(Scope && isa<DILocalScope>(Scope) &&
831"Unexpected scope for a local variable.");
832returncreateLocalVariable(
833 VMContext, getSubprogramNodesTrackingVector(Scope), Scope,Name, ArgNo,
834 File, LineNo, Ty, AlwaysPreserve, Flags,/*AlignInBits=*/0,Annotations);
835}
836
837DILabel *DIBuilder::createLabel(DIScope *Context,StringRefName,DIFile *File,
838unsigned LineNo,bool AlwaysPreserve) {
839auto *Scope = cast<DILocalScope>(Context);
840auto *Node =DILabel::get(VMContext, Scope,Name, File, LineNo);
841
842if (AlwaysPreserve) {
843 /// The optimizer may remove labels. If there is an interest
844 /// to preserve label info in such situation then append it to
845 /// the list of retained nodes of the DISubprogram.
846 getSubprogramNodesTrackingVector(Scope).emplace_back(Node);
847 }
848return Node;
849}
850
851DIExpression *DIBuilder::createExpression(ArrayRef<uint64_t>Addr) {
852returnDIExpression::get(VMContext,Addr);
853}
854
855template <class... Ts>
856staticDISubprogram *getSubprogram(bool IsDistinct, Ts &&...Args) {
857if (IsDistinct)
858returnDISubprogram::getDistinct(std::forward<Ts>(Args)...);
859returnDISubprogram::get(std::forward<Ts>(Args)...);
860}
861
862DISubprogram *DIBuilder::createFunction(
863DIScope *Context,StringRefName,StringRefLinkageName,DIFile *File,
864unsigned LineNo,DISubroutineType *Ty,unsigned ScopeLine,
865DINode::DIFlags Flags,DISubprogram::DISPFlags SPFlags,
866 DITemplateParameterArray TParams,DISubprogram *Decl,
867 DITypeArray ThrownTypes, DINodeArrayAnnotations,
868StringRef TargetFuncName) {
869bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
870auto *Node =getSubprogram(
871/*IsDistinct=*/IsDefinition, VMContext,getNonCompileUnitScope(Context),
872Name,LinkageName, File, LineNo, Ty, ScopeLine,nullptr, 0, 0, Flags,
873 SPFlags, IsDefinition ? CUNode :nullptr, TParams, Decl,nullptr,
874 ThrownTypes,Annotations, TargetFuncName);
875
876if (IsDefinition)
877 AllSubprograms.push_back(Node);
878 trackIfUnresolved(Node);
879return Node;
880}
881
882DISubprogram *DIBuilder::createTempFunctionFwdDecl(
883DIScope *Context,StringRefName,StringRefLinkageName,DIFile *File,
884unsigned LineNo,DISubroutineType *Ty,unsigned ScopeLine,
885DINode::DIFlags Flags,DISubprogram::DISPFlags SPFlags,
886 DITemplateParameterArray TParams,DISubprogram *Decl,
887 DITypeArray ThrownTypes) {
888bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
889returnDISubprogram::getTemporary(VMContext,getNonCompileUnitScope(Context),
890Name,LinkageName, File, LineNo, Ty,
891 ScopeLine,nullptr, 0, 0, Flags, SPFlags,
892 IsDefinition ? CUNode :nullptr, TParams,
893 Decl,nullptr, ThrownTypes)
894 .release();
895}
896
897DISubprogram *DIBuilder::createMethod(
898DIScope *Context,StringRefName,StringRefLinkageName,DIFile *F,
899unsigned LineNo,DISubroutineType *Ty,unsigned VIndex,int ThisAdjustment,
900DIType *VTableHolder,DINode::DIFlags Flags,
901DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams,
902 DITypeArray ThrownTypes) {
903assert(getNonCompileUnitScope(Context) &&
904"Methods should have both a Context and a context that isn't "
905"the compile unit.");
906// FIXME: Do we want to use different scope/lines?
907bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
908auto *SP =getSubprogram(
909/*IsDistinct=*/IsDefinition, VMContext, cast<DIScope>(Context),Name,
910LinkageName,F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
911 Flags, SPFlags, IsDefinition ? CUNode :nullptr, TParams,nullptr,
912nullptr, ThrownTypes);
913
914if (IsDefinition)
915 AllSubprograms.push_back(SP);
916 trackIfUnresolved(SP);
917return SP;
918}
919
920DICommonBlock *DIBuilder::createCommonBlock(DIScope *Scope,
921DIGlobalVariable *Decl,
922StringRefName,DIFile *File,
923unsigned LineNo) {
924returnDICommonBlock::get(VMContext, Scope, Decl,Name, File, LineNo);
925}
926
927DINamespace *DIBuilder::createNameSpace(DIScope *Scope,StringRefName,
928bool ExportSymbols) {
929
930// It is okay to *not* make anonymous top-level namespaces distinct, because
931// all nodes that have an anonymous namespace as their parent scope are
932// guaranteed to be unique and/or are linked to their containing
933// DICompileUnit. This decision is an explicit tradeoff of link time versus
934// memory usage versus code simplicity and may get revisited in the future.
935returnDINamespace::get(VMContext,getNonCompileUnitScope(Scope),Name,
936 ExportSymbols);
937}
938
939DIModule *DIBuilder::createModule(DIScope *Scope,StringRefName,
940StringRef ConfigurationMacros,
941StringRef IncludePath,StringRef APINotesFile,
942DIFile *File,unsigned LineNo,bool IsDecl) {
943returnDIModule::get(VMContext, File,getNonCompileUnitScope(Scope),Name,
944 ConfigurationMacros, IncludePath, APINotesFile, LineNo,
945 IsDecl);
946}
947
948DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope,
949DIFile *File,
950unsigned Discriminator) {
951returnDILexicalBlockFile::get(VMContext, Scope, File, Discriminator);
952}
953
954DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope,DIFile *File,
955unsigned Line,unsigned Col) {
956// Make these distinct, to avoid merging two lexical blocks on the same
957// file/line/column.
958returnDILexicalBlock::getDistinct(VMContext,getNonCompileUnitScope(Scope),
959 File, Line, Col);
960}
961
962DbgInstPtr DIBuilder::insertDeclare(Value *Storage,DILocalVariable *VarInfo,
963DIExpression *Expr,constDILocation *DL,
964Instruction *InsertBefore) {
965return insertDeclare(Storage, VarInfo, Expr,DL, InsertBefore->getParent(),
966 InsertBefore);
967}
968
969DbgInstPtr DIBuilder::insertDeclare(Value *Storage,DILocalVariable *VarInfo,
970DIExpression *Expr,constDILocation *DL,
971BasicBlock *InsertAtEnd) {
972// If this block already has a terminator then insert this intrinsic before
973// the terminator. Otherwise, put it at the end of the block.
974Instruction *InsertBefore = InsertAtEnd->getTerminator();
975return insertDeclare(Storage, VarInfo, Expr,DL, InsertAtEnd, InsertBefore);
976}
977
978DbgInstPtrDIBuilder::insertDbgAssign(Instruction *LinkedInstr,Value *Val,
979DILocalVariable *SrcVar,
980DIExpression *ValExpr,Value *Addr,
981DIExpression *AddrExpr,
982constDILocation *DL) {
983auto *Link = cast_or_null<DIAssignID>(
984 LinkedInstr->getMetadata(LLVMContext::MD_DIAssignID));
985assert(Link &&"Linked instruction must have DIAssign metadata attached");
986
987if (M.IsNewDbgInfoFormat) {
988DbgVariableRecord *DVR =DbgVariableRecord::createDVRAssign(
989 Val, SrcVar, ValExpr, Link,Addr, AddrExpr,DL);
990BasicBlock *InsertBB = LinkedInstr->getParent();
991// Insert after LinkedInstr.
992BasicBlock::iterator NextIt = std::next(LinkedInstr->getIterator());
993Instruction *InsertBefore = NextIt == InsertBB->end() ? nullptr : &*NextIt;
994 insertDbgVariableRecord(DVR, InsertBB, InsertBefore,true);
995return DVR;
996 }
997
998LLVMContext &Ctx = LinkedInstr->getContext();
999Module *M = LinkedInstr->getModule();
1000if (!AssignFn)
1001 AssignFn =Intrinsic::getOrInsertDeclaration(M, Intrinsic::dbg_assign);
1002
1003 std::array<Value *, 6> Args = {
1004MetadataAsValue::get(Ctx,ValueAsMetadata::get(Val)),
1005MetadataAsValue::get(Ctx, SrcVar),
1006MetadataAsValue::get(Ctx, ValExpr),
1007MetadataAsValue::get(Ctx, Link),
1008MetadataAsValue::get(Ctx,ValueAsMetadata::get(Addr)),
1009MetadataAsValue::get(Ctx, AddrExpr),
1010 };
1011
1012IRBuilder<>B(Ctx);
1013B.SetCurrentDebugLocation(DL);
1014
1015auto *DVI = cast<DbgAssignIntrinsic>(B.CreateCall(AssignFn, Args));
1016 DVI->insertAfter(LinkedInstr->getIterator());
1017return DVI;
1018}
1019
1020DbgInstPtr DIBuilder::insertLabel(DILabel *LabelInfo,constDILocation *DL,
1021Instruction *InsertBefore) {
1022return insertLabel(LabelInfo,DL,
1023 InsertBefore ? InsertBefore->getParent() :nullptr,
1024 InsertBefore);
1025}
1026
1027DbgInstPtr DIBuilder::insertLabel(DILabel *LabelInfo,constDILocation *DL,
1028BasicBlock *InsertAtEnd) {
1029return insertLabel(LabelInfo,DL, InsertAtEnd,nullptr);
1030}
1031
1032DbgInstPtr DIBuilder::insertDbgValueIntrinsic(Value *V,
1033DILocalVariable *VarInfo,
1034DIExpression *Expr,
1035constDILocation *DL,
1036Instruction *InsertBefore) {
1037DbgInstPtr DVI = insertDbgValueIntrinsic(
1038 V, VarInfo, Expr,DL, InsertBefore ? InsertBefore->getParent() :nullptr,
1039 InsertBefore);
1040if (auto *Inst = dyn_cast<Instruction *>(DVI))
1041 cast<CallInst>(Inst)->setTailCall();
1042return DVI;
1043}
1044
1045DbgInstPtr DIBuilder::insertDbgValueIntrinsic(Value *V,
1046DILocalVariable *VarInfo,
1047DIExpression *Expr,
1048constDILocation *DL,
1049BasicBlock *InsertAtEnd) {
1050return insertDbgValueIntrinsic(V, VarInfo, Expr,DL, InsertAtEnd,nullptr);
1051}
1052
1053/// Initialize IRBuilder for inserting dbg.declare and dbg.value intrinsics.
1054/// This abstracts over the various ways to specify an insert position.
1055staticvoidinitIRBuilder(IRBuilder<> &Builder,constDILocation *DL,
1056BasicBlock *InsertBB,Instruction *InsertBefore) {
1057if (InsertBefore)
1058 Builder.SetInsertPoint(InsertBefore);
1059elseif (InsertBB)
1060 Builder.SetInsertPoint(InsertBB);
1061 Builder.SetCurrentDebugLocation(DL);
1062}
1063
1064staticValue *getDbgIntrinsicValueImpl(LLVMContext &VMContext,Value *V) {
1065assert(V &&"no value passed to dbg intrinsic");
1066returnMetadataAsValue::get(VMContext,ValueAsMetadata::get(V));
1067}
1068
1069staticFunction *getDeclareIntrin(Module &M) {
1070returnIntrinsic::getOrInsertDeclaration(&M, Intrinsic::dbg_declare);
1071}
1072
1073DbgInstPtr DIBuilder::insertDbgValueIntrinsic(
1074llvm::Value *Val,DILocalVariable *VarInfo,DIExpression *Expr,
1075constDILocation *DL,BasicBlock *InsertBB,Instruction *InsertBefore) {
1076if (M.IsNewDbgInfoFormat) {
1077DbgVariableRecord *DVR =
1078DbgVariableRecord::createDbgVariableRecord(Val, VarInfo, Expr,DL);
1079 insertDbgVariableRecord(DVR, InsertBB, InsertBefore);
1080return DVR;
1081 }
1082
1083if (!ValueFn)
1084 ValueFn =Intrinsic::getOrInsertDeclaration(&M, Intrinsic::dbg_value);
1085return insertDbgIntrinsic(ValueFn, Val, VarInfo, Expr,DL, InsertBB,
1086 InsertBefore);
1087}
1088
1089DbgInstPtr DIBuilder::insertDeclare(Value *Storage,DILocalVariable *VarInfo,
1090DIExpression *Expr,constDILocation *DL,
1091BasicBlock *InsertBB,
1092Instruction *InsertBefore) {
1093assert(VarInfo &&"empty or invalid DILocalVariable* passed to dbg.declare");
1094assert(DL &&"Expected debug loc");
1095assert(DL->getScope()->getSubprogram() ==
1096 VarInfo->getScope()->getSubprogram() &&
1097"Expected matching subprograms");
1098
1099if (M.IsNewDbgInfoFormat) {
1100DbgVariableRecord *DVR =
1101DbgVariableRecord::createDVRDeclare(Storage, VarInfo, Expr,DL);
1102 insertDbgVariableRecord(DVR, InsertBB, InsertBefore);
1103return DVR;
1104 }
1105
1106if (!DeclareFn)
1107 DeclareFn =getDeclareIntrin(M);
1108
1109 trackIfUnresolved(VarInfo);
1110 trackIfUnresolved(Expr);
1111Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1112MetadataAsValue::get(VMContext, VarInfo),
1113MetadataAsValue::get(VMContext, Expr)};
1114
1115IRBuilder<>B(DL->getContext());
1116initIRBuilder(B,DL, InsertBB, InsertBefore);
1117returnB.CreateCall(DeclareFn, Args);
1118}
1119
1120void DIBuilder::insertDbgVariableRecord(DbgVariableRecord *DVR,
1121BasicBlock *InsertBB,
1122Instruction *InsertBefore,
1123bool InsertAtHead) {
1124assert(InsertBefore || InsertBB);
1125 trackIfUnresolved(DVR->getVariable());
1126 trackIfUnresolved(DVR->getExpression());
1127if (DVR->isDbgAssign())
1128 trackIfUnresolved(DVR->getAddressExpression());
1129
1130BasicBlock::iterator InsertPt;
1131if (InsertBB && InsertBefore)
1132 InsertPt = InsertBefore->getIterator();
1133elseif (InsertBB)
1134 InsertPt = InsertBB->end();
1135 InsertPt.setHeadBit(InsertAtHead);
1136 InsertBB->insertDbgRecordBefore(DVR, InsertPt);
1137}
1138
1139Instruction *DIBuilder::insertDbgIntrinsic(llvm::Function *IntrinsicFn,
1140Value *V,DILocalVariable *VarInfo,
1141DIExpression *Expr,
1142constDILocation *DL,
1143BasicBlock *InsertBB,
1144Instruction *InsertBefore) {
1145assert(IntrinsicFn &&"must pass a non-null intrinsic function");
1146assert(V &&"must pass a value to a dbg intrinsic");
1147assert(VarInfo &&
1148"empty or invalid DILocalVariable* passed to debug intrinsic");
1149assert(DL &&"Expected debug loc");
1150assert(DL->getScope()->getSubprogram() ==
1151 VarInfo->getScope()->getSubprogram() &&
1152"Expected matching subprograms");
1153
1154 trackIfUnresolved(VarInfo);
1155 trackIfUnresolved(Expr);
1156Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1157MetadataAsValue::get(VMContext, VarInfo),
1158MetadataAsValue::get(VMContext, Expr)};
1159
1160IRBuilder<>B(DL->getContext());
1161initIRBuilder(B,DL, InsertBB, InsertBefore);
1162returnB.CreateCall(IntrinsicFn, Args);
1163}
1164
1165DbgInstPtr DIBuilder::insertLabel(DILabel *LabelInfo,constDILocation *DL,
1166BasicBlock *InsertBB,
1167Instruction *InsertBefore) {
1168assert(LabelInfo &&"empty or invalid DILabel* passed to dbg.label");
1169assert(DL &&"Expected debug loc");
1170assert(DL->getScope()->getSubprogram() ==
1171 LabelInfo->getScope()->getSubprogram() &&
1172"Expected matching subprograms");
1173
1174 trackIfUnresolved(LabelInfo);
1175if (M.IsNewDbgInfoFormat) {
1176DbgLabelRecord *DLR =newDbgLabelRecord(LabelInfo,DL);
1177if (InsertBB && InsertBefore)
1178 InsertBB->insertDbgRecordBefore(DLR, InsertBefore->getIterator());
1179elseif (InsertBB)
1180 InsertBB->insertDbgRecordBefore(DLR, InsertBB->end());
1181return DLR;
1182 }
1183
1184if (!LabelFn)
1185 LabelFn =Intrinsic::getOrInsertDeclaration(&M, Intrinsic::dbg_label);
1186
1187Value *Args[] = {MetadataAsValue::get(VMContext, LabelInfo)};
1188
1189IRBuilder<>B(DL->getContext());
1190initIRBuilder(B,DL, InsertBB, InsertBefore);
1191returnB.CreateCall(LabelFn, Args);
1192}
1193
1194voidDIBuilder::replaceVTableHolder(DICompositeType *&T,DIType *VTableHolder) {
1195 {
1196TypedTrackingMDRef<DICompositeType>N(T);
1197N->replaceVTableHolder(VTableHolder);
1198T =N.get();
1199 }
1200
1201// If this didn't create a self-reference, just return.
1202if (T != VTableHolder)
1203return;
1204
1205// Look for unresolved operands. T will drop RAUW support, orphaning any
1206// cycles underneath it.
1207if (T->isResolved())
1208for (constMDOperand &O :T->operands())
1209if (auto *N = dyn_cast_or_null<MDNode>(O))
1210 trackIfUnresolved(N);
1211}
1212
1213voidDIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements,
1214 DINodeArray TParams) {
1215 {
1216TypedTrackingMDRef<DICompositeType>N(T);
1217if (Elements)
1218N->replaceElements(Elements);
1219if (TParams)
1220N->replaceTemplateParams(DITemplateParameterArray(TParams));
1221T =N.get();
1222 }
1223
1224// If T isn't resolved, there's no problem.
1225if (!T->isResolved())
1226return;
1227
1228// If T is resolved, it may be due to a self-reference cycle. Track the
1229// arrays explicitly if they're unresolved, or else the cycles will be
1230// orphaned.
1231if (Elements)
1232 trackIfUnresolved(Elements.get());
1233if (TParams)
1234 trackIfUnresolved(TParams.get());
1235}
APInt.h
This file implements a class to represent arbitrary precision integral constant values and operations...
APSInt.h
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition:ARMSLSHardening.cpp:73
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Constants.h
This file contains the declarations for the subclasses of Constant, which represent the different fla...
createLocalVariable
static DILocalVariable * createLocalVariable(LLVMContext &VMContext, SmallVectorImpl< TrackingMDNodeRef > &PreservedNodes, DIScope *Context, StringRef Name, unsigned ArgNo, DIFile *File, unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags, uint32_t AlignInBits, DINodeArray Annotations=nullptr)
Definition:DIBuilder.cpp:793
getDeclareIntrin
static Function * getDeclareIntrin(Module &M)
Definition:DIBuilder.cpp:1069
createTypeWithFlags
static DIType * createTypeWithFlags(const DIType *Ty, DINode::DIFlags FlagsToSet)
Definition:DIBuilder.cpp:634
getNonCompileUnitScope
static DIScope * getNonCompileUnitScope(DIScope *N)
If N is compile unit return NULL otherwise return N.
Definition:DIBuilder.cpp:128
checkGlobalVariableScope
static void checkGlobalVariableScope(DIScope *Context)
Definition:DIBuilder.cpp:751
getSubprogram
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
Definition:DIBuilder.cpp:856
getConstantOrNull
static ConstantAsMetadata * getConstantOrNull(Constant *C)
Definition:DIBuilder.cpp:400
createTemplateValueParameterHelper
static DITemplateValueParameter * createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag, DIScope *Context, StringRef Name, DIType *Ty, bool IsDefault, Metadata *MD)
Definition:DIBuilder.cpp:469
getDbgIntrinsicValueImpl
static Value * getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V)
Definition:DIBuilder.cpp:1064
initIRBuilder
static void initIRBuilder(IRBuilder<> &Builder, const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore)
Initialize IRBuilder for inserting dbg.declare and dbg.value intrinsics.
Definition:DIBuilder.cpp:1055
createImportedModule
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, DINodeArray Elements, SmallVectorImpl< TrackingMDNodeRef > &ImportedModules)
Definition:DIBuilder.cpp:161
DIBuilder.h
RetTy
return RetTy
Definition:DeadArgumentElimination.cpp:361
Dwarf.h
This file contains constants used for implementing Dwarf debug support.
Addr
uint64_t Addr
Definition:ELFObjHandler.cpp:79
Name
std::string Name
Definition:ELFObjHandler.cpp:77
Size
uint64_t Size
Definition:ELFObjHandler.cpp:81
IRBuilder.h
Module.h
Module.h This file contains the declarations for the Module class.
LLVMContextImpl.h
F
#define F(x, y, z)
Definition:MD5.cpp:55
I
#define I(x, y, z)
Definition:MD5.cpp:58
CC
auto CC
Definition:RISCVRedundantCopyElimination.cpp:79
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
BaseTy
Node
Definition:ItaniumDemangle.h:163
T
llvm::APInt
Class for arbitrary precision integers.
Definition:APInt.h:78
llvm::APSInt
An arbitrary precision integer that knows its signedness.
Definition:APSInt.h:23
llvm::Annotations
Annotations lets you mark points and ranges inside source code, for tests:
Definition:Annotations.h:53
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition:ArrayRef.h:41
llvm::BasicBlock
LLVM Basic Block Representation.
Definition:BasicBlock.h:61
llvm::BasicBlock::end
iterator end()
Definition:BasicBlock.h:474
llvm::BasicBlock::insertDbgRecordBefore
void insertDbgRecordBefore(DbgRecord *DR, InstListType::iterator Here)
Insert a DbgRecord into a block at the position given by Here.
Definition:BasicBlock.cpp:1088
llvm::BasicBlock::iterator
InstListType::iterator iterator
Instruction iterators...
Definition:BasicBlock.h:177
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition:BasicBlock.h:240
llvm::ConstantAsMetadata
Definition:Metadata.h:525
llvm::ConstantAsMetadata::get
static ConstantAsMetadata * get(Constant *C)
Definition:Metadata.h:532
llvm::ConstantInt::getSigned
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
Definition:Constants.h:126
llvm::Constant
This is an important base class in LLVM.
Definition:Constant.h:42
llvm::DIBasicType
Basic type, like 'int' or 'float'.
Definition:DebugInfoMetadata.h:823
llvm::DIBuilder::createObjectPointerType
static DIType * createObjectPointerType(DIType *Ty, bool Implicit)
Create a uniqued clone of Ty with FlagObjectPointer set.
Definition:DIBuilder.cpp:647
llvm::DIBuilder::createUnspecifiedParameter
DIBasicType * createUnspecifiedParameter()
Create unspecified parameter type for a subroutine type.
Definition:DIBuilder.cpp:667
llvm::DIBuilder::createTempGlobalVariableFwdDecl
DIGlobalVariable * createTempGlobalVariableFwdDecl(DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DIType *Ty, bool IsLocalToUnit, MDNode *Decl=nullptr, MDTuple *TemplateParams=nullptr, uint32_t AlignInBits=0)
Identical to createGlobalVariable except that the resulting DbgNode is temporary and meant to be RAUW...
Definition:DIBuilder.cpp:779
llvm::DIBuilder::createTemplateTemplateParameter
DITemplateValueParameter * createTemplateTemplateParameter(DIScope *Scope, StringRef Name, DIType *Ty, StringRef Val, bool IsDefault=false)
Create debugging information for a template template parameter.
Definition:DIBuilder.cpp:486
llvm::DIBuilder::createBitFieldMemberType
DIDerivedType * createBitFieldMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint64_t OffsetInBits, uint64_t StorageOffsetInBits, DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations=nullptr)
Create debugging information entry for a bit field member.
Definition:DIBuilder.cpp:416
llvm::DIBuilder::replaceTemporary
NodeTy * replaceTemporary(TempMDNode &&N, NodeTy *Replacement)
Replace a temporary node.
Definition:DIBuilder.h:1061
llvm::DIBuilder::createTypedef
DIDerivedType * createTypedef(DIType *Ty, StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagZero, DINodeArray Annotations=nullptr)
Create debugging information entry for a typedef.
Definition:DIBuilder.cpp:348
llvm::DIBuilder::finalize
void finalize()
Construct any deferred debug info descriptors.
Definition:DIBuilder.cpp:63
llvm::DIBuilder::createSubroutineType
DISubroutineType * createSubroutineType(DITypeRefArray ParameterTypes, DINode::DIFlags Flags=DINode::FlagZero, unsigned CC=0)
Create subroutine type.
Definition:DIBuilder.cpp:562
llvm::DIBuilder::createMacro
DIMacro * createMacro(DIMacroFile *Parent, unsigned Line, unsigned MacroType, StringRef Name, StringRef Value=StringRef())
Create debugging information entry for a macro.
Definition:DIBuilder.cpp:220
llvm::DIBuilder::createInheritance
DIDerivedType * createInheritance(DIType *Ty, DIType *BaseTy, uint64_t BaseOffset, uint32_t VBPtrOffset, DINode::DIFlags Flags)
Create debugging information entry to establish inheritance relationship between two types.
Definition:DIBuilder.cpp:378
llvm::DIBuilder::createStaticMemberType
DIDerivedType * createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, DIType *Ty, DINode::DIFlags Flags, Constant *Val, unsigned Tag, uint32_t AlignInBits=0)
Create debugging information entry for a C++ static data member.
Definition:DIBuilder.cpp:431
llvm::DIBuilder::createVariantMemberType
DIDerivedType * createVariantMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty)
Create debugging information entry for a variant.
Definition:DIBuilder.cpp:406
llvm::DIBuilder::createClassType
DICompositeType * createClassType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang=0, DIType *VTableHolder=nullptr, MDNode *TemplateParms=nullptr, StringRef UniqueIdentifier="")
Create debugging information entry for a class.
Definition:DIBuilder.cpp:502
llvm::DIBuilder::createEnumerationType
DICompositeType * createEnumerationType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements, DIType *UnderlyingType, unsigned RunTimeLang=0, StringRef UniqueIdentifier="", bool IsScoped=false)
Create debugging information entry for an enumeration.
Definition:DIBuilder.cpp:569
llvm::DIBuilder::createLexicalBlockFile
DILexicalBlockFile * createLexicalBlockFile(DIScope *Scope, DIFile *File, unsigned Discriminator=0)
This creates a descriptor for a lexical block with a new file attached.
Definition:DIBuilder.cpp:948
llvm::DIBuilder::finalizeSubprogram
void finalizeSubprogram(DISubprogram *SP)
Finalize a specific subprogram - no new variables may be added to this subprogram afterwards.
Definition:DIBuilder.cpp:55
llvm::DIBuilder::createQualifiedType
DIDerivedType * createQualifiedType(unsigned Tag, DIType *FromTy)
Create debugging information entry for a qualified type, e.g.
Definition:DIBuilder.cpp:297
llvm::DIBuilder::createCompileUnit
DICompileUnit * createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized, StringRef Flags, unsigned RV, StringRef SplitName=StringRef(), DICompileUnit::DebugEmissionKind Kind=DICompileUnit::DebugEmissionKind::FullDebug, uint64_t DWOId=0, bool SplitDebugInlining=true, bool DebugInfoForProfiling=false, DICompileUnit::DebugNameTableKind NameTableKind=DICompileUnit::DebugNameTableKind::Default, bool RangesBaseAddress=false, StringRef SysRoot={}, StringRef SDK={})
A CompileUnit provides an anchor for all debugging information generated during this instance of comp...
Definition:DIBuilder.cpp:134
llvm::DIBuilder::createTempFunctionFwdDecl
DISubprogram * createTempFunctionFwdDecl(DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, DINode::DIFlags Flags=DINode::FlagZero, DISubprogram::DISPFlags SPFlags=DISubprogram::SPFlagZero, DITemplateParameterArray TParams=nullptr, DISubprogram *Decl=nullptr, DITypeArray ThrownTypes=nullptr)
Identical to createFunction, except that the resulting DbgNode is meant to be RAUWed.
Definition:DIBuilder.cpp:882
llvm::DIBuilder::createObjCIVar
DIDerivedType * createObjCIVar(StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DINode::DIFlags Flags, DIType *Ty, MDNode *PropertyNode)
Create debugging information entry for Objective-C instance variable.
Definition:DIBuilder.cpp:443
llvm::DIBuilder::createArtificialType
static DIType * createArtificialType(DIType *Ty)
Create a uniqued clone of Ty with FlagArtificial set.
Definition:DIBuilder.cpp:640
llvm::DIBuilder::createVectorType
DICompositeType * createVectorType(uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts)
Create debugging information entry for a vector type.
Definition:DIBuilder.cpp:619
llvm::DIBuilder::createLabel
DILabel * createLabel(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, bool AlwaysPreserve=false)
Create a new descriptor for an label.
Definition:DIBuilder.cpp:837
llvm::DIBuilder::createNameSpace
DINamespace * createNameSpace(DIScope *Scope, StringRef Name, bool ExportSymbols)
This creates new descriptor for a namespace with the specified parent scope.
Definition:DIBuilder.cpp:927
llvm::DIBuilder::createStringType
DIStringType * createStringType(StringRef Name, uint64_t SizeInBits)
Create debugging information entry for a string type.
Definition:DIBuilder.cpp:275
llvm::DIBuilder::createFunction
DISubprogram * createFunction(DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, DINode::DIFlags Flags=DINode::FlagZero, DISubprogram::DISPFlags SPFlags=DISubprogram::SPFlagZero, DITemplateParameterArray TParams=nullptr, DISubprogram *Decl=nullptr, DITypeArray ThrownTypes=nullptr, DINodeArray Annotations=nullptr, StringRef TargetFuncName="")
Create a new descriptor for the specified subprogram.
Definition:DIBuilder.cpp:862
llvm::DIBuilder::insertDbgAssign
DbgInstPtr insertDbgAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *SrcVar, DIExpression *ValExpr, Value *Addr, DIExpression *AddrExpr, const DILocation *DL)
Insert a new llvm.dbg.assign intrinsic call.
Definition:DIBuilder.cpp:978
llvm::DIBuilder::createLexicalBlock
DILexicalBlock * createLexicalBlock(DIScope *Scope, DIFile *File, unsigned Line, unsigned Col)
This creates a descriptor for a lexical block with the specified parent context.
Definition:DIBuilder.cpp:954
llvm::DIBuilder::createUnionType
DICompositeType * createUnionType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DINodeArray Elements, unsigned RunTimeLang=0, StringRef UniqueIdentifier="")
Create debugging information entry for an union.
Definition:DIBuilder.cpp:536
llvm::DIBuilder::getOrCreateMacroArray
DIMacroNodeArray getOrCreateMacroArray(ArrayRef< Metadata * > Elements)
Get a DIMacroNodeArray, create one if required.
Definition:DIBuilder.cpp:705
llvm::DIBuilder::createSetType
DIDerivedType * createSetType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, DIType *Ty)
Create debugging information entry for a set.
Definition:DIBuilder.cpp:584
llvm::DIBuilder::replaceVTableHolder
void replaceVTableHolder(DICompositeType *&T, DIType *VTableHolder)
Replace the vtable holder in the given type.
Definition:DIBuilder.cpp:1194
llvm::DIBuilder::createNullPtrType
DIBasicType * createNullPtrType()
Create C++11 nullptr type.
Definition:DIBuilder.cpp:262
llvm::DIBuilder::createCommonBlock
DICommonBlock * createCommonBlock(DIScope *Scope, DIGlobalVariable *decl, StringRef Name, DIFile *File, unsigned LineNo)
Create common block entry for a Fortran common block.
Definition:DIBuilder.cpp:920
llvm::DIBuilder::createFriend
DIDerivedType * createFriend(DIType *Ty, DIType *FriendTy)
Create debugging information entry for a 'friend'.
Definition:DIBuilder.cpp:370
llvm::DIBuilder::retainType
void retainType(DIScope *T)
Retain DIScope* in a module even if it is not referenced through debug info anchors.
Definition:DIBuilder.cpp:659
llvm::DIBuilder::createTemplateAlias
DIDerivedType * createTemplateAlias(DIType *Ty, StringRef Name, DIFile *File, unsigned LineNo, DIScope *Context, DINodeArray TParams, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagZero, DINodeArray Annotations=nullptr)
Create debugging information entry for a template alias.
Definition:DIBuilder.cpp:360
llvm::DIBuilder::createPointerType
DIDerivedType * createPointerType(DIType *PointeeTy, uint64_t SizeInBits, uint32_t AlignInBits=0, std::optional< unsigned > DWARFAddressSpace=std::nullopt, StringRef Name="", DINodeArray Annotations=nullptr)
Create debugging information entry for a pointer.
Definition:DIBuilder.cpp:316
llvm::DIBuilder::createTemplateParameterPack
DITemplateValueParameter * createTemplateParameterPack(DIScope *Scope, StringRef Name, DIType *Ty, DINodeArray Val)
Create debugging information for a template parameter pack.
Definition:DIBuilder.cpp:495
llvm::DIBuilder::createGlobalVariableExpression
DIGlobalVariableExpression * createGlobalVariableExpression(DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DIType *Ty, bool IsLocalToUnit, bool isDefined=true, DIExpression *Expr=nullptr, MDNode *Decl=nullptr, MDTuple *TemplateParams=nullptr, uint32_t AlignInBits=0, DINodeArray Annotations=nullptr)
Create a new descriptor for the specified variable.
Definition:DIBuilder.cpp:760
llvm::DIBuilder::createBasicType
DIBasicType * createBasicType(StringRef Name, uint64_t SizeInBits, unsigned Encoding, DINode::DIFlags Flags=DINode::FlagZero, uint32_t NumExtraInhabitants=0)
Create debugging information entry for a basic type.
Definition:DIBuilder.cpp:266
llvm::DIBuilder::getOrCreateSubrange
DISubrange * getOrCreateSubrange(int64_t Lo, int64_t Count)
Create a descriptor for a value range.
Definition:DIBuilder.cpp:720
llvm::DIBuilder::createReferenceType
DIDerivedType * createReferenceType(unsigned Tag, DIType *RTy, uint64_t SizeInBits=0, uint32_t AlignInBits=0, std::optional< unsigned > DWARFAddressSpace=std::nullopt)
Create debugging information entry for a c++ style reference or rvalue reference type.
Definition:DIBuilder.cpp:339
llvm::DIBuilder::createMethod
DISubprogram * createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned VTableIndex=0, int ThisAdjustment=0, DIType *VTableHolder=nullptr, DINode::DIFlags Flags=DINode::FlagZero, DISubprogram::DISPFlags SPFlags=DISubprogram::SPFlagZero, DITemplateParameterArray TParams=nullptr, DITypeArray ThrownTypes=nullptr)
Create a new descriptor for the specified C++ method.
Definition:DIBuilder.cpp:897
llvm::DIBuilder::createTempMacroFile
DIMacroFile * createTempMacroFile(DIMacroFile *Parent, unsigned Line, DIFile *File)
Create debugging information temporary entry for a macro file.
Definition:DIBuilder.cpp:232
llvm::DIBuilder::createArrayType
DICompositeType * createArrayType(uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts, PointerUnion< DIExpression *, DIVariable * > DataLocation=nullptr, PointerUnion< DIExpression *, DIVariable * > Associated=nullptr, PointerUnion< DIExpression *, DIVariable * > Allocated=nullptr, PointerUnion< DIExpression *, DIVariable * > Rank=nullptr)
Create debugging information entry for an array.
Definition:DIBuilder.cpp:597
llvm::DIBuilder::createMemberPointerType
DIDerivedType * createMemberPointerType(DIType *PointeeTy, DIType *Class, uint64_t SizeInBits, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagZero)
Create debugging information entry for a pointer to member.
Definition:DIBuilder.cpp:327
llvm::DIBuilder::getOrCreateTypeArray
DITypeRefArray getOrCreateTypeArray(ArrayRef< Metadata * > Elements)
Get a DITypeRefArray, create one if required.
Definition:DIBuilder.cpp:709
llvm::DIBuilder::getOrCreateArray
DINodeArray getOrCreateArray(ArrayRef< Metadata * > Elements)
Get a DINodeArray, create one if required.
Definition:DIBuilder.cpp:700
llvm::DIBuilder::createEnumerator
DIEnumerator * createEnumerator(StringRef Name, const APSInt &Value)
Create a single enumerator value.
Definition:DIBuilder.cpp:252
llvm::DIBuilder::createTemplateTypeParameter
DITemplateTypeParameter * createTemplateTypeParameter(DIScope *Scope, StringRef Name, DIType *Ty, bool IsDefault)
Create debugging information for template type parameter.
Definition:DIBuilder.cpp:462
llvm::DIBuilder::DIBuilder
DIBuilder(Module &M, bool AllowUnresolved=true, DICompileUnit *CU=nullptr)
Construct a builder for a module.
Definition:DIBuilder.cpp:27
llvm::DIBuilder::createExpression
DIExpression * createExpression(ArrayRef< uint64_t > Addr={})
Create a new descriptor for the specified variable which has a complex address expression for its add...
Definition:DIBuilder.cpp:851
llvm::DIBuilder::createReplaceableCompositeType
DICompositeType * createReplaceableCompositeType(unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line, unsigned RuntimeLang=0, uint64_t SizeInBits=0, uint32_t AlignInBits=0, DINode::DIFlags Flags=DINode::FlagFwdDecl, StringRef UniqueIdentifier="", DINodeArray Annotations=nullptr)
Create a temporary forward-declared type.
Definition:DIBuilder.cpp:684
llvm::DIBuilder::createPtrAuthQualifiedType
DIDerivedType * createPtrAuthQualifiedType(DIType *FromTy, unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, bool IsaPointer, bool authenticatesNullValues)
Create a __ptrauth qualifier.
Definition:DIBuilder.cpp:302
llvm::DIBuilder::createVariantPart
DICompositeType * createVariantPart(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DIDerivedType *Discriminator, DINodeArray Elements, StringRef UniqueIdentifier="")
Create debugging information entry for a variant part.
Definition:DIBuilder.cpp:549
llvm::DIBuilder::createImportedModule
DIImportedEntity * createImportedModule(DIScope *Context, DINamespace *NS, DIFile *File, unsigned Line, DINodeArray Elements=nullptr)
Create a descriptor for an imported module.
Definition:DIBuilder.cpp:177
llvm::DIBuilder::createMemberType
DIDerivedType * createMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DINode::DIFlags Flags, DIType *Ty, DINodeArray Annotations=nullptr)
Create debugging information entry for a member.
Definition:DIBuilder.cpp:390
llvm::DIBuilder::createImportedDeclaration
DIImportedEntity * createImportedDeclaration(DIScope *Context, DINode *Decl, DIFile *File, unsigned Line, StringRef Name="", DINodeArray Elements=nullptr)
Create a descriptor for an imported function.
Definition:DIBuilder.cpp:204
llvm::DIBuilder::createAutoVariable
DILocalVariable * createAutoVariable(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, DIType *Ty, bool AlwaysPreserve=false, DINode::DIFlags Flags=DINode::FlagZero, uint32_t AlignInBits=0)
Create a new descriptor for an auto variable.
Definition:DIBuilder.cpp:813
llvm::DIBuilder::createArtificialSubprogram
static DISubprogram * createArtificialSubprogram(DISubprogram *SP)
Create a distinct clone of SP with FlagArtificial set.
Definition:DIBuilder.cpp:629
llvm::DIBuilder::getOrCreateGenericSubrange
DIGenericSubrange * getOrCreateGenericSubrange(DIGenericSubrange::BoundType Count, DIGenericSubrange::BoundType LowerBound, DIGenericSubrange::BoundType UpperBound, DIGenericSubrange::BoundType Stride)
Definition:DIBuilder.cpp:739
llvm::DIBuilder::createUnspecifiedType
DIBasicType * createUnspecifiedType(StringRef Name)
Create a DWARF unspecified type.
Definition:DIBuilder.cpp:257
llvm::DIBuilder::createObjCProperty
DIObjCProperty * createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber, StringRef GetterName, StringRef SetterName, unsigned PropertyAttributes, DIType *Ty)
Create debugging information entry for Objective-C property.
Definition:DIBuilder.cpp:454
llvm::DIBuilder::createForwardDecl
DICompositeType * createForwardDecl(unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line, unsigned RuntimeLang=0, uint64_t SizeInBits=0, uint32_t AlignInBits=0, StringRef UniqueIdentifier="")
Create a permanent forward-declared type.
Definition:DIBuilder.cpp:670
llvm::DIBuilder::createTemplateValueParameter
DITemplateValueParameter * createTemplateValueParameter(DIScope *Scope, StringRef Name, DIType *Ty, bool IsDefault, Constant *Val)
Create debugging information for template value parameter.
Definition:DIBuilder.cpp:477
llvm::DIBuilder::createParameterVariable
DILocalVariable * createParameterVariable(DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, unsigned LineNo, DIType *Ty, bool AlwaysPreserve=false, DINode::DIFlags Flags=DINode::FlagZero, DINodeArray Annotations=nullptr)
Create a new descriptor for a parameter variable.
Definition:DIBuilder.cpp:825
llvm::DIBuilder::createFile
DIFile * createFile(StringRef Filename, StringRef Directory, std::optional< DIFile::ChecksumInfo< StringRef > > Checksum=std::nullopt, std::optional< StringRef > Source=std::nullopt)
Create a file descriptor to hold debugging information for a file.
Definition:DIBuilder.cpp:214
llvm::DIBuilder::createStructType
DICompositeType * createStructType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang=0, DIType *VTableHolder=nullptr, StringRef UniqueIdentifier="", DIType *Specification=nullptr, uint32_t NumExtraInhabitants=0)
Create debugging information entry for a struct.
Definition:DIBuilder.cpp:520
llvm::DIBuilder::replaceArrays
void replaceArrays(DICompositeType *&T, DINodeArray Elements, DINodeArray TParams=DINodeArray())
Replace arrays on a composite type.
Definition:DIBuilder.cpp:1213
llvm::DIBuilder::createModule
DIModule * createModule(DIScope *Scope, StringRef Name, StringRef ConfigurationMacros, StringRef IncludePath, StringRef APINotesFile={}, DIFile *File=nullptr, unsigned LineNo=0, bool IsDecl=false)
This creates new descriptor for a module with the specified parent scope.
Definition:DIBuilder.cpp:939
llvm::DICommonBlock
Debug common block.
Definition:DebugInfoMetadata.h:3403
llvm::DICompileUnit
Compile unit.
Definition:DebugInfoMetadata.h:1469
llvm::DICompileUnit::getEnumTypes
DICompositeTypeArray getEnumTypes() const
Definition:DebugInfoMetadata.h:1609
llvm::DICompileUnit::DebugNameTableKind
DebugNameTableKind
Definition:DebugInfoMetadata.h:1482
llvm::DICompileUnit::replaceEnumTypes
void replaceEnumTypes(DICompositeTypeArray N)
Replace arrays.
Definition:DebugInfoMetadata.h:1652
llvm::DICompileUnit::getMacros
DIMacroNodeArray getMacros() const
Definition:DebugInfoMetadata.h:1621
llvm::DICompileUnit::replaceRetainedTypes
void replaceRetainedTypes(DITypeArray N)
Definition:DebugInfoMetadata.h:1655
llvm::DICompileUnit::replaceGlobalVariables
void replaceGlobalVariables(DIGlobalVariableExpressionArray N)
Definition:DebugInfoMetadata.h:1656
llvm::DICompileUnit::replaceMacros
void replaceMacros(DIMacroNodeArray N)
Definition:DebugInfoMetadata.h:1662
llvm::DICompileUnit::getImportedEntities
DIImportedEntityArray getImportedEntities() const
Definition:DebugInfoMetadata.h:1618
llvm::DICompileUnit::getRetainedTypes
DIScopeArray getRetainedTypes() const
Definition:DebugInfoMetadata.h:1612
llvm::DICompileUnit::DebugEmissionKind
DebugEmissionKind
Definition:DebugInfoMetadata.h:1474
llvm::DICompileUnit::replaceImportedEntities
void replaceImportedEntities(DIImportedEntityArray N)
Definition:DebugInfoMetadata.h:1659
llvm::DICompileUnit::getGlobalVariables
DIGlobalVariableExpressionArray getGlobalVariables() const
Definition:DebugInfoMetadata.h:1615
llvm::DICompositeType
Composite types.
Definition:DebugInfoMetadata.h:1174
llvm::DIDerivedType
Derived types.
Definition:DebugInfoMetadata.h:997
llvm::DIEnumerator
Enumeration value.
Definition:DebugInfoMetadata.h:459
llvm::DIExpression
DWARF expression.
Definition:DebugInfoMetadata.h:2763
llvm::DIFile
File.
Definition:DebugInfoMetadata.h:573
llvm::DIGenericSubrange
Definition:DebugInfoMetadata.h:411
llvm::DIGlobalVariableExpression
A pair of DIGlobalVariable and DIExpression.
Definition:DebugInfoMetadata.h:3761
llvm::DIGlobalVariable
Global variables.
Definition:DebugInfoMetadata.h:3315
llvm::DIImportedEntity
An imported module (C++ using directive or similar).
Definition:DebugInfoMetadata.h:3696
llvm::DILabel
Label.
Definition:DebugInfoMetadata.h:3551
llvm::DILabel::getScope
DILocalScope * getScope() const
Get the local scope for this label.
Definition:DebugInfoMetadata.h:3589
llvm::DILexicalBlockFile
Definition:DebugInfoMetadata.h:2336
llvm::DILexicalBlock
Debug lexical block.
Definition:DebugInfoMetadata.h:2283
llvm::DILocalScope::getSubprogram
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
Definition:DebugInfoMetadata.cpp:1051
llvm::DILocalVariable
Local variable.
Definition:DebugInfoMetadata.h:3460
llvm::DILocalVariable::getScope
DILocalScope * getScope() const
Get the local scope for this variable.
Definition:DebugInfoMetadata.h:3518
llvm::DILocation
Debug location.
Definition:DebugInfoMetadata.h:1988
llvm::DIMacroFile
Macro file.
Definition:DebugInfoMetadata.h:3910
llvm::DIMacro
Macro.
Definition:DebugInfoMetadata.h:3856
llvm::DIModule
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Definition:DebugInfoMetadata.h:2511
llvm::DINamespace
Debug lexical block.
Definition:DebugInfoMetadata.h:2462
llvm::DINode
Tagged DWARF-like metadata node.
Definition:DebugInfoMetadata.h:135
llvm::DINode::DIFlags
DIFlags
Debug info flags.
Definition:DebugInfoMetadata.h:174
llvm::DIObjCProperty
Definition:DebugInfoMetadata.h:3614
llvm::DIScope
Base class for scope-like contexts.
Definition:DebugInfoMetadata.h:519
llvm::DIStringType
String type, Fortran CHARACTER(n)
Definition:DebugInfoMetadata.h:905
llvm::DISubprogram
Subprogram description.
Definition:DebugInfoMetadata.h:1710
llvm::DISubprogram::DISPFlags
DISPFlags
Debug info subprogram flags.
Definition:DebugInfoMetadata.h:1725
llvm::DISubrange
Array subrange.
Definition:DebugInfoMetadata.h:348
llvm::DISubroutineType
Type array for a subprogram.
Definition:DebugInfoMetadata.h:1412
llvm::DITemplateTypeParameter
Definition:DebugInfoMetadata.h:2607
llvm::DITemplateValueParameter
Definition:DebugInfoMetadata.h:2646
llvm::DITypeRefArray
Definition:DebugInfoMetadata.h:73
llvm::DIType
Base class for types.
Definition:DebugInfoMetadata.h:710
llvm::DIType::cloneWithFlags
TempDIType cloneWithFlags(DIFlags NewFlags) const
Returns a new temporary DIType with updated Flags.
Definition:DebugInfoMetadata.h:769
llvm::DIType::isObjectPointer
bool isObjectPointer() const
Definition:DebugInfoMetadata.h:788
llvm::DIType::getFlags
DIFlags getFlags() const
Definition:DebugInfoMetadata.h:760
llvm::DIType::isArtificial
bool isArtificial() const
Definition:DebugInfoMetadata.h:787
llvm::DIVariable
Base class for variables.
Definition:DebugInfoMetadata.h:2698
llvm::DbgLabelRecord
Records a position in IR for a source label (DILabel).
Definition:DebugProgramInstruction.h:231
llvm::DbgVariableRecord
Record of a variable value-assignment, aka a non instruction representation of the dbg....
Definition:DebugProgramInstruction.h:270
llvm::DbgVariableRecord::createDbgVariableRecord
static DbgVariableRecord * createDbgVariableRecord(Value *Location, DILocalVariable *DV, DIExpression *Expr, const DILocation *DI)
Definition:DebugProgramInstruction.cpp:179
llvm::DbgVariableRecord::createDVRDeclare
static DbgVariableRecord * createDVRDeclare(Value *Address, DILocalVariable *DV, DIExpression *Expr, const DILocation *DI)
Definition:DebugProgramInstruction.cpp:194
llvm::DbgVariableRecord::isDbgAssign
bool isDbgAssign() const
Definition:DebugProgramInstruction.h:506
llvm::DbgVariableRecord::getExpression
DIExpression * getExpression() const
Definition:DebugProgramInstruction.h:453
llvm::DbgVariableRecord::getVariable
DILocalVariable * getVariable() const
Definition:DebugProgramInstruction.h:449
llvm::DbgVariableRecord::createDVRAssign
static DbgVariableRecord * createDVRAssign(Value *Val, DILocalVariable *Variable, DIExpression *Expression, DIAssignID *AssignID, Value *Address, DIExpression *AddressExpression, const DILocation *DI)
Definition:DebugProgramInstruction.cpp:211
llvm::DbgVariableRecord::getAddressExpression
DIExpression * getAddressExpression() const
Definition:DebugProgramInstruction.h:514
llvm::Function
Definition:Function.h:63
llvm::IRBuilderBase::SetCurrentDebugLocation
void SetCurrentDebugLocation(DebugLoc L)
Set location information used by debugging information.
Definition:IRBuilder.h:239
llvm::IRBuilderBase::SetInsertPoint
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Definition:IRBuilder.h:199
llvm::IRBuilder
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition:IRBuilder.h:2705
llvm::Instruction
Definition:Instruction.h:68
llvm::Instruction::getModule
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition:Instruction.cpp:68
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition:Instruction.h:426
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition:Type.cpp:311
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition:LLVMContext.h:67
llvm::MDNode
Metadata node.
Definition:Metadata.h:1073
llvm::MDNode::getDistinct
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition:Metadata.h:1557
llvm::MDNode::getTemporary
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition:Metadata.h:1561
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition:Metadata.h:1549
llvm::MDNode::replaceWithDistinct
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithDistinct(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a distinct one.
Definition:Metadata.h:1315
llvm::MDNode::replaceWithUniqued
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
Definition:Metadata.h:1305
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition:Metadata.h:895
llvm::MDString::get
static MDString * get(LLVMContext &Context, StringRef Str)
Definition:Metadata.cpp:606
llvm::MDTuple
Tuple of metadata.
Definition:Metadata.h:1479
llvm::MDTuple::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition:Metadata.h:1506
llvm::MetadataAsValue::get
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition:Metadata.cpp:103
llvm::Metadata
Root of the metadata hierarchy.
Definition:Metadata.h:62
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition:Module.h:65
llvm::Module::IsNewDbgInfoFormat
bool IsNewDbgInfoFormat
Is this Module using intrinsics to record the position of debugging information, or non-intrinsic rec...
Definition:Module.h:217
llvm::Module::getOrInsertNamedMetadata
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition:Module.cpp:304
llvm::NamedMDNode
A tuple of MDNodes.
Definition:Metadata.h:1737
llvm::NamedMDNode::addOperand
void addOperand(MDNode *M)
Definition:Metadata.cpp:1431
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition:PointerUnion.h:118
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition:SmallPtrSet.h:384
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition:SmallPtrSet.h:519
llvm::SmallVectorBase::empty
bool empty() const
Definition:SmallVector.h:81
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition:SmallVector.h:573
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition:SmallVector.h:937
llvm::SmallVectorTemplateBase::push_back
void push_back(const T &Elt)
Definition:SmallVector.h:413
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition:SmallVector.h:1196
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition:StringRef.h:51
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
llvm::TypedTrackingMDRef< MDNode >
llvm::ValueAsMetadata::get
static ValueAsMetadata * get(Value *V)
Definition:Metadata.cpp:501
llvm::Value
LLVM Value Representation.
Definition:Value.h:74
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition:Value.cpp:1075
llvm::ilist_detail::node_parent_access::getParent
const ParentTy * getParent() const
Definition:ilist_node.h:32
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition:ilist_node.h:132
uint32_t
uint64_t
DebugInfo.h
CU
Definition:AArch64AsmBackend.cpp:549
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition:AMDGPUMetadata.h:395
llvm::CallingConv::C
@ C
The default llvm calling convention, compatible with C.
Definition:CallingConv.h:34
llvm::Intrinsic::getOrInsertDeclaration
Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})
Look up the Function declaration of the intrinsic id in the Module M.
Definition:Intrinsics.cpp:732
llvm::dwarf
Calculates the starting offsets for various sections within the .debug_names section.
Definition:Dwarf.h:34
llvm::dwarf::DW_LANG_lo_user
@ DW_LANG_lo_user
Definition:Dwarf.h:211
llvm::dwarf::DW_MACINFO_undef
@ DW_MACINFO_undef
Definition:Dwarf.h:797
llvm::dwarf::DW_MACINFO_start_file
@ DW_MACINFO_start_file
Definition:Dwarf.h:798
llvm::dwarf::DW_MACINFO_define
@ DW_MACINFO_define
Definition:Dwarf.h:796
llvm::dwarf::Tag
Tag
Definition:Dwarf.h:103
llvm::sampleprof::Base
@ Base
Definition:Discriminator.h:58
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition:AddressRanges.h:18
llvm::PackElem::Lo
@ Lo
llvm::DINameKind::LinkageName
@ LinkageName
N
#define N
llvm::DIFile::ChecksumInfo
A single checksum, represented by a Kind and a Value (a string).
Definition:DebugInfoMetadata.h:594
Generated on Fri Jul 18 2025 11:40:18 for LLVM by doxygen 1.9.6
[8]ページ先頭
©2009-2025 Movatter.jp