29 : M(m), VMContext(M.getContext()), CUNode(
CU), DeclareFn(nullptr),
30 ValueFn(nullptr), LabelFn(nullptr), AssignFn(nullptr),
31 AllowUnresolvedNodes(AllowUnresolvedNodes) {
34 AllEnumTypes.assign(ETs.begin(), ETs.end());
36 AllRetainTypes.assign(RTs.begin(), RTs.end());
38 AllGVs.assign(GVs.begin(), GVs.end());
40 ImportedModules.assign(IMs.begin(), IMs.end());
41 if (
const auto &MNs = CUNode->
getMacros())
42 AllMacrosPerParent.insert({
nullptr, {MNs.begin(), MNs.end()}});
46void DIBuilder::trackIfUnresolved(
MDNode *
N) {
52 assert(AllowUnresolvedNodes &&
"Cannot handle unresolved nodes");
53 UnresolvedNodes.emplace_back(
N);
57 auto PN = SubprogramTrackedNodes.find(SP);
58 if (PN != SubprogramTrackedNodes.end())
59 SP->replaceRetainedNodes(
66 assert(!AllowUnresolvedNodes &&
67 "creating type nodes without a CU is not supported");
71 if (!AllEnumTypes.empty())
74 AllEnumTypes.end())));
86 if (!RetainValues.
empty())
89 for (
auto *SP : AllSubprograms)
91 for (
auto *
N : RetainValues)
92 if (
auto *SP = dyn_cast<DISubprogram>(
N))
98 if (!ImportedModules.empty())
101 ImportedModules.end())));
103 for (
const auto &
I : AllMacrosPerParent) {
110 auto *TMF = cast<DIMacroFile>(
I.first);
112 TMF->getLine(), TMF->getFile(),
119 for (
const auto &
N : UnresolvedNodes)
120 if (
N && !
N->isResolved())
122 UnresolvedNodes.clear();
125 AllowUnresolvedNodes =
false;
130 if (!
N || isa<DICompileUnit>(
N))
132 return cast<DIScope>(
N);
139 bool SplitDebugInlining,
bool DebugInfoForProfiling,
143 assert(((Lang <= dwarf::DW_LANG_Mojo && Lang >= dwarf::DW_LANG_C89) ||
145 "Invalid Language tag");
147 assert(!CUNode &&
"Can only make one compile unit per DIBuilder instance");
149 VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
150 SplitName, Kind,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr, DWOId,
151 SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
152 RangesBaseAddress, SysRoot, SDK);
157 trackIfUnresolved(CUNode);
164 DINodeArray Elements,
167 assert(File &&
"Source location has line number but no file");
168 unsigned EntitiesCount =
C.pImpl->DIImportedEntitys.size();
170 File, Line,
Name, Elements);
171 if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
181 DINodeArray Elements) {
182 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
183 Context, NS, File, Line,
StringRef(), Elements,
184 getImportTrackingVector(Context));
189 DIFile *File,
unsigned Line,
190 DINodeArray Elements) {
191 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
192 Context, NS, File, Line,
StringRef(), Elements,
193 getImportTrackingVector(Context));
197 DIFile *File,
unsigned Line,
198 DINodeArray Elements) {
199 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
200 Context, M, File, Line,
StringRef(), Elements,
201 getImportTrackingVector(Context));
206 DIFile *File,
unsigned Line,
210 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
211 Context, Decl, File, Line,
Name, Elements,
212 getImportTrackingVector(Context));
217 std::optional<StringRef> Source) {
218 return DIFile::get(VMContext, Filename, Directory, CS, Source);
224 assert(!
Name.empty() &&
"Unable to create macro without name");
227 "Unexpected macro type");
229 AllMacrosPerParent[Parent].insert(M);
234 unsigned LineNumber,
DIFile *File) {
236 LineNumber, File, DIMacroNodeArray())
238 AllMacrosPerParent[Parent].insert(MF);
242 AllMacrosPerParent.insert({MF, {}});
248 assert(!
Name.empty() &&
"Unable to create enumerator without name");
254 assert(!
Name.empty() &&
"Unable to create enumerator without name");
259 assert(!
Name.empty() &&
"Unable to create type without name");
270 assert(!
Name.empty() &&
"Unable to create type without name");
276 assert(!
Name.empty() &&
"Unable to create type without name");
284 assert(!
Name.empty() &&
"Unable to create type without name");
286 StringLength,
nullptr, StrLocationExp, 0, 0, 0);
292 assert(!
Name.empty() &&
"Unable to create type without name");
294 StringLengthExp, StrLocationExp, 0, 0, 0);
299 0, 0, std::nullopt, std::nullopt, DINode::FlagZero);
303 DIType *FromTy,
unsigned Key,
bool IsAddressDiscriminated,
304 unsigned ExtraDiscriminator,
bool IsaPointer,
305 bool AuthenticatesNullValues) {
307 nullptr, 0,
nullptr, FromTy, 0, 0, 0, std::nullopt,
308 std::optional<DIDerivedType::PtrAuthData>(
309 std::in_place, Key, IsAddressDiscriminated,
310 ExtraDiscriminator, IsaPointer,
311 AuthenticatesNullValues),
318 std::optional<unsigned> DWARFAddressSpace,
322 nullptr, 0,
nullptr, PointeeTy, SizeInBits,
323 AlignInBits, 0, DWARFAddressSpace, std::nullopt,
333 nullptr, 0,
nullptr, PointeeTy, SizeInBits,
334 AlignInBits, 0, std::nullopt, std::nullopt, Flags,
341 std::optional<unsigned> DWARFAddressSpace) {
342 assert(RTy &&
"Unable to create reference type");
344 SizeInBits, AlignInBits, 0, DWARFAddressSpace, {},
349 DIFile *File,
unsigned LineNo,
355 AlignInBits, 0, std::nullopt, std::nullopt, Flags,
361 unsigned LineNo,
DIScope *Context,
362 DINodeArray TParams,
uint32_t AlignInBits,
366 AlignInBits, 0, std::nullopt, std::nullopt, Flags,
371 assert(Ty &&
"Invalid type!");
372 assert(FriendTy &&
"Invalid friend type!");
374 FriendTy, 0, 0, 0, std::nullopt, std::nullopt,
382 assert(Ty &&
"Unable to create inheritance");
386 0, Ty,
BaseTy, 0, 0, BaseOffset, std::nullopt,
387 std::nullopt, Flags, ExtraData);
396 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
411 VMContext, dwarf::DW_TAG_member,
Name, File, LineNumber,
420 Flags |= DINode::FlagBitField;
422 VMContext, dwarf::DW_TAG_member,
Name, File, LineNumber,
424 OffsetInBits, std::nullopt, std::nullopt, Flags,
426 StorageOffsetInBits)),
432 unsigned LineNumber,
DIType *Ty,
435 Flags |= DINode::FlagStaticMember;
438 0, std::nullopt, std::nullopt, Flags,
449 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
450 std::nullopt, Flags, PropertyNode);
456 unsigned PropertyAttributes,
DIType *Ty) {
458 SetterName, PropertyAttributes, Ty);
463 DIType *Ty,
bool isDefault) {
464 assert((!Context || isa<DICompileUnit>(Context)) &&
"Expected compile unit");
472 assert((!Context || isa<DICompileUnit>(Context)) &&
"Expected compile unit");
478 DIType *Ty,
bool isDefault,
481 VMContext, dwarf::DW_TAG_template_value_parameter, Context,
Name, Ty,
490 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context,
Name, Ty,
496 DIType *Ty, DINodeArray Val) {
498 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context,
Name, Ty,
506 unsigned RunTimeLang,
DIType *VTableHolder,
MDNode *TemplateParams,
508 assert((!Context || isa<DIScope>(Context)) &&
509 "createClassType should be called with a valid Context");
512 VMContext, dwarf::DW_TAG_class_type,
Name, File, LineNumber,
514 OffsetInBits, Flags, Elements, RunTimeLang, VTableHolder,
515 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
516 trackIfUnresolved(R);
523 DIType *DerivedFrom, DINodeArray Elements,
unsigned RunTimeLang,
526 VMContext, dwarf::DW_TAG_structure_type,
Name, File, LineNumber,
528 Flags, Elements, RunTimeLang, VTableHolder,
nullptr, UniqueIdentifier);
529 trackIfUnresolved(R);
536 DINodeArray Elements,
unsigned RunTimeLang,
StringRef UniqueIdentifier) {
538 VMContext, dwarf::DW_TAG_union_type,
Name, File, LineNumber,
540 Elements, RunTimeLang,
nullptr,
nullptr, UniqueIdentifier);
541 trackIfUnresolved(R);
547 unsigned LineNumber,
uint64_t SizeInBits,
552 VMContext, dwarf::DW_TAG_variant_part,
Name, File, LineNumber,
554 Elements, 0,
nullptr,
nullptr, UniqueIdentifier, Discriminator);
555 trackIfUnresolved(R);
567 unsigned LineNumber,
uint64_t SizeInBits,
568 uint32_t AlignInBits, DINodeArray Elements,
569 DIType *UnderlyingType,
unsigned RunTimeLang,
570 StringRef UniqueIdentifier,
bool IsScoped) {
572 VMContext, dwarf::DW_TAG_enumeration_type,
Name, File, LineNumber,
574 IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements,
575 RunTimeLang,
nullptr,
nullptr, UniqueIdentifier);
576 AllEnumTypes.emplace_back(CTy);
577 trackIfUnresolved(CTy);
582 DIFile *File,
unsigned LineNo,
587 SizeInBits, AlignInBits, 0, std::nullopt,
588 std::nullopt, DINode::FlagZero);
589 trackIfUnresolved(R);
595 DINodeArray Subscripts,
601 VMContext, dwarf::DW_TAG_array_type,
"",
nullptr, 0,
nullptr, Ty,
Size,
602 AlignInBits, 0, DINode::FlagZero, Subscripts, 0,
nullptr,
nullptr,
"",
604 isa<DIExpression *>(
DL) ? (
Metadata *)cast<DIExpression *>(
DL)
606 isa<DIExpression *>(AS) ? (
Metadata *)cast<DIExpression *>(AS)
607 : (
Metadata *)cast<DIVariable *>(AS),
608 isa<DIExpression *>(AL) ? (
Metadata *)cast<DIExpression *>(AL)
609 : (
Metadata *)cast<DIVariable *>(AL),
610 isa<DIExpression *>(RK) ? (
Metadata *)cast<DIExpression *>(RK)
611 : (
Metadata *)cast<DIVariable *>(RK));
612 trackIfUnresolved(R);
618 DINodeArray Subscripts) {
620 nullptr, 0,
nullptr, Ty,
Size, AlignInBits, 0,
621 DINode::FlagVector, Subscripts, 0,
nullptr);
622 trackIfUnresolved(R);
627 auto NewSP = SP->cloneWithFlags(SP->getFlags() | DINode::FlagArtificial);
648 DINode::DIFlags Flags = DINode::FlagObjectPointer | DINode::FlagArtificial;
653 assert(
T &&
"Expected non-null type");
654 assert((isa<DIType>(
T) || (isa<DISubprogram>(
T) &&
655 cast<DISubprogram>(
T)->isDefinition() ==
false)) &&
656 "Expected type or subprogram declaration");
657 AllRetainTypes.emplace_back(
T);
664 DIFile *
F,
unsigned Line,
unsigned RuntimeLang,
671 SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl,
nullptr, RuntimeLang,
672 nullptr,
nullptr, UniqueIdentifier);
673 trackIfUnresolved(
RetTy);
685 SizeInBits, AlignInBits, 0, Flags,
nullptr, RuntimeLang,
nullptr,
686 nullptr, UniqueIdentifier,
nullptr,
nullptr,
nullptr,
nullptr,
689 trackIfUnresolved(
RetTy);
705 if (isa_and_nonnull<MDNode>(E))
736 return isa<DIExpression *>(Bound) ? (
Metadata *)cast<DIExpression *>(Bound)
737 : (
Metadata *)cast<DIVariable *>(Bound);
740 ConvToMetadata(LB), ConvToMetadata(UB),
741 ConvToMetadata(Stride));
748 assert(CT->getIdentifier().empty() &&
749 "Context of a global variable should not be a type with identifier");
755 unsigned LineNumber,
DIType *Ty,
bool IsLocalToUnit,
bool isDefined,
762 LineNumber, Ty, IsLocalToUnit, isDefined,
763 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
774 unsigned LineNumber,
DIType *Ty,
bool IsLocalToUnit,
MDNode *Decl,
780 LineNumber, Ty, IsLocalToUnit,
false,
781 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
794 auto *Scope = cast<DILocalScope>(Context);
797 if (AlwaysPreserve) {
807 DIFile *File,
unsigned LineNo,
808 DIType *Ty,
bool AlwaysPreserve,
811 assert(Scope && isa<DILocalScope>(Scope) &&
812 "Unexpected scope for a local variable.");
814 VMContext, getSubprogramNodesTrackingVector(Scope), Scope,
Name,
815 0, File, LineNo, Ty, AlwaysPreserve, Flags, AlignInBits);
822 assert(ArgNo &&
"Expected non-zero argument number for parameter");
823 assert(Scope && isa<DILocalScope>(Scope) &&
824 "Unexpected scope for a local variable.");
826 VMContext, getSubprogramNodesTrackingVector(Scope), Scope,
Name, ArgNo,
827 File, LineNo, Ty, AlwaysPreserve, Flags, 0,
Annotations);
831 unsigned LineNo,
bool AlwaysPreserve) {
832 auto *Scope = cast<DILocalScope>(Context);
835 if (AlwaysPreserve) {
839 getSubprogramNodesTrackingVector(Scope).emplace_back(Node);
848template <
class... Ts>
862 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
865 Name,
LinkageName, File, LineNo, Ty, ScopeLine,
nullptr, 0, 0, Flags,
866 SPFlags, IsDefinition ? CUNode :
nullptr, TParams, Decl,
nullptr,
870 AllSubprograms.push_back(Node);
871 trackIfUnresolved(Node);
880 DITypeArray ThrownTypes) {
881 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
884 ScopeLine,
nullptr, 0, 0, Flags, SPFlags,
885 IsDefinition ? CUNode :
nullptr, TParams,
886 Decl,
nullptr, ThrownTypes)
895 DITypeArray ThrownTypes) {
897 "Methods should have both a Context and a context that isn't "
898 "the compile unit.");
900 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
902 IsDefinition, VMContext, cast<DIScope>(Context),
Name,
903 LinkageName,
F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
904 Flags, SPFlags, IsDefinition ? CUNode :
nullptr, TParams,
nullptr,
905 nullptr, ThrownTypes);
908 AllSubprograms.push_back(SP);
909 trackIfUnresolved(SP);
921 bool ExportSymbols) {
935 DIFile *File,
unsigned LineNo,
bool IsDecl) {
937 ConfigurationMacros, IncludePath, APINotesFile, LineNo,
943 unsigned Discriminator) {
948 unsigned Line,
unsigned Col) {
958 return insertDeclare(Storage, VarInfo, Expr,
DL, InsertBefore->
getParent(),
968 return insertDeclare(Storage, VarInfo, Expr,
DL, InsertAtEnd, InsertBefore);
976 auto *Link = cast_or_null<DIAssignID>(
977 LinkedInstr->
getMetadata(LLVMContext::MD_DIAssignID));
978 assert(Link &&
"Linked instruction must have DIAssign metadata attached");
982 Val, SrcVar, ValExpr, Link,
Addr, AddrExpr,
DL);
986 Instruction *InsertBefore = NextIt == InsertBB->
end() ? nullptr : &*NextIt;
987 insertDbgVariableRecord(DVR, InsertBB, InsertBefore,
true);
996 std::array<Value *, 6> Args = {
1006 B.SetCurrentDebugLocation(
DL);
1008 auto *DVI = cast<DbgAssignIntrinsic>(
B.CreateCall(AssignFn, Args));
1009 DVI->insertAfter(LinkedInstr);
1015 return insertLabel(LabelInfo,
DL,
1016 InsertBefore ? InsertBefore->
getParent() :
nullptr,
1022 return insertLabel(LabelInfo,
DL, InsertAtEnd,
nullptr);
1031 V, VarInfo, Expr,
DL, InsertBefore ? InsertBefore->
getParent() :
nullptr,
1043 return insertDbgValueIntrinsic(V, VarInfo, Expr,
DL, InsertAtEnd,
nullptr);
1058 assert(V &&
"no value passed to dbg intrinsic");
1066DbgInstPtr DIBuilder::insertDbgValueIntrinsic(
1072 insertDbgVariableRecord(DVR, InsertBB, InsertBefore);
1078 return insertDbgIntrinsic(ValueFn, Val, VarInfo, Expr,
DL, InsertBB,
1086 assert(VarInfo &&
"empty or invalid DILocalVariable* passed to dbg.declare");
1087 assert(
DL &&
"Expected debug loc");
1088 assert(
DL->getScope()->getSubprogram() ==
1090 "Expected matching subprograms");
1095 insertDbgVariableRecord(DVR, InsertBB, InsertBefore);
1102 trackIfUnresolved(VarInfo);
1103 trackIfUnresolved(Expr);
1110 return B.CreateCall(DeclareFn, Args);
1116 bool InsertAtHead) {
1117 assert(InsertBefore || InsertBB);
1124 if (InsertBB && InsertBefore)
1127 InsertPt = InsertBB->
end();
1128 InsertPt.setHeadBit(InsertAtHead);
1138 assert(IntrinsicFn &&
"must pass a non-null intrinsic function");
1139 assert(V &&
"must pass a value to a dbg intrinsic");
1141 "empty or invalid DILocalVariable* passed to debug intrinsic");
1142 assert(
DL &&
"Expected debug loc");
1143 assert(
DL->getScope()->getSubprogram() ==
1145 "Expected matching subprograms");
1147 trackIfUnresolved(VarInfo);
1148 trackIfUnresolved(Expr);
1155 return B.CreateCall(IntrinsicFn, Args);
1161 assert(LabelInfo &&
"empty or invalid DILabel* passed to dbg.label");
1162 assert(
DL &&
"Expected debug loc");
1163 assert(
DL->getScope()->getSubprogram() ==
1165 "Expected matching subprograms");
1167 trackIfUnresolved(LabelInfo);
1170 if (InsertBB && InsertBefore)
1184 return B.CreateCall(LabelFn, Args);
1190 N->replaceVTableHolder(VTableHolder);
1195 if (
T != VTableHolder)
1200 if (
T->isResolved())
1202 if (
auto *
N = dyn_cast_or_null<MDNode>(O))
1203 trackIfUnresolved(
N);
1207 DINodeArray TParams) {
1211 N->replaceElements(Elements);
1213 N->replaceTemplateParams(DITemplateParameterArray(TParams));
1218 if (!
T->isResolved())
1225 trackIfUnresolved(Elements.get());
1227 trackIfUnresolved(TParams.get());
This file implements a class to represent arbitrary precision integral constant values and operations...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
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)
static Function * getDeclareIntrin(Module &M)
static DIType * createTypeWithFlags(const DIType *Ty, DINode::DIFlags FlagsToSet)
static DIScope * getNonCompileUnitScope(DIScope *N)
If N is compile unit return NULL otherwise return N.
static void checkGlobalVariableScope(DIScope *Context)
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
static ConstantAsMetadata * getConstantOrNull(Constant *C)
static DITemplateValueParameter * createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag, DIScope *Context, StringRef Name, DIType *Ty, bool IsDefault, Metadata *MD)
static Value * getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V)
static void initIRBuilder(IRBuilder<> &Builder, const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore)
Initialize IRBuilder for inserting dbg.declare and dbg.value intrinsics.
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, DINodeArray Elements, SmallVectorImpl< TrackingMDNodeRef > &ImportedModules)
This file contains constants used for implementing Dwarf debug support.
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Class for arbitrary precision integers.
An arbitrary precision integer that knows its signedness.
Annotations lets you mark points and ranges inside source code, for tests:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
void insertDbgRecordBefore(DbgRecord *DR, InstListType::iterator Here)
Insert a DbgRecord into a block at the position given by Here.
InstListType::iterator iterator
Instruction iterators...
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...
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
This is an important base class in LLVM.
Basic type, like 'int' or 'float'.
DIBasicType * createUnspecifiedParameter()
Create unspecified parameter type for a subroutine type.
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...
DITemplateValueParameter * createTemplateTemplateParameter(DIScope *Scope, StringRef Name, DIType *Ty, StringRef Val, bool IsDefault=false)
Create debugging information for a template template parameter.
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.
NodeTy * replaceTemporary(TempMDNode &&N, NodeTy *Replacement)
Replace a temporary node.
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.
void finalize()
Construct any deferred debug info descriptors.
DISubroutineType * createSubroutineType(DITypeRefArray ParameterTypes, DINode::DIFlags Flags=DINode::FlagZero, unsigned CC=0)
Create subroutine type.
DIMacro * createMacro(DIMacroFile *Parent, unsigned Line, unsigned MacroType, StringRef Name, StringRef Value=StringRef())
Create debugging information entry for a macro.
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.
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.
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.
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.
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.
DILexicalBlockFile * createLexicalBlockFile(DIScope *Scope, DIFile *File, unsigned Discriminator=0)
This creates a descriptor for a lexical block with a new file attached.
void finalizeSubprogram(DISubprogram *SP)
Finalize a specific subprogram - no new variables may be added to this subprogram afterwards.
DIDerivedType * createQualifiedType(unsigned Tag, DIType *FromTy)
Create debugging information entry for a qualified type, e.g.
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...
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.
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.
static DIType * createArtificialType(DIType *Ty)
Create a uniqued clone of Ty with FlagArtificial set.
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="")
Create debugging information entry for a struct.
DICompositeType * createVectorType(uint64_t Size, uint32_t AlignInBits, DIType *Ty, DINodeArray Subscripts)
Create debugging information entry for a vector type.
static DIType * createObjectPointerType(DIType *Ty)
Create a uniqued clone of Ty with FlagObjectPointer and FlagArtificial set.
DILabel * createLabel(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, bool AlwaysPreserve=false)
Create a new descriptor for an label.
DINamespace * createNameSpace(DIScope *Scope, StringRef Name, bool ExportSymbols)
This creates new descriptor for a namespace with the specified parent scope.
DIStringType * createStringType(StringRef Name, uint64_t SizeInBits)
Create debugging information entry for a string type.
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.
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.
DILexicalBlock * createLexicalBlock(DIScope *Scope, DIFile *File, unsigned Line, unsigned Col)
This creates a descriptor for a lexical block with the specified parent context.
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.
DIMacroNodeArray getOrCreateMacroArray(ArrayRef< Metadata * > Elements)
Get a DIMacroNodeArray, create one if required.
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.
void replaceVTableHolder(DICompositeType *&T, DIType *VTableHolder)
Replace the vtable holder in the given type.
DIBasicType * createNullPtrType()
Create C++11 nullptr type.
DICommonBlock * createCommonBlock(DIScope *Scope, DIGlobalVariable *decl, StringRef Name, DIFile *File, unsigned LineNo)
Create common block entry for a Fortran common block.
DIDerivedType * createFriend(DIType *Ty, DIType *FriendTy)
Create debugging information entry for a 'friend'.
void retainType(DIScope *T)
Retain DIScope* in a module even if it is not referenced through debug info anchors.
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.
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.
DIExpression * createExpression(ArrayRef< uint64_t > Addr=std::nullopt)
Create a new descriptor for the specified variable which has a complex address expression for its add...
DITemplateValueParameter * createTemplateParameterPack(DIScope *Scope, StringRef Name, DIType *Ty, DINodeArray Val)
Create debugging information for a template parameter pack.
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.
DISubrange * getOrCreateSubrange(int64_t Lo, int64_t Count)
Create a descriptor for a value range.
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.
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.
DIMacroFile * createTempMacroFile(DIMacroFile *Parent, unsigned Line, DIFile *File)
Create debugging information temporary entry for a macro file.
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.
DIBasicType * createBasicType(StringRef Name, uint64_t SizeInBits, unsigned Encoding, DINode::DIFlags Flags=DINode::FlagZero)
Create debugging information entry for a basic type.
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.
DITypeRefArray getOrCreateTypeArray(ArrayRef< Metadata * > Elements)
Get a DITypeRefArray, create one if required.
DINodeArray getOrCreateArray(ArrayRef< Metadata * > Elements)
Get a DINodeArray, create one if required.
DIEnumerator * createEnumerator(StringRef Name, const APSInt &Value)
Create a single enumerator value.
DITemplateTypeParameter * createTemplateTypeParameter(DIScope *Scope, StringRef Name, DIType *Ty, bool IsDefault)
Create debugging information for template type parameter.
DIBuilder(Module &M, bool AllowUnresolved=true, DICompileUnit *CU=nullptr)
Construct a builder for a module.
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.
DIDerivedType * createPtrAuthQualifiedType(DIType *FromTy, unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, bool IsaPointer, bool authenticatesNullValues)
Create a __ptrauth qualifier.
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.
DIImportedEntity * createImportedModule(DIScope *Context, DINamespace *NS, DIFile *File, unsigned Line, DINodeArray Elements=nullptr)
Create a descriptor for an imported module.
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.
DIImportedEntity * createImportedDeclaration(DIScope *Context, DINode *Decl, DIFile *File, unsigned Line, StringRef Name="", DINodeArray Elements=nullptr)
Create a descriptor for an imported function.
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.
static DISubprogram * createArtificialSubprogram(DISubprogram *SP)
Create a distinct clone of SP with FlagArtificial set.
DIGenericSubrange * getOrCreateGenericSubrange(DIGenericSubrange::BoundType Count, DIGenericSubrange::BoundType LowerBound, DIGenericSubrange::BoundType UpperBound, DIGenericSubrange::BoundType Stride)
DIBasicType * createUnspecifiedType(StringRef Name)
Create a DWARF unspecified type.
DIObjCProperty * createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber, StringRef GetterName, StringRef SetterName, unsigned PropertyAttributes, DIType *Ty)
Create debugging information entry for Objective-C property.
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.
DITemplateValueParameter * createTemplateValueParameter(DIScope *Scope, StringRef Name, DIType *Ty, bool IsDefault, Constant *Val)
Create debugging information for template value parameter.
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.
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.
void replaceArrays(DICompositeType *&T, DINodeArray Elements, DINodeArray TParams=DINodeArray())
Replace arrays on a composite type.
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.
DICompositeTypeArray getEnumTypes() const
void replaceEnumTypes(DICompositeTypeArray N)
Replace arrays.
DIMacroNodeArray getMacros() const
void replaceRetainedTypes(DITypeArray N)
void replaceGlobalVariables(DIGlobalVariableExpressionArray N)
void replaceMacros(DIMacroNodeArray N)
DIImportedEntityArray getImportedEntities() const
DIScopeArray getRetainedTypes() const
void replaceImportedEntities(DIImportedEntityArray N)
DIGlobalVariableExpressionArray getGlobalVariables() const
A pair of DIGlobalVariable and DIExpression.
An imported module (C++ using directive or similar).
DILocalScope * getScope() const
Get the local scope for this label.
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
DILocalScope * getScope() const
Get the local scope for this variable.
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Tagged DWARF-like metadata node.
Base class for scope-like contexts.
String type, Fortran CHARACTER(n)
DISPFlags
Debug info subprogram flags.
Type array for a subprogram.
TempDIType cloneWithFlags(DIFlags NewFlags) const
Returns a new temporary DIType with updated Flags.
bool isObjectPointer() const
bool isArtificial() const
Base class for variables.
Records a position in IR for a source label (DILabel).
Record of a variable value-assignment, aka a non instruction representation of the dbg....
static DbgVariableRecord * createDbgVariableRecord(Value *Location, DILocalVariable *DV, DIExpression *Expr, const DILocation *DI)
static DbgVariableRecord * createDVRDeclare(Value *Address, DILocalVariable *DV, DIExpression *Expr, const DILocation *DI)
DIExpression * getExpression() const
DILocalVariable * getVariable() const
static DbgVariableRecord * createDVRAssign(Value *Val, DILocalVariable *Variable, DIExpression *Expression, DIAssignID *AssignID, Value *Address, DIExpression *AddressExpression, const DILocation *DI)
DIExpression * getAddressExpression() const
void SetCurrentDebugLocation(DebugLoc L)
Set location information used by debugging information.
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
This is an important class for using LLVM in a threaded context.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
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.
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.
Tracking metadata reference owned by Metadata.
static MDString * get(LLVMContext &Context, StringRef Str)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
A Module instance is used to store all the information related to an LLVM module.
bool IsNewDbgInfoFormat
Is this Module using intrinsics to record the position of debugging information, or non-intrinsic rec...
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
void addOperand(MDNode *M)
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
T get() const
Returns the value of the specified pointer type.
bool is() const
Test if the Union currently holds the type matching T.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
static IntegerType * getInt64Ty(LLVMContext &C)
LLVM Value Representation.
LLVMContext & getContext() const
All values hold a context through their type.
const ParentTy * getParent() const
self_iterator getIterator()
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Calculates the starting offsets for various sections within the .debug_names section.
This is an optimization pass for GlobalISel generic memory operations.
A single checksum, represented by a Kind and a Value (a string).