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 DISubprogramArray SPs =
MDTuple::get(VMContext, AllSubprograms);
102 for (
auto *
N : RetainValues)
103 if (
auto *SP = dyn_cast<DISubprogram>(
N))
109 if (!AllImportedModules.empty())
112 AllImportedModules.end())));
114 for (
const auto &
I : AllMacrosPerParent) {
121 auto *TMF = cast<DIMacroFile>(
I.first);
123 TMF->getLine(), TMF->getFile(),
130 for (
const auto &
N : UnresolvedNodes)
131 if (
N && !
N->isResolved())
133 UnresolvedNodes.clear();
136 AllowUnresolvedNodes =
false;
141 if (!
N || isa<DICompileUnit>(
N))
143 return cast<DIScope>(
N);
150 bool SplitDebugInlining,
bool DebugInfoForProfiling,
154 assert(((Lang <= dwarf::DW_LANG_Ada2012 && Lang >= dwarf::DW_LANG_C89) ||
156 "Invalid Language tag");
158 assert(!CUNode &&
"Can only make one compile unit per DIBuilder instance");
160 VMContext, Lang, File, Producer, isOptimized,
Flags, RunTimeVer,
161 SplitName, Kind,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr, DWOId,
162 SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
163 RangesBaseAddress, SysRoot, SDK);
168 trackIfUnresolved(CUNode);
175 DINodeArray Elements,
178 assert(File &&
"Source location has line number but no file");
179 unsigned EntitiesCount =
C.pImpl->DIImportedEntitys.size();
181 File, Line,
Name, Elements);
182 if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
192 DINodeArray Elements) {
193 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
200 DIFile *File,
unsigned Line,
201 DINodeArray Elements) {
202 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
208 DIFile *File,
unsigned Line,
209 DINodeArray Elements) {
210 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
217 DIFile *File,
unsigned Line,
221 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
228 std::optional<StringRef> Source) {
229 return DIFile::get(VMContext, Filename, Directory, CS, Source);
235 assert(!
Name.empty() &&
"Unable to create macro without name");
238 "Unexpected macro type");
240 AllMacrosPerParent[Parent].insert(M);
245 unsigned LineNumber,
DIFile *File) {
247 LineNumber, File, DIMacroNodeArray())
249 AllMacrosPerParent[Parent].insert(MF);
253 AllMacrosPerParent.insert({MF, {}});
259 assert(!
Name.empty() &&
"Unable to create enumerator without name");
265 assert(!
Name.empty() &&
"Unable to create enumerator without name");
270 assert(!
Name.empty() &&
"Unable to create type without name");
281 assert(!
Name.empty() &&
"Unable to create type without name");
287 assert(!
Name.empty() &&
"Unable to create type without name");
295 assert(!
Name.empty() &&
"Unable to create type without name");
297 StringLength,
nullptr, StrLocationExp, 0, 0, 0);
303 assert(!
Name.empty() &&
"Unable to create type without name");
305 StringLengthExp, StrLocationExp, 0, 0, 0);
310 0, 0, std::nullopt, DINode::FlagZero);
316 std::optional<unsigned> DWARFAddressSpace,
320 nullptr, 0,
nullptr, PointeeTy, SizeInBits,
321 AlignInBits, 0, DWARFAddressSpace, DINode::FlagZero,
331 nullptr, 0,
nullptr, PointeeTy, SizeInBits,
332 AlignInBits, 0, std::nullopt,
Flags,
Base);
338 std::optional<unsigned> DWARFAddressSpace) {
339 assert(RTy &&
"Unable to create reference type");
341 SizeInBits, AlignInBits, 0, DWARFAddressSpace,
346 DIFile *File,
unsigned LineNo,
352 AlignInBits, 0, std::nullopt,
Flags,
nullptr,
357 assert(Ty &&
"Invalid type!");
358 assert(FriendTy &&
"Invalid friend type!");
360 FriendTy, 0, 0, 0, std::nullopt, DINode::FlagZero);
367 assert(Ty &&
"Unable to create inheritance");
371 0, Ty,
BaseTy, 0, 0, BaseOffset, std::nullopt,
381 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
397 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
405 Flags |= DINode::FlagBitField;
407 VMContext, dwarf::DW_TAG_member,
Name, File, LineNumber,
409 OffsetInBits, std::nullopt,
Flags,
411 StorageOffsetInBits)),
417 unsigned LineNumber,
DIType *Ty,
420 Flags |= DINode::FlagStaticMember;
423 AlignInBits, 0, std::nullopt,
Flags,
434 SizeInBits, AlignInBits, OffsetInBits, std::nullopt,
435 Flags, PropertyNode);
441 unsigned PropertyAttributes,
DIType *Ty) {
443 SetterName, PropertyAttributes, Ty);
448 DIType *Ty,
bool isDefault) {
463 DIType *Ty,
bool isDefault,
466 VMContext, dwarf::DW_TAG_template_value_parameter,
Context,
Name, Ty,
475 VMContext, dwarf::DW_TAG_GNU_template_template_param,
Context,
Name, Ty,
481 DIType *Ty, DINodeArray Val) {
483 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack,
Context,
Name, Ty,
493 "createClassType should be called with a valid Context");
496 VMContext, dwarf::DW_TAG_structure_type,
Name, File, LineNumber,
498 OffsetInBits,
Flags, Elements, 0, VTableHolder,
499 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
500 trackIfUnresolved(R);
507 DIType *DerivedFrom, DINodeArray Elements,
unsigned RunTimeLang,
510 VMContext, dwarf::DW_TAG_structure_type,
Name, File, LineNumber,
512 Flags, Elements, RunTimeLang, VTableHolder,
nullptr, UniqueIdentifier);
513 trackIfUnresolved(R);
520 DINodeArray Elements,
unsigned RunTimeLang,
StringRef UniqueIdentifier) {
522 VMContext, dwarf::DW_TAG_union_type,
Name, File, LineNumber,
524 Elements, RunTimeLang,
nullptr,
nullptr, UniqueIdentifier);
525 trackIfUnresolved(R);
531 unsigned LineNumber,
uint64_t SizeInBits,
536 VMContext, dwarf::DW_TAG_variant_part,
Name, File, LineNumber,
538 Elements, 0,
nullptr,
nullptr, UniqueIdentifier, Discriminator);
539 trackIfUnresolved(R);
554 VMContext, dwarf::DW_TAG_enumeration_type,
Name, File, LineNumber,
556 IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements, 0,
nullptr,
557 nullptr, UniqueIdentifier);
558 AllEnumTypes.emplace_back(CTy);
559 trackIfUnresolved(CTy);
564 DIFile *File,
unsigned LineNo,
570 AlignInBits, 0, std::nullopt, DINode::FlagZero);
571 trackIfUnresolved(R);
577 DINodeArray Subscripts,
583 VMContext, dwarf::DW_TAG_array_type,
"",
nullptr, 0,
nullptr, Ty,
Size,
584 AlignInBits, 0, DINode::FlagZero, Subscripts, 0,
nullptr,
nullptr,
"",
594 trackIfUnresolved(R);
600 DINodeArray Subscripts) {
602 nullptr, 0,
nullptr, Ty,
Size, AlignInBits, 0,
603 DINode::FlagVector, Subscripts, 0,
nullptr);
604 trackIfUnresolved(R);
609 auto NewSP = SP->cloneWithFlags(SP->getFlags() | DINode::FlagArtificial);
635 assert(
T &&
"Expected non-null type");
636 assert((isa<DIType>(
T) || (isa<DISubprogram>(
T) &&
637 cast<DISubprogram>(
T)->isDefinition() ==
false)) &&
638 "Expected type or subprogram declaration");
639 AllRetainTypes.emplace_back(
T);
646 DIFile *
F,
unsigned Line,
unsigned RuntimeLang,
653 SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl,
nullptr, RuntimeLang,
654 nullptr,
nullptr, UniqueIdentifier);
655 trackIfUnresolved(
RetTy);
667 SizeInBits, AlignInBits, 0,
Flags,
nullptr, RuntimeLang,
nullptr,
668 nullptr, UniqueIdentifier,
nullptr,
nullptr,
nullptr,
nullptr,
671 trackIfUnresolved(
RetTy);
687 if (isa_and_nonnull<MDNode>(
E))
722 ConvToMetadata(LB), ConvToMetadata(UB),
723 ConvToMetadata(Stride));
730 assert(CT->getIdentifier().empty() &&
731 "Context of a global variable should not be a type with identifier");
737 unsigned LineNumber,
DIType *Ty,
bool IsLocalToUnit,
bool isDefined,
744 LineNumber, Ty, IsLocalToUnit, isDefined,
745 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
756 unsigned LineNumber,
DIType *Ty,
bool IsLocalToUnit,
MDNode *Decl,
762 LineNumber, Ty, IsLocalToUnit,
false,
763 cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
781 VMContext, cast_or_null<DILocalScope>(
Context),
Name, File, LineNo, Ty,
783 if (AlwaysPreserve) {
788 assert(Fn &&
"Missing subprogram for local variable");
789 PreservedVariables[Fn].emplace_back(
Node);
795 DIFile *File,
unsigned LineNo,
796 DIType *Ty,
bool AlwaysPreserve,
800 0, File, LineNo, Ty, AlwaysPreserve,
808 assert(ArgNo &&
"Expected non-zero argument number for parameter");
810 File, LineNo, Ty, AlwaysPreserve,
Flags,
815 unsigned LineNo,
bool AlwaysPreserve) {
821 if (AlwaysPreserve) {
826 assert(Fn &&
"Missing subprogram for label");
827 PreservedLabels[Fn].emplace_back(Node);
836template <
class... Ts>
850 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
853 Name,
LinkageName, File, LineNo, Ty, ScopeLine,
nullptr, 0, 0,
Flags,
854 SPFlags, IsDefinition ? CUNode :
nullptr, TParams, Decl,
859 AllSubprograms.push_back(Node);
860 trackIfUnresolved(Node);
869 DITypeArray ThrownTypes) {
870 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
873 ScopeLine,
nullptr, 0, 0,
Flags, SPFlags,
874 IsDefinition ? CUNode :
nullptr, TParams,
875 Decl,
nullptr, ThrownTypes)
884 DITypeArray ThrownTypes) {
886 "Methods should have both a Context and a context that isn't "
887 "the compile unit.");
889 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
891 IsDefinition, VMContext, cast<DIScope>(
Context),
Name,
892 LinkageName,
F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
893 Flags, SPFlags, IsDefinition ? CUNode :
nullptr, TParams,
nullptr,
894 nullptr, ThrownTypes);
897 AllSubprograms.push_back(SP);
898 trackIfUnresolved(SP);
910 bool ExportSymbols) {
924 DIFile *File,
unsigned LineNo,
bool IsDecl) {
926 ConfigurationMacros, IncludePath, APINotesFile, LineNo,
932 unsigned Discriminator) {
937 unsigned Line,
unsigned Col) {
947 return insertDeclare(Storage, VarInfo, Expr,
DL, InsertBefore->
getParent(),
957 return insertDeclare(Storage, VarInfo, Expr,
DL, InsertAtEnd, InsertBefore);
970 auto *Link = LinkedInstr->
getMetadata(LLVMContext::MD_DIAssignID);
971 assert(Link &&
"Linked instruction must have DIAssign metadata attached");
973 std::array<Value *, 6> Args = {
983 B.SetCurrentDebugLocation(
DL);
985 auto *DVI = cast<DbgAssignIntrinsic>(
B.CreateCall(AssignFn, Args));
986 DVI->insertAfter(LinkedInstr);
992 return insertLabel(LabelInfo,
DL,
993 InsertBefore ? InsertBefore->
getParent() :
nullptr,
999 return insertLabel(LabelInfo,
DL, InsertAtEnd,
nullptr);
1007 return insertDbgValueIntrinsic(
1008 V, VarInfo, Expr,
DL, InsertBefore ? InsertBefore->
getParent() :
nullptr,
1017 return insertDbgValueIntrinsic(V, VarInfo, Expr,
DL, InsertAtEnd,
nullptr);
1025 Builder.SetInsertPoint(InsertBefore);
1027 Builder.SetInsertPoint(InsertBB);
1032 assert(V &&
"no value passed to dbg intrinsic");
1045 return insertDbgIntrinsic(ValueFn, Val, VarInfo, Expr,
DL, InsertBB,
1053 assert(VarInfo &&
"empty or invalid DILocalVariable* passed to dbg.declare");
1054 assert(
DL &&
"Expected debug loc");
1055 assert(
DL->getScope()->getSubprogram() ==
1057 "Expected matching subprograms");
1061 trackIfUnresolved(VarInfo);
1062 trackIfUnresolved(Expr);
1069 return B.CreateCall(DeclareFn, Args);
1078 assert(IntrinsicFn &&
"must pass a non-null intrinsic function");
1079 assert(V &&
"must pass a value to a dbg intrinsic");
1081 "empty or invalid DILocalVariable* passed to debug intrinsic");
1082 assert(
DL &&
"Expected debug loc");
1083 assert(
DL->getScope()->getSubprogram() ==
1085 "Expected matching subprograms");
1087 trackIfUnresolved(VarInfo);
1088 trackIfUnresolved(Expr);
1095 return B.CreateCall(IntrinsicFn, Args);
1101 assert(LabelInfo &&
"empty or invalid DILabel* passed to dbg.label");
1102 assert(
DL &&
"Expected debug loc");
1103 assert(
DL->getScope()->getSubprogram() ==
1105 "Expected matching subprograms");
1109 trackIfUnresolved(LabelInfo);
1114 return B.CreateCall(LabelFn, Args);
1120 N->replaceVTableHolder(VTableHolder);
1125 if (
T != VTableHolder)
1130 if (
T->isResolved())
1132 if (
auto *
N = dyn_cast_or_null<MDNode>(O))
1133 trackIfUnresolved(
N);
1137 DINodeArray TParams) {
1141 N->replaceElements(Elements);
1143 N->replaceTemplateParams(DITemplateParameterArray(TParams));
1148 if (!
T->isResolved())
1155 trackIfUnresolved(Elements.get());
1157 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...
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 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).