54 GV->setAlignment(
Align(1));
64 auto *PT = cast<PointerType>(
Ptr->getType());
65 if (PT->isOpaqueOrPointeeTypeMatches(
getInt8Ty()))
73 for (
auto &KV : MetadataToCopy)
74 if (KV.first == LLVMContext::MD_dbg)
75 return {cast<DILocation>(KV.second)};
80 for (
const auto &KV : MetadataToCopy)
81 if (KV.first == LLVMContext::MD_dbg) {
98 assert(isa<ConstantInt>(Scaling) &&
"Expected constant integer");
99 if (cast<ConstantInt>(Scaling)->
isZero())
105 return cast<ConstantInt>(Scaling)->getSExtValue() == 1
112 if (isa<ScalableVectorType>(DstType)) {
113 Type *StepVecType = DstType;
121 {StepVecType}, {},
nullptr,
Name);
122 if (StepVecType != DstType)
127 unsigned NumEls = cast<FixedVectorType>(DstType)->getNumElements();
131 for (
unsigned i = 0; i < NumEls; ++i)
142 Ptr = getCastedInt8PtrValue(
Ptr);
151 cast<MemSetInst>(CI)->setDestAlignment(*
Align);
158 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
161 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
168 bool IsVolatile,
MDNode *TBAATag,
171 Dst = getCastedInt8PtrValue(Dst);
173 Type *Tys[] = {Dst->getType(),
Size->getType()};
180 cast<MemSetInlineInst>(CI)->setDestAlignment(*DstAlign);
187 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
190 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
199 Ptr = getCastedInt8PtrValue(
Ptr);
204 M, Intrinsic::memset_element_unordered_atomic, Tys);
208 cast<AtomicMemSetInst>(CI)->setDestAlignment(Alignment);
215 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
218 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
227 Dst = getCastedInt8PtrValue(Dst);
228 Src = getCastedInt8PtrValue(Src);
231 Type *Tys[] = { Dst->getType(), Src->getType(),
Size->getType() };
237 auto* MCI = cast<MemTransferInst>(CI);
239 MCI->setDestAlignment(*DstAlign);
241 MCI->setSourceAlignment(*SrcAlign);
249 CI->
setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
252 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
255 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
264 Dst = getCastedInt8PtrValue(Dst);
265 Src = getCastedInt8PtrValue(Src);
268 Type *Tys[] = {Dst->getType(), Src->getType(),
Size->getType()};
275 auto *MCI = cast<MemCpyInlineInst>(CI);
277 MCI->setDestAlignment(*DstAlign);
279 MCI->setSourceAlignment(*SrcAlign);
283 MCI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
287 MCI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
290 MCI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
293 MCI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
302 assert(DstAlign >= ElementSize &&
303 "Pointer alignment must be at least element size");
304 assert(SrcAlign >= ElementSize &&
305 "Pointer alignment must be at least element size");
306 Dst = getCastedInt8PtrValue(Dst);
307 Src = getCastedInt8PtrValue(Src);
310 Type *Tys[] = {Dst->getType(), Src->getType(),
Size->getType()};
313 M, Intrinsic::memcpy_element_unordered_atomic, Tys);
318 auto *AMCI = cast<AtomicMemCpyInst>(CI);
319 AMCI->setDestAlignment(DstAlign);
320 AMCI->setSourceAlignment(SrcAlign);
328 CI->
setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
331 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
334 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
344 Dst = getCastedInt8PtrValue(Dst);
345 Src = getCastedInt8PtrValue(Src);
348 Type *Tys[] = { Dst->getType(), Src->getType(),
Size->getType() };
354 auto *MMI = cast<MemMoveInst>(CI);
356 MMI->setDestAlignment(*DstAlign);
358 MMI->setSourceAlignment(*SrcAlign);
365 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
368 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
377 assert(DstAlign >= ElementSize &&
378 "Pointer alignment must be at least element size");
379 assert(SrcAlign >= ElementSize &&
380 "Pointer alignment must be at least element size");
381 Dst = getCastedInt8PtrValue(Dst);
382 Src = getCastedInt8PtrValue(Src);
385 Type *Tys[] = {Dst->getType(), Src->getType(),
Size->getType()};
388 M, Intrinsic::memmove_element_unordered_atomic, Tys);
402 CI->
setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
405 CI->
setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
408 CI->
setMetadata(LLVMContext::MD_noalias, NoAliasTag);
415 Value *Ops[] = {Src};
416 Type *Tys[] = { Src->getType() };
423 Value *Ops[] = {Acc, Src};
431 Value *Ops[] = {Acc, Src};
438 return getReductionIntrinsic(Intrinsic::vector_reduce_add, Src);
442 return getReductionIntrinsic(Intrinsic::vector_reduce_mul, Src);
446 return getReductionIntrinsic(Intrinsic::vector_reduce_and, Src);
450 return getReductionIntrinsic(Intrinsic::vector_reduce_or, Src);
454 return getReductionIntrinsic(Intrinsic::vector_reduce_xor, Src);
459 IsSigned ? Intrinsic::vector_reduce_smax : Intrinsic::vector_reduce_umax;
460 return getReductionIntrinsic(
ID, Src);
465 IsSigned ? Intrinsic::vector_reduce_smin : Intrinsic::vector_reduce_umin;
466 return getReductionIntrinsic(
ID, Src);
470 return getReductionIntrinsic(Intrinsic::vector_reduce_fmax, Src);
474 return getReductionIntrinsic(Intrinsic::vector_reduce_fmin, Src);
478 assert(isa<PointerType>(
Ptr->getType()) &&
479 "lifetime.start only applies to pointers.");
480 Ptr = getCastedInt8PtrValue(
Ptr);
485 "lifetime.start requires the size to be an i64");
494 assert(isa<PointerType>(
Ptr->getType()) &&
495 "lifetime.end only applies to pointers.");
496 Ptr = getCastedInt8PtrValue(
Ptr);
501 "lifetime.end requires the size to be an i64");
511 assert(isa<PointerType>(
Ptr->getType()) &&
512 "invariant.start only applies to pointers.");
513 Ptr = getCastedInt8PtrValue(
Ptr);
518 "invariant.start requires the size to be an i64");
522 Type *ObjectPtr[1] = {
Ptr->getType()};
530 if (
auto *O = dyn_cast<GlobalObject>(
Ptr))
531 return O->getAlign();
532 if (
auto *
A = dyn_cast<GlobalAlias>(
Ptr))
533 return A->getAliaseeObject()->getAlign();
544 if (
auto *CE = dyn_cast<ConstantExpr>(V))
546 V = CE->getOperand(0);
548 assert(isa<GlobalValue>(V) && cast<GlobalValue>(V)->isThreadLocal() &&
549 "threadlocal_address only applies to thread local variables.");
564 "an assumption condition must be of type i1");
575 M, Intrinsic::experimental_noalias_scope_decl, {});
591 auto *PtrTy = cast<PointerType>(
Ptr->getType());
593 assert(PtrTy->isOpaqueOrPointeeTypeMatches(Ty) &&
"Wrong element type");
594 assert(Mask &&
"Mask should not be all-ones (null)");
597 Type *OverloadedTypes[] = { Ty, PtrTy };
599 return CreateMaskedIntrinsic(Intrinsic::masked_load, Ops,
600 OverloadedTypes,
Name);
611 auto *PtrTy = cast<PointerType>(
Ptr->getType());
614 assert(PtrTy->isOpaqueOrPointeeTypeMatches(DataTy) &&
"Wrong element type");
615 assert(Mask &&
"Mask should not be all-ones (null)");
616 Type *OverloadedTypes[] = { DataTy, PtrTy };
618 return CreateMaskedIntrinsic(Intrinsic::masked_store, Ops, OverloadedTypes);
646 auto *VecTy = cast<VectorType>(Ty);
648 auto *PtrsTy = cast<VectorType>(Ptrs->
getType());
649 assert(cast<PointerType>(PtrsTy->getElementType())
650 ->isOpaqueOrPointeeTypeMatches(
651 cast<VectorType>(Ty)->getElementType()) &&
652 "Element type mismatch");
653 assert(NumElts == PtrsTy->getElementCount() &&
"Element count mismatch");
662 Type *OverloadedTypes[] = {Ty, PtrsTy};
667 return CreateMaskedIntrinsic(Intrinsic::masked_gather, Ops, OverloadedTypes,
680 auto *PtrsTy = cast<VectorType>(Ptrs->
getType());
681 auto *DataTy = cast<VectorType>(
Data->getType());
685 auto *PtrTy = cast<PointerType>(PtrsTy->getElementType());
686 assert(NumElts == DataTy->getElementCount() &&
687 PtrTy->isOpaqueOrPointeeTypeMatches(DataTy->getElementType()) &&
688 "Incompatible pointer and data types");
695 Type *OverloadedTypes[] = {DataTy, PtrsTy};
700 return CreateMaskedIntrinsic(Intrinsic::masked_scatter, Ops, OverloadedTypes);
714 auto *PtrTy = cast<PointerType>(
Ptr->getType());
716 assert(PtrTy->isOpaqueOrPointeeTypeMatches(
717 cast<FixedVectorType>(Ty)->getElementType()) &&
718 "Wrong element type");
720 assert(Mask &&
"Mask should not be all-ones (null)");
723 Type *OverloadedTypes[] = {Ty};
724 Value *Ops[] = {
Ptr, Mask, PassThru};
725 return CreateMaskedIntrinsic(Intrinsic::masked_expandload, Ops,
726 OverloadedTypes,
Name);
736 auto *PtrTy = cast<PointerType>(
Ptr->getType());
739 assert(PtrTy->isOpaqueOrPointeeTypeMatches(
740 cast<FixedVectorType>(DataTy)->getElementType()) &&
741 "Wrong element type");
743 assert(Mask &&
"Mask should not be all-ones (null)");
744 Type *OverloadedTypes[] = {DataTy};
746 return CreateMaskedIntrinsic(Intrinsic::masked_compressstore, Ops,
750template <
typename T0>
751static std::vector<Value *>
754 std::vector<Value *> Args;
755 Args.push_back(
B.getInt64(
ID));
756 Args.push_back(
B.getInt32(NumPatchBytes));
757 Args.push_back(ActualCallee);
758 Args.push_back(
B.getInt32(CallArgs.
size()));
759 Args.push_back(
B.getInt32(Flags));
763 Args.push_back(
B.getInt32(0));
764 Args.push_back(
B.getInt32(0));
769template<
typename T1,
typename T2,
typename T3>
770static std::vector<OperandBundleDef>
774 std::vector<OperandBundleDef> Rval;
778 Rval.emplace_back(
"deopt", DeoptValues);
780 if (TransitionArgs) {
783 Rval.emplace_back(
"gc-transition", TransitionValues);
788 Rval.emplace_back(
"gc-live", LiveValues);
793template <
typename T0,
typename T1,
typename T2,
typename T3>
800 Module *M =
Builder->GetInsertBlock()->getParent()->getParent();
822 return CreateGCStatepointCallCommon<Value *, Value *, Value *, Value *>(
824 CallArgs, std::nullopt , DeoptArgs, GCArgs,
Name);
833 return CreateGCStatepointCallCommon<Value *, Use, Use, Value *>(
834 this,
ID, NumPatchBytes, ActualCallee, Flags, CallArgs, TransitionArgs,
835 DeoptArgs, GCArgs,
Name);
842 return CreateGCStatepointCallCommon<Use, Value *, Value *, Value *>(
844 CallArgs, std::nullopt, DeoptArgs, GCArgs,
Name);
847template <
typename T0,
typename T1,
typename T2,
typename T3>
855 Module *M =
Builder->GetInsertBlock()->getParent()->getParent();
861 std::vector<Value *> Args =
866 FnStatepoint, NormalDest, UnwindDest, Args,
879 return CreateGCStatepointInvokeCommon<Value *, Value *, Value *, Value *>(
880 this,
ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
882 std::nullopt , DeoptArgs, GCArgs,
Name);
891 return CreateGCStatepointInvokeCommon<Value *, Use, Use, Value *>(
892 this,
ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest, Flags,
893 InvokeArgs, TransitionArgs, DeoptArgs, GCArgs,
Name);
901 return CreateGCStatepointInvokeCommon<Use, Value *, Value *, Value *>(
902 this,
ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
911 Type *Types[] = {ResultType};
914 Value *Args[] = {Statepoint};
919 int BaseOffset,
int DerivedOffset,
922 Type *Types[] = {ResultType};
935 M, Intrinsic::experimental_gc_get_pointer_base, {PtrTy, PtrTy});
944 M, Intrinsic::experimental_gc_get_pointer_offset, {PtrTy});
953 return createCallHelper(Fn, {V},
Name, FMFSource);
962 return createCallHelper(Fn, {
LHS,
RHS},
Name, FMFSource);
972 return createCallHelper(Fn, Args,
Name, FMFSource);
992 matchIntrinsicSignature(FTy,
TableRef, OverloadTys);
995 "Wrong types for intrinsic!");
999 return createCallHelper(Fn, Args,
Name, FMFSource);
1005 std::optional<RoundingMode> Rounding,
1006 std::optional<fp::ExceptionBehavior> Except) {
1007 Value *RoundingV = getConstrainedFPRounding(Rounding);
1008 Value *ExceptV = getConstrainedFPExcept(Except);
1015 {L, R, RoundingV, ExceptV},
nullptr,
Name);
1017 setFPAttrs(
C, FPMathTag, UseFMF);
1024 assert(Ops.
size() == 2 &&
"Invalid number of operands!");
1026 Ops[0], Ops[1],
Name, FPMathTag);
1029 assert(Ops.
size() == 1 &&
"Invalid number of operands!");
1031 Ops[0],
Name, FPMathTag);
1039 std::optional<RoundingMode> Rounding,
1040 std::optional<fp::ExceptionBehavior> Except) {
1041 Value *ExceptV = getConstrainedFPExcept(Except);
1048 bool HasRoundingMD =
false;
1052#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
1053 case Intrinsic::INTRINSIC: \
1054 HasRoundingMD = ROUND_MODE; \
1056#include "llvm/IR/ConstrainedOps.def"
1058 if (HasRoundingMD) {
1059 Value *RoundingV = getConstrainedFPRounding(Rounding);
1068 if (isa<FPMathOperator>(
C))
1069 setFPAttrs(
C, FPMathTag, UseFMF);
1073Value *IRBuilderBase::CreateFCmpHelper(
1075 MDNode *FPMathTag,
bool IsSignaling) {
1077 auto ID = IsSignaling ? Intrinsic::experimental_constrained_fcmps
1078 : Intrinsic::experimental_constrained_fcmp;
1082 if (
auto *LC = dyn_cast<Constant>(LHS))
1083 if (
auto *RC = dyn_cast<Constant>(RHS))
1090 const Twine &
Name, std::optional<fp::ExceptionBehavior> Except) {
1091 Value *PredicateV = getConstrainedFPPredicate(
P);
1092 Value *ExceptV = getConstrainedFPExcept(Except);
1095 {L, R, PredicateV, ExceptV},
nullptr,
Name);
1102 std::optional<RoundingMode> Rounding,
1103 std::optional<fp::ExceptionBehavior> Except) {
1107 bool HasRoundingMD =
false;
1108 switch (
Callee->getIntrinsicID()) {
1111#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
1112 case Intrinsic::INTRINSIC: \
1113 HasRoundingMD = ROUND_MODE; \
1115#include "llvm/IR/ConstrainedOps.def"
1118 UseArgs.
push_back(getConstrainedFPRounding(Rounding));
1119 UseArgs.
push_back(getConstrainedFPExcept(Except));
1135 Sel = addBranchMetadata(Sel, Prof, Unpred);
1137 if (isa<FPMathOperator>(Sel))
1138 setFPAttrs(Sel,
nullptr ,
FMF);
1145 "Pointer subtraction operand types must match!");
1147 ->isOpaqueOrPointeeTypeMatches(ElemTy) &&
1148 "Pointer type must match element type");
1157 assert(isa<PointerType>(
Ptr->getType()) &&
1158 "launder.invariant.group only applies to pointers.");
1160 auto *PtrType =
Ptr->getType();
1161 auto *Int8PtrTy =
getInt8PtrTy(PtrType->getPointerAddressSpace());
1162 if (PtrType != Int8PtrTy)
1166 M, Intrinsic::launder_invariant_group, {Int8PtrTy});
1171 "LaunderInvariantGroup should take and return the same type");
1175 if (PtrType != Int8PtrTy)
1181 assert(isa<PointerType>(
Ptr->getType()) &&
1182 "strip.invariant.group only applies to pointers.");
1185 auto *PtrType =
Ptr->getType();
1186 auto *Int8PtrTy =
getInt8PtrTy(PtrType->getPointerAddressSpace());
1187 if (PtrType != Int8PtrTy)
1191 M, Intrinsic::strip_invariant_group, {Int8PtrTy});
1196 "StripInvariantGroup should take and return the same type");
1200 if (PtrType != Int8PtrTy)
1206 auto *Ty = cast<VectorType>(V->
getType());
1207 if (isa<ScalableVectorType>(Ty)) {
1210 M, Intrinsic::experimental_vector_reverse, Ty);
1215 int NumElts = Ty->getElementCount().getKnownMinValue();
1216 for (
int i = 0; i < NumElts; ++i)
1223 assert(isa<VectorType>(V1->
getType()) &&
"Unexpected type");
1225 "Splice expects matching operand types!");
1227 if (
auto *VTy = dyn_cast<ScalableVectorType>(V1->
getType())) {
1230 M, Intrinsic::experimental_vector_splice, VTy);
1236 unsigned NumElts = cast<FixedVectorType>(V1->
getType())->getNumElements();
1237 assert(((-Imm <= NumElts) || (Imm < NumElts)) &&
1238 "Invalid immediate for vector splice!");
1241 unsigned Idx = (NumElts + Imm) % NumElts;
1243 for (
unsigned I = 0;
I < NumElts; ++
I)
1244 Mask.push_back(
Idx +
I);
1257 assert(EC.isNonZero() &&
"Cannot splat to an empty vector!");
1265 Zeros.
resize(EC.getKnownMinValue());
1272 auto *IntTy = cast<IntegerType>(
From->getType());
1274 DL.getTypeStoreSize(IntTy) &&
1275 "Element extends past full value");
1278 if (
DL.isBigEndian())
1279 ShAmt = 8 * (
DL.getTypeStoreSize(IntTy) -
1280 DL.getTypeStoreSize(ExtractedTy) -
Offset);
1285 "Cannot extract to a larger integer!");
1286 if (ExtractedTy != IntTy) {
1293 Type *ElTy,
Value *
Base,
unsigned Dimension,
unsigned LastIndex,
1297 "Invalid Base ptr type for preserve.array.access.index.");
1298 assert(cast<PointerType>(
BaseType)->isOpaqueOrPointeeTypeMatches(ElTy) &&
1299 "Pointer element type mismatch");
1311 M, Intrinsic::preserve_array_access_index, {ResultType,
BaseType});
1315 CreateCall(FnPreserveArrayAccessIndex, {
Base, DimV, LastIndexV});
1319 Fn->
setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
1327 "Invalid Base ptr type for preserve.union.access.index.");
1338 Fn->
setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
1348 "Invalid Base ptr type for preserve.struct.access.index.");
1349 assert(cast<PointerType>(
BaseType)->isOpaqueOrPointeeTypeMatches(ElTy) &&
1350 "Pointer element type mismatch");
1359 M, Intrinsic::preserve_struct_access_index, {ResultType,
BaseType});
1363 {
Base, GEPIndex, DIIndex});
1367 Fn->
setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
1375 Value *OffsetValue) {
1386 Value *OffsetValue) {
1388 "trying to create an alignment assumption on a non-pointer?");
1389 assert(Alignment != 0 &&
"Invalid Alignment");
1390 auto *PtrTy = cast<PointerType>(PtrValue->
getType());
1393 return CreateAlignmentAssumptionHelper(
DL, PtrValue, AlignValue, OffsetValue);
1399 Value *OffsetValue) {
1401 "trying to create an alignment assumption on a non-pointer?");
1402 return CreateAlignmentAssumptionHelper(
DL, PtrValue, Alignment, OffsetValue);
1408void ConstantFolder::anchor() {}
1409void NoFolder::anchor() {}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu Simplify well known AMD library false FunctionCallee Callee
ArrayRef< TableEntry > TableRef
SmallVector< MachineOperand, 4 > Cond
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static InvokeInst * CreateGCStatepointInvokeCommon(IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags, ArrayRef< T0 > InvokeArgs, std::optional< ArrayRef< T1 > > TransitionArgs, std::optional< ArrayRef< T2 > > DeoptArgs, ArrayRef< T3 > GCArgs, const Twine &Name)
static CallInst * CreateGCStatepointCallCommon(IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualCallee, uint32_t Flags, ArrayRef< T0 > CallArgs, std::optional< ArrayRef< T1 > > TransitionArgs, std::optional< ArrayRef< T2 > > DeoptArgs, ArrayRef< T3 > GCArgs, const Twine &Name)
static std::vector< OperandBundleDef > getStatepointBundles(std::optional< ArrayRef< T1 > > TransitionArgs, std::optional< ArrayRef< T2 > > DeoptArgs, ArrayRef< T3 > GCArgs)
static std::vector< Value * > getStatepointArgs(IRBuilderBase &B, uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, uint32_t Flags, ArrayRef< T0 > CallArgs)
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
static M68kRelType getType(unsigned Kind, MCSymbolRefExpr::VariantKind &Modifier, bool &IsPCRel)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
LLVM Basic Block Representation.
const Function * getParent() const
Return the enclosing method, or null if none.
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
void addRetAttr(Attribute::AttrKind Kind)
Adds the attribute to the return value.
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
static Constant * getSizeOf(Type *Ty)
getSizeOf constant expr - computes the (alloc) size of a type (in address-units, not bits) in a targe...
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
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 Constant * get(ArrayRef< Constant * > V)
This is an important base class in LLVM.
static Constant * getAllOnesValue(Type *Ty)
A parsed version of the target data layout string in and methods for querying it.
static constexpr ElementCount getFixed(ScalarTy MinVal)
This instruction compares its operands according to the predicate given to the constructor.
Convenience struct for specifying and reasoning about fast-math flags.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
FunctionType * getFunctionType()
Class to represent function types.
Type * getParamType(unsigned i) const
Parameter type accessors.
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Type * getReturnType() const
Returns the type of the ret val.
static Type * getGEPReturnType(Type *ElTy, Value *Ptr, ArrayRef< Value * > IdxList)
Returns the pointer type returned by the GEP instruction, which may be a vector of pointers.
Module * getParent()
Get the module that this global value is contained inside of...
@ PrivateLinkage
Like Internal, but omit from symbol table.
Common base class shared among various IRBuilders.
Value * CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name="")
CallInst * CreateElementUnorderedAtomicMemCpy(Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, uint32_t ElementSize, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert an element unordered-atomic memcpy between the specified pointers.
ConstantInt * getInt1(bool V)
Get a constant value representing either true or false.
CallInst * CreateMaskedCompressStore(Value *Val, Value *Ptr, Value *Mask=nullptr)
Create a call to Masked Compress Store intrinsic.
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Value * CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS, const Twine &Name="")
Return the i64 difference between two pointer values, dividing out the size of the pointed-to objects...
CallInst * CreateMulReduce(Value *Src)
Create a vector int mul reduction intrinsic of the source vector.
CallInst * CreateFAddReduce(Value *Acc, Value *Src)
Create a sequential vector fadd reduction intrinsic of the source vector.
CallInst * CreateMaskedExpandLoad(Type *Ty, Value *Ptr, Value *Mask=nullptr, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Expand Load intrinsic.
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateVScale(Constant *Scaling, const Twine &Name="")
Create a call to llvm.vscale, multiplied by Scaling.
Value * CreateLaunderInvariantGroup(Value *Ptr)
Create a launder.invariant.group intrinsic call.
Value * CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx, const Twine &Name="")
CallInst * CreateThreadLocalAddress(Value *Ptr)
Create a call to llvm.threadlocal.address intrinsic.
IntegerType * getInt1Ty()
Fetch the type representing a single bit.
Type * getCurrentFunctionReturnType() const
Get the return type of the current function that we're emitting into.
CallInst * CreateGCGetPointerBase(Value *DerivedPtr, const Twine &Name="")
Create a call to the experimental.gc.pointer.base intrinsic to get the base pointer for the specified...
CallInst * CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualCallee, ArrayRef< Value * > CallArgs, std::optional< ArrayRef< Value * > > DeoptArgs, ArrayRef< Value * > GCArgs, const Twine &Name="")
Create a call to the experimental.gc.statepoint intrinsic to start a new statepoint sequence.
GlobalVariable * CreateGlobalString(StringRef Str, const Twine &Name="", unsigned AddressSpace=0, Module *M=nullptr)
Make a new global variable with initializer type i8*.
CallInst * CreateLifetimeStart(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.start intrinsic.
CallInst * CreateConstrainedFPCmp(Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R, const Twine &Name="", std::optional< fp::ExceptionBehavior > Except=std::nullopt)
CallInst * CreateAndReduce(Value *Src)
Create a vector int AND reduction intrinsic of the source vector.
Value * CreateVectorSplice(Value *V1, Value *V2, int64_t Imm, const Twine &Name="")
Return a vector splice intrinsic if using scalable vectors, otherwise return a shufflevector.
Value * CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name="")
Return a vector value that contains.
CallInst * CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, bool IsVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Value * CreatePreserveStructAccessIndex(Type *ElTy, Value *Base, unsigned Index, unsigned FieldIndex, MDNode *DbgInfo)
CallInst * CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, unsigned Alignment, Value *OffsetValue=nullptr)
Create an assume intrinsic call that represents an alignment assumption on the provided pointer.
CallInst * CreateMaskedLoad(Type *Ty, Value *Ptr, Align Alignment, Value *Mask, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Load intrinsic.
CallInst * CreateConstrainedFPCall(Function *Callee, ArrayRef< Value * > Args, const Twine &Name="", std::optional< RoundingMode > Rounding=std::nullopt, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
CallInst * CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, MaybeAlign Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memset to the specified pointer and the specified value.
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
CallInst * CreateGCGetPointerOffset(Value *DerivedPtr, const Twine &Name="")
Create a call to the experimental.gc.get.pointer.offset intrinsic to get the offset of the specified ...
CallInst * CreateAddReduce(Value *Src)
Create a vector int add reduction intrinsic of the source vector.
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
IntegerType * getIntPtrTy(const DataLayout &DL, unsigned AddrSpace=0)
Fetch the type of an integer with size at least as big as that of a pointer in the given address spac...
BasicBlock * GetInsertBlock() const
IntegerType * getInt64Ty()
Fetch the type representing a 64-bit integer.
CallInst * CreateMemTransferInst(Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Value * CreateVectorReverse(Value *V, const Twine &Name="")
Return a vector value that contains the vector V reversed.
CallInst * CreateXorReduce(Value *Src)
Create a vector int XOR reduction intrinsic of the source vector.
ConstantInt * getInt64(uint64_t C)
Get a constant 64-bit value.
Value * CreateUnOp(Instruction::UnaryOps Opc, Value *V, const Twine &Name="", MDNode *FPMathTag=nullptr)
CallInst * CreateOrReduce(Value *Src)
Create a vector int OR reduction intrinsic of the source vector.
CallInst * CreateFPMinReduce(Value *Src)
Create a vector float min reduction intrinsic of the source vector.
CallInst * CreateFPMaxReduce(Value *Src)
Create a vector float max reduction intrinsic of the source vector.
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Value * CreateExtractInteger(const DataLayout &DL, Value *From, IntegerType *ExtractedTy, uint64_t Offset, const Twine &Name)
Return a value that has been extracted from a larger integer type.
InstTy * Insert(InstTy *I, const Twine &Name="") const
Insert and return the specified instruction.
CallInst * CreateConstrainedFPBinOp(Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource=nullptr, const Twine &Name="", MDNode *FPMathTag=nullptr, std::optional< RoundingMode > Rounding=std::nullopt, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
DebugLoc getCurrentDebugLocation() const
Get location information used by debugging information.
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Value * CreateNAryOp(unsigned Opc, ArrayRef< Value * > Ops, const Twine &Name="", MDNode *FPMathTag=nullptr)
Create either a UnaryOperator or BinaryOperator depending on Opc.
CallInst * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
CallInst * CreateAssumption(Value *Cond, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Create an assume intrinsic call that allows the optimizer to assume that the provided condition will ...
Value * CreateShuffleVector(Value *V1, Value *V2, Value *Mask, const Twine &Name="")
LLVMContext & getContext() const
Value * CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex, MDNode *DbgInfo)
CallInst * CreateIntMaxReduce(Value *Src, bool IsSigned=false)
Create a vector integer max reduction intrinsic of the source vector.
CallInst * CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment, Value *Mask)
Create a call to Masked Store intrinsic.
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
CallInst * CreateGCResult(Instruction *Statepoint, Type *ResultType, const Twine &Name="")
Create a call to the experimental.gc.result intrinsic to extract the result from a call wrapped in a ...
CallInst * CreateLifetimeEnd(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.end intrinsic.
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
CallInst * CreateConstrainedFPCast(Intrinsic::ID ID, Value *V, Type *DestTy, Instruction *FMFSource=nullptr, const Twine &Name="", MDNode *FPMathTag=nullptr, std::optional< RoundingMode > Rounding=std::nullopt, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
CallInst * CreateElementUnorderedAtomicMemMove(Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, uint32_t ElementSize, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert an element unordered-atomic memmove between the specified pointers.
CallInst * CreateIntMinReduce(Value *Src, bool IsSigned=false)
Create a vector integer min reduction intrinsic of the source vector.
void setConstrainedFPCallAttr(CallBase *I)
InvokeInst * CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > InvokeArgs, std::optional< ArrayRef< Value * > > DeoptArgs, ArrayRef< Value * > GCArgs, const Twine &Name="")
Create an invoke to the experimental.gc.statepoint intrinsic to start a new statepoint sequence.
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
const IRBuilderFolder & Folder
CallInst * CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, Value *Val, Value *Size, bool IsVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
CallInst * CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, uint64_t Size, Align Alignment, uint32_t ElementSize, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert an element unordered-atomic memset of the region of memory starting at the given po...
CallInst * CreateFMulReduce(Value *Acc, Value *Src)
Create a sequential vector fmul reduction intrinsic of the source vector.
void SetInstDebugLocation(Instruction *I) const
If this builder has a current debug location, set it on the specified instruction.
IntegerType * getInt8Ty()
Fetch the type representing an 8-bit integer.
CallInst * CreateGCRelocate(Instruction *Statepoint, int BaseOffset, int DerivedOffset, Type *ResultType, const Twine &Name="")
Create a call to the experimental.gc.relocate intrinsics to project the relocated value of one pointe...
Value * CreateStepVector(Type *DstType, const Twine &Name="")
Creates a vector of type DstType with the linear sequence <0, 1, ...>
CallInst * CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, uint64_t Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Value * CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base, unsigned Dimension, unsigned LastIndex, MDNode *DbgInfo)
CallInst * CreateInvariantStart(Value *Ptr, ConstantInt *Size=nullptr)
Create a call to invariant.start intrinsic.
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Instruction * CreateNoAliasScopeDeclaration(Value *Scope)
Create a llvm.experimental.noalias.scope.decl intrinsic call.
CallInst * CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment, Value *Mask=nullptr)
Create a call to Masked Scatter intrinsic.
Value * CreateStripInvariantGroup(Value *Ptr)
Create a strip.invariant.group intrinsic call.
CallInst * CreateMaskedGather(Type *Ty, Value *Ptrs, Align Alignment, Value *Mask=nullptr, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Gather intrinsic.
~IRBuilderCallbackInserter() override
virtual ~IRBuilderDefaultInserter()
virtual Value * FoldSelect(Value *C, Value *True, Value *False) const =0
virtual Value * CreateFCmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const =0
virtual ~IRBuilderFolder()
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction,...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
Class to represent integer types.
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
A Module instance is used to store all the information related to an LLVM module.
A container for an operand bundle being viewed as a set of values rather than a set of uses.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
This class represents the LLVM 'select' instruction.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
void reserve(size_type N)
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.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
static IntegerType * getInt1Ty(LLVMContext &C)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVMContext & getContext() const
All values hold a context through their type.
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
MatchIntrinsicTypesResult
@ MatchIntrinsicTypes_Match
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.
bool getAlign(const Function &F, unsigned index, unsigned &align)
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.