27 : M(m), VMContext(M.getContext()), CUNode(
CU), DeclareFn(nullptr),
28 ValueFn(nullptr), LabelFn(nullptr), AssignFn(nullptr),
29 AllowUnresolvedNodes(AllowUnresolvedNodes) {
32 AllEnumTypes.assign(ETs.begin(), ETs.end());
34 AllRetainTypes.assign(RTs.begin(), RTs.end());
36 AllGVs.assign(GVs.begin(), GVs.end());
38 AllImportedModules.assign(IMs.begin(), IMs.end());
39 if (
const auto &MNs = CUNode->
getMacros())
40 AllMacrosPerParent.insert({
nullptr, {MNs.begin(), MNs.end()}});
44void DIBuilder::trackIfUnresolved(
MDNode *
N) {
50 assert(AllowUnresolvedNodes &&
"Cannot handle unresolved nodes");
51 UnresolvedNodes.emplace_back(
N);
61 auto PV = PreservedVariables.find(SP);
62 if (PV != PreservedVariables.end())
63 RetainedNodes.
append(PV->second.begin(), PV->second.end());
65 auto PL = PreservedLabels.find(SP);
66 if (PL != PreservedLabels.end())
67 RetainedNodes.
append(PL->second.begin(), PL->second.end());
71 TempMDTuple(Temp)->replaceAllUsesWith(Node.get());
76 assert(!AllowUnresolvedNodes &&
77 "creating type nodes without a CU is not supported");
81 if (!AllEnumTypes.empty())
84 AllEnumTypes.end())));
92 for (
unsigned I = 0,
E = AllRetainTypes.size();
I <
E;
I++)
93 if (RetainSet.
insert(AllRetainTypes[
I]).second)
96 if (!RetainValues.
empty())
99 for (
auto *SP : AllSubprograms)
101 for (
auto *
N : RetainValues)
102 if (
auto *SP = dyn_cast<DISubprogram>(
N))
108 if (!AllImportedModules.empty())
111 AllImportedModules.end())));
113 for (
const auto &
I : AllMacrosPerParent) {
120 auto *TMF = cast<DIMacroFile>(
I.first);
122 TMF->getLine(), TMF->getFile(),
129 for (
const auto &
N : UnresolvedNodes)
130 if (
N && !
N->isResolved())
132 UnresolvedNodes.clear();
135 AllowUnresolvedNodes =
false;
140 if (!
N || isa<DICompileUnit>(
N))
142 return cast<DIScope>(
N);
149 bool SplitDebugInlining,
bool DebugInfoForProfiling,
153 assert(((Lang <= dwarf::DW_LANG_Ada2012 && Lang >= dwarf::DW_LANG_C89) ||
155 "Invalid Language tag");
157 assert(!CUNode &&
"Can only make one compile unit per DIBuilder instance");
159 VMContext, Lang, File, Producer, isOptimized,
Flags, RunTimeVer,
160 SplitName, Kind,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr, DWOId,
161 SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
162 RangesBaseAddress, SysRoot, SDK);
167 trackIfUnresolved(CUNode);
174 DINodeArray Elements,
177 assert(File &&
"Source location has line number but no file");
178 unsigned EntitiesCount =
C.pImpl->DIImportedEntitys.size();
180 File, Line,
Name, Elements);
181 if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
191 DINodeArray Elements) {
192 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
199 DIFile *File,
unsigned Line,
200 DINodeArray Elements) {
201 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
207 DIFile *File,
unsigned Line,
208 DINodeArray Elements) {
209 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
216 DIFile *File,
unsigned Line,
220 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
227 std::optional<StringRef> Source) {
228 return DIFile::get(VMContext, Filename, Directory, CS, Source);
234 assert(!
Name.empty() &&
"Unable to create macro without name");
237 "Unexpected macro type");
239 AllMacrosPerParent[Parent].insert(M);
244 unsigned LineNumber,
DIFile *File) {
246 LineNumber, File, DIMacroNodeArray())
248 AllMacrosPerParent[Parent].insert(MF);
252 AllMacrosPerParent.insert({MF, {}});
258 assert(!
Name.empty() &&
"Unable to create enumerator without name");
264 assert(!
Name.empty() &&
"Unable to create enumerator without name");
269 assert(!
Name.empty() &&
"Unable to create type without name");
280 assert(!
Name.empty() &&
"Unable to create type without name");
286 assert(!
Name.empty() &&
"Unable to create type without name");
294 assert(!
Name.empty() &&
"Unable to create type without name");
296 StringLength,
nullptr, StrLocationExp, 0, 0, 0);
302 assert(!
Name.empty() &&
"Unable to create type without name");
304 StringLengthExp, StrLocationExp, 0, 0, 0);
309 0, 0, std::nullopt, DINode::FlagZero);
315 std::optional<unsigned> DWARFAddressSpace,
319 nullptr, 0,
nullptr, PointeeTy, SizeInBits,
320 AlignInBits, 0, DWARFAddressSpace, DINode::FlagZero,
330 nullptr, 0,
nullptr, PointeeTy, SizeInBits,
331 AlignInBits, 0, std::nullopt,
Flags,
Base);
337 std::optional<unsigned> DWARFAddressSpace) {
338 assert(RTy &&
"Unable to create reference type");
340 SizeInBits, AlignInBits, 0, DWARFAddressSpace,
345 DIFile *File,
unsigned LineNo,
351 AlignInBits, 0, std::nullopt,
Flags,
nullptr,
356 assert(Ty &&
"Invalid type!");
357 assert(FriendTy &&
"Invalid friend type!");
359 FriendTy, 0, 0, 0, std::nullopt, DINode::FlagZero);
366 assert(Ty &&
"Unable to create inheritance");
370 0, Ty,
BaseTy, 0, 0, BaseOffset, std::nullopt,
380 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
396 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
404 Flags |= DINode::FlagBitField;
406 VMContext, dwarf::DW_TAG_member,
Name, File, LineNumber,
408 OffsetInBits, std::nullopt,
Flags,
410 StorageOffsetInBits)),
416 unsigned LineNumber,
DIType *Ty,
419 Flags |= DINode::FlagStaticMember;
422 AlignInBits, 0, std::nullopt,
Flags,
433 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
434 Flags, PropertyNode);
440 unsigned PropertyAttributes,
DIType *Ty) {
442 SetterName, PropertyAttributes, Ty);
447 DIType *Ty,
bool isDefault) {
462 DIType *Ty,
bool isDefault,
465 VMContext, dwarf::DW_TAG_template_value_parameter,
Context,
Name, Ty,
474 VMContext, dwarf::DW_TAG_GNU_template_template_param,
Context,
Name, Ty,
480 DIType *Ty, DINodeArray Val) {
482 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack,
Context,
Name, Ty,
492 "createClassType should be called with a valid Context");
495 VMContext, dwarf::DW_TAG_structure_type,
Name, File, LineNumber,
497 OffsetInBits,
Flags, Elements, 0, VTableHolder,
498 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
499 trackIfUnresolved(R);
506 DIType *DerivedFrom, DINodeArray Elements,
unsigned RunTimeLang,
509 VMContext, dwarf::DW_TAG_structure_type,
Name, File, LineNumber,
511 Flags, Elements, RunTimeLang, VTableHolder,
nullptr, UniqueIdentifier);
512 trackIfUnresolved(R);
519 DINodeArray Elements,
unsigned RunTimeLang,
StringRef UniqueIdentifier) {
521 VMContext, dwarf::DW_TAG_union_type,
Name, File, LineNumber,
523 Elements, RunTimeLang,
nullptr,
nullptr, UniqueIdentifier);
524 trackIfUnresolved(R);
530 unsigned LineNumber,
uint64_t SizeInBits,
535 VMContext, dwarf::DW_TAG_variant_part,
Name, File, LineNumber,
537 Elements, 0,
nullptr,
nullptr, UniqueIdentifier, Discriminator);
538 trackIfUnresolved(R);
553 VMContext, dwarf::DW_TAG_enumeration_type,
Name, File, LineNumber,
555 IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements, 0,
nullptr,
556 nullptr, UniqueIdentifier);
557 AllEnumTypes.emplace_back(CTy);
558 trackIfUnresolved(CTy);
563 DIFile *File,
unsigned LineNo,
569 AlignInBits, 0, std::nullopt, DINode::FlagZero);
570 trackIfUnresolved(R);
576 DINodeArray Subscripts,
582 VMContext, dwarf::DW_TAG_array_type,
"",
nullptr, 0,
nullptr, Ty,
Size,
583 AlignInBits, 0, DINode::FlagZero, Subscripts, 0,
nullptr,
nullptr,
"",
585 isa<DIExpression *>(
DL) ? (
Metadata *)cast<DIExpression *>(
DL)
587 isa<DIExpression *>(AS) ? (
Metadata *)cast<DIExpression *>(AS)
588 : (
Metadata *)cast<DIVariable *>(AS),
589 isa<DIExpression *>(AL) ? (
Metadata *)cast<DIExpression *>(AL)
590 : (
Metadata *)cast<DIVariable *>(AL),
591 isa<DIExpression *>(RK) ? (
Metadata *)cast<DIExpression *>(RK)
592 : (
Metadata *)cast<DIVariable *>(RK));
593 trackIfUnresolved(R);
599 DINodeArray Subscripts) {
601 nullptr, 0,
nullptr, Ty,
Size, AlignInBits, 0,
602 DINode::FlagVector, Subscripts, 0,
nullptr);
603 trackIfUnresolved(R);
608 auto NewSP = SP->cloneWithFlags(SP->getFlags() | DINode::FlagArtificial);
634 assert(
T &&
"Expected non-null type");
635 assert((isa<DIType>(
T) || (isa<DISubprogram>(
T) &&
636 cast<DISubprogram>(
T)->isDefinition() ==
false)) &&
637 "Expected type or subprogram declaration");
638 AllRetainTypes.emplace_back(
T);
645 DIFile *
F,
unsigned Line,
unsigned RuntimeLang,
652 SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl,
nullptr, RuntimeLang,
653 nullptr,
nullptr, UniqueIdentifier);
654 trackIfUnresolved(
RetTy);
666 SizeInBits, AlignInBits, 0,
Flags,
nullptr, RuntimeLang,
nullptr,
667 nullptr, UniqueIdentifier,
nullptr,
nullptr,
nullptr,
nullptr,
670 trackIfUnresolved(
RetTy);
686 if (isa_and_nonnull<MDNode>(
E))
717 return isa<DIExpression *>(Bound) ? (
Metadata *)cast<DIExpression *>(Bound)
718 : (
Metadata *)cast<DIVariable *>(Bound);
721 ConvToMetadata(LB), ConvToMetadata(UB),
722 ConvToMetadata(Stride));
729 assert(CT->getIdentifier().empty() &&
730 "Context of a global variable should not be a type with identifier");
736 unsigned LineNumber,
DIType *Ty,
bool IsLocalToUnit,
bool isDefined,
743 LineNumber, Ty, IsLocalToUnit, isDefined,
744 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
755 unsigned LineNumber,
DIType *Ty,
bool IsLocalToUnit,
MDNode *Decl,
761 LineNumber, Ty, IsLocalToUnit,
false,
762 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
780 VMContext, cast_or_null<DILocalScope>(
Context),
Name, File, LineNo, Ty,
782 if (AlwaysPreserve) {
787 assert(Fn &&
"Missing subprogram for local variable");
788 PreservedVariables[Fn].emplace_back(
Node);
794 DIFile *File,
unsigned LineNo,
795 DIType *Ty,
bool AlwaysPreserve,
799 0, File, LineNo, Ty, AlwaysPreserve,
807 assert(ArgNo &&
"Expected non-zero argument number for parameter");
809 File, LineNo, Ty, AlwaysPreserve,
Flags,
814 unsigned LineNo,
bool AlwaysPreserve) {
820 if (AlwaysPreserve) {
825 assert(Fn &&
"Missing subprogram for label");
826 PreservedLabels[Fn].emplace_back(Node);
835template <
class... Ts>
849 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
852 Name,
LinkageName, File, LineNo, Ty, ScopeLine,
nullptr, 0, 0,
Flags,
853 SPFlags, IsDefinition ? CUNode :
nullptr, TParams, Decl,
858 AllSubprograms.push_back(Node);
859 trackIfUnresolved(Node);
868 DITypeArray ThrownTypes) {
869 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
872 ScopeLine,
nullptr, 0, 0,
Flags, SPFlags,
873 IsDefinition ? CUNode :
nullptr, TParams,
874 Decl,
nullptr, ThrownTypes)
883 DITypeArray ThrownTypes) {
885 "Methods should have both a Context and a context that isn't "
886 "the compile unit.");
888 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
890 IsDefinition, VMContext, cast<DIScope>(
Context),
Name,
891 LinkageName,
F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
892 Flags, SPFlags, IsDefinition ? CUNode :
nullptr, TParams,
nullptr,
893 nullptr, ThrownTypes);
896 AllSubprograms.push_back(SP);
897 trackIfUnresolved(SP);
909 bool ExportSymbols) {
923 DIFile *File,
unsigned LineNo,
bool IsDecl) {
925 ConfigurationMacros, IncludePath, APINotesFile, LineNo,
931 unsigned Discriminator) {
936 unsigned Line,
unsigned Col) {
946 return insertDeclare(Storage, VarInfo, Expr,
DL, InsertBefore->
getParent(),
956 return insertDeclare(Storage, VarInfo, Expr,
DL, InsertAtEnd, InsertBefore);
969 auto *Link = LinkedInstr->
getMetadata(LLVMContext::MD_DIAssignID);
970 assert(Link &&
"Linked instruction must have DIAssign metadata attached");
972 std::array<Value *, 6> Args = {
982 B.SetCurrentDebugLocation(
DL);
984 auto *DVI = cast<DbgAssignIntrinsic>(
B.CreateCall(AssignFn, Args));
985 DVI->insertAfter(LinkedInstr);
991 return insertLabel(LabelInfo,
DL,
992 InsertBefore ? InsertBefore->
getParent() :
nullptr,
998 return insertLabel(LabelInfo,
DL, InsertAtEnd,
nullptr);
1006 return insertDbgValueIntrinsic(
1007 V, VarInfo, Expr,
DL, InsertBefore ? InsertBefore->
getParent() :
nullptr,
1016 return insertDbgValueIntrinsic(V, VarInfo, Expr,
DL, InsertAtEnd,
nullptr);
1024 Builder.SetInsertPoint(InsertBefore);
1026 Builder.SetInsertPoint(InsertBB);
1031 assert(V &&
"no value passed to dbg intrinsic");
1044 return insertDbgIntrinsic(ValueFn, Val, VarInfo, Expr,
DL, InsertBB,
1052 assert(VarInfo &&
"empty or invalid DILocalVariable* passed to dbg.declare");
1053 assert(
DL &&
"Expected debug loc");
1054 assert(
DL->getScope()->getSubprogram() ==
1056 "Expected matching subprograms");
1060 trackIfUnresolved(VarInfo);
1061 trackIfUnresolved(Expr);
1068 return B.CreateCall(DeclareFn, Args);
1077 assert(IntrinsicFn &&
"must pass a non-null intrinsic function");
1078 assert(V &&
"must pass a value to a dbg intrinsic");
1080 "empty or invalid DILocalVariable* passed to debug intrinsic");
1081 assert(
DL &&
"Expected debug loc");
1082 assert(
DL->getScope()->getSubprogram() ==
1084 "Expected matching subprograms");
1086 trackIfUnresolved(VarInfo);
1087 trackIfUnresolved(Expr);
1094 return B.CreateCall(IntrinsicFn, Args);
1100 assert(LabelInfo &&
"empty or invalid DILabel* passed to dbg.label");
1101 assert(
DL &&
"Expected debug loc");
1102 assert(
DL->getScope()->getSubprogram() ==
1104 "Expected matching subprograms");
1108 trackIfUnresolved(LabelInfo);
1113 return B.CreateCall(LabelFn, Args);
1119 N->replaceVTableHolder(VTableHolder);
1124 if (
T != VTableHolder)
1129 if (
T->isResolved())
1131 if (
auto *
N = dyn_cast_or_null<MDNode>(O))
1132 trackIfUnresolved(
N);
1136 DINodeArray TParams) {
1140 N->replaceElements(Elements);
1142 N->replaceTemplateParams(DITemplateParameterArray(TParams));
1147 if (!
T->isResolved())
1154 trackIfUnresolved(Elements.get());
1156 trackIfUnresolved(TParams.get());
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static Function * getDeclareIntrin(Module &M)
static DIImportedEntity * createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, Metadata *NS, DIFile *File, unsigned Line, StringRef Name, DINodeArray Elements, SmallVectorImpl< TrackingMDNodeRef > &AllImportedModules)
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 DILocalVariable * createLocalVariable(LLVMContext &VMContext, DenseMap< MDNode *, SmallVector< TrackingMDNodeRef, 1 > > &PreservedVariables, DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags, uint32_t AlignInBits, DINodeArray Annotations=nullptr)
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.
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.
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 Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
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.
DbgAssignIntrinsic * insertDbgAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *SrcVar, DIExpression *ValExpr, Value *Addr, DIExpression *AddrExpr, const DILocation *DL)
Insert a new llvm.dbg.assign intrinsic call.
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 * 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.
DILexicalBlockFile * createLexicalBlockFile(DIScope *Scope, DIFile *File, unsigned Discriminator=0)
This creates a descriptor for a lexical block with a new file attached.
DIDerivedType * createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, DIType *Ty, DINode::DIFlags Flags, Constant *Val, uint32_t AlignInBits=0)
Create debugging information entry for a C++ static data member.
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.
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 * 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.
DICompositeType * createEnumerationType(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements, DIType *UnderlyingType, StringRef UniqueIdentifier="", bool IsScoped=false)
Create debugging information entry for an enumeration.
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.
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)
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, DIType *VTableHolder=nullptr, MDNode *TemplateParms=nullptr, StringRef UniqueIdentifier="")
Create debugging information entry for a class.
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.
This represents the llvm.dbg.assign instruction.
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...
const BasicBlock * getParent() const
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)
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
A Module instance is used to store all the information related to an LLVM module.
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...
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 append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
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.
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.
This is an optimization pass for GlobalISel generic memory operations.
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
A single checksum, represented by a Kind and a Value (a string).