1 //===- IRBuilder.cpp - Builder for LLVM Instrs ----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the IRBuilder class, which is used as a convenient way
11 // to create LLVM instructions with a consistent and simplified interface.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/IR/IRBuilder.h"
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/None.h"
18 #include "llvm/IR/Constant.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/DerivedTypes.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/GlobalValue.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/IR/Operator.h"
28 #include "llvm/IR/Statepoint.h"
29 #include "llvm/IR/Type.h"
30 #include "llvm/IR/Value.h"
31 #include "llvm/Support/Casting.h"
32 #include "llvm/Support/MathExtras.h"
39 /// CreateGlobalString - Make a new global variable with an initializer that
40 /// has array of i8 type filled in with the nul terminated string value
41 /// specified. If Name is specified, it is the name of the global variable
43 GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str,
45 unsigned AddressSpace) {
46 Constant *StrConstant = ConstantDataArray::getString(Context, Str);
47 Module &M = *BB->getParent()->getParent();
48 auto *GV = new GlobalVariable(M, StrConstant->getType(), true,
49 GlobalValue::PrivateLinkage, StrConstant, Name,
50 nullptr, GlobalVariable::NotThreadLocal,
52 GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
57 Type *IRBuilderBase::getCurrentFunctionReturnType() const {
58 assert(BB && BB->getParent() && "No current function!");
59 return BB->getParent()->getReturnType();
62 Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) {
63 auto *PT = cast<PointerType>(Ptr->getType());
64 if (PT->getElementType()->isIntegerTy(8))
67 // Otherwise, we need to insert a bitcast.
68 PT = getInt8PtrTy(PT->getAddressSpace());
69 BitCastInst *BCI = new BitCastInst(Ptr, PT, "");
70 BB->getInstList().insert(InsertPt, BCI);
71 SetInstDebugLocation(BCI);
75 static CallInst *createCallHelper(Value *Callee, ArrayRef<Value *> Ops,
76 IRBuilderBase *Builder,
77 const Twine &Name = "",
78 Instruction *FMFSource = nullptr) {
79 CallInst *CI = CallInst::Create(Callee, Ops, Name);
81 CI->copyFastMathFlags(FMFSource);
82 Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),CI);
83 Builder->SetInstDebugLocation(CI);
87 static InvokeInst *createInvokeHelper(Value *Invokee, BasicBlock *NormalDest,
88 BasicBlock *UnwindDest,
89 ArrayRef<Value *> Ops,
90 IRBuilderBase *Builder,
91 const Twine &Name = "") {
93 InvokeInst::Create(Invokee, NormalDest, UnwindDest, Ops, Name);
94 Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),
96 Builder->SetInstDebugLocation(II);
100 CallInst *IRBuilderBase::
101 CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
102 bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
103 MDNode *NoAliasTag) {
104 Ptr = getCastedInt8PtrValue(Ptr);
105 Value *Ops[] = {Ptr, Val, Size, getInt1(isVolatile)};
106 Type *Tys[] = { Ptr->getType(), Size->getType() };
107 Module *M = BB->getParent()->getParent();
108 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
110 CallInst *CI = createCallHelper(TheFn, Ops, this);
113 cast<MemSetInst>(CI)->setDestAlignment(Align);
115 // Set the TBAA info if present.
117 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
120 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
123 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
128 CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet(
129 Value *Ptr, Value *Val, Value *Size, unsigned Align, uint32_t ElementSize,
130 MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) {
131 assert(Align >= ElementSize &&
132 "Pointer alignment must be at least element size.");
134 Ptr = getCastedInt8PtrValue(Ptr);
135 Value *Ops[] = {Ptr, Val, Size, getInt32(ElementSize)};
136 Type *Tys[] = {Ptr->getType(), Size->getType()};
137 Module *M = BB->getParent()->getParent();
138 Value *TheFn = Intrinsic::getDeclaration(
139 M, Intrinsic::memset_element_unordered_atomic, Tys);
141 CallInst *CI = createCallHelper(TheFn, Ops, this);
143 cast<AtomicMemSetInst>(CI)->setDestAlignment(Align);
145 // Set the TBAA info if present.
147 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
150 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
153 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
158 CallInst *IRBuilderBase::
159 CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
160 Value *Size, bool isVolatile, MDNode *TBAATag,
161 MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) {
162 assert((DstAlign == 0 || isPowerOf2_32(DstAlign)) && "Must be 0 or a power of 2");
163 assert((SrcAlign == 0 || isPowerOf2_32(SrcAlign)) && "Must be 0 or a power of 2");
164 Dst = getCastedInt8PtrValue(Dst);
165 Src = getCastedInt8PtrValue(Src);
167 Value *Ops[] = {Dst, Src, Size, getInt1(isVolatile)};
168 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
169 Module *M = BB->getParent()->getParent();
170 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys);
172 CallInst *CI = createCallHelper(TheFn, Ops, this);
174 auto* MCI = cast<MemCpyInst>(CI);
176 MCI->setDestAlignment(DstAlign);
178 MCI->setSourceAlignment(SrcAlign);
180 // Set the TBAA info if present.
182 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
184 // Set the TBAA Struct info if present.
186 CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
189 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
192 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
197 CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemCpy(
198 Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
199 uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
200 MDNode *ScopeTag, MDNode *NoAliasTag) {
201 assert(DstAlign >= ElementSize &&
202 "Pointer alignment must be at least element size");
203 assert(SrcAlign >= ElementSize &&
204 "Pointer alignment must be at least element size");
205 Dst = getCastedInt8PtrValue(Dst);
206 Src = getCastedInt8PtrValue(Src);
208 Value *Ops[] = {Dst, Src, Size, getInt32(ElementSize)};
209 Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
210 Module *M = BB->getParent()->getParent();
211 Value *TheFn = Intrinsic::getDeclaration(
212 M, Intrinsic::memcpy_element_unordered_atomic, Tys);
214 CallInst *CI = createCallHelper(TheFn, Ops, this);
216 // Set the alignment of the pointer args.
217 auto *AMCI = cast<AtomicMemCpyInst>(CI);
218 AMCI->setDestAlignment(DstAlign);
219 AMCI->setSourceAlignment(SrcAlign);
221 // Set the TBAA info if present.
223 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
225 // Set the TBAA Struct info if present.
227 CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
230 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
233 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
238 CallInst *IRBuilderBase::
239 CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
240 Value *Size, bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
241 MDNode *NoAliasTag) {
242 assert((DstAlign == 0 || isPowerOf2_32(DstAlign)) && "Must be 0 or a power of 2");
243 assert((SrcAlign == 0 || isPowerOf2_32(SrcAlign)) && "Must be 0 or a power of 2");
244 Dst = getCastedInt8PtrValue(Dst);
245 Src = getCastedInt8PtrValue(Src);
247 Value *Ops[] = {Dst, Src, Size, getInt1(isVolatile)};
248 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
249 Module *M = BB->getParent()->getParent();
250 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys);
252 CallInst *CI = createCallHelper(TheFn, Ops, this);
254 auto *MMI = cast<MemMoveInst>(CI);
256 MMI->setDestAlignment(DstAlign);
258 MMI->setSourceAlignment(SrcAlign);
260 // Set the TBAA info if present.
262 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
265 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
268 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
273 CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemMove(
274 Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
275 uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
276 MDNode *ScopeTag, MDNode *NoAliasTag) {
277 assert(DstAlign >= ElementSize &&
278 "Pointer alignment must be at least element size");
279 assert(SrcAlign >= ElementSize &&
280 "Pointer alignment must be at least element size");
281 Dst = getCastedInt8PtrValue(Dst);
282 Src = getCastedInt8PtrValue(Src);
284 Value *Ops[] = {Dst, Src, Size, getInt32(ElementSize)};
285 Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
286 Module *M = BB->getParent()->getParent();
287 Value *TheFn = Intrinsic::getDeclaration(
288 M, Intrinsic::memmove_element_unordered_atomic, Tys);
290 CallInst *CI = createCallHelper(TheFn, Ops, this);
292 // Set the alignment of the pointer args.
293 CI->addParamAttr(0, Attribute::getWithAlignment(CI->getContext(), DstAlign));
294 CI->addParamAttr(1, Attribute::getWithAlignment(CI->getContext(), SrcAlign));
296 // Set the TBAA info if present.
298 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
300 // Set the TBAA Struct info if present.
302 CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
305 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
308 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
313 static CallInst *getReductionIntrinsic(IRBuilderBase *Builder, Intrinsic::ID ID,
315 Module *M = Builder->GetInsertBlock()->getParent()->getParent();
316 Value *Ops[] = {Src};
317 Type *Tys[] = { Src->getType()->getVectorElementType(), Src->getType() };
318 auto Decl = Intrinsic::getDeclaration(M, ID, Tys);
319 return createCallHelper(Decl, Ops, Builder);
322 CallInst *IRBuilderBase::CreateFAddReduce(Value *Acc, Value *Src) {
323 Module *M = GetInsertBlock()->getParent()->getParent();
324 Value *Ops[] = {Acc, Src};
325 Type *Tys[] = {Src->getType()->getVectorElementType(), Acc->getType(),
327 auto Decl = Intrinsic::getDeclaration(
328 M, Intrinsic::experimental_vector_reduce_fadd, Tys);
329 return createCallHelper(Decl, Ops, this);
332 CallInst *IRBuilderBase::CreateFMulReduce(Value *Acc, Value *Src) {
333 Module *M = GetInsertBlock()->getParent()->getParent();
334 Value *Ops[] = {Acc, Src};
335 Type *Tys[] = {Src->getType()->getVectorElementType(), Acc->getType(),
337 auto Decl = Intrinsic::getDeclaration(
338 M, Intrinsic::experimental_vector_reduce_fmul, Tys);
339 return createCallHelper(Decl, Ops, this);
342 CallInst *IRBuilderBase::CreateAddReduce(Value *Src) {
343 return getReductionIntrinsic(this, Intrinsic::experimental_vector_reduce_add,
347 CallInst *IRBuilderBase::CreateMulReduce(Value *Src) {
348 return getReductionIntrinsic(this, Intrinsic::experimental_vector_reduce_mul,
352 CallInst *IRBuilderBase::CreateAndReduce(Value *Src) {
353 return getReductionIntrinsic(this, Intrinsic::experimental_vector_reduce_and,
357 CallInst *IRBuilderBase::CreateOrReduce(Value *Src) {
358 return getReductionIntrinsic(this, Intrinsic::experimental_vector_reduce_or,
362 CallInst *IRBuilderBase::CreateXorReduce(Value *Src) {
363 return getReductionIntrinsic(this, Intrinsic::experimental_vector_reduce_xor,
367 CallInst *IRBuilderBase::CreateIntMaxReduce(Value *Src, bool IsSigned) {
368 auto ID = IsSigned ? Intrinsic::experimental_vector_reduce_smax
369 : Intrinsic::experimental_vector_reduce_umax;
370 return getReductionIntrinsic(this, ID, Src);
373 CallInst *IRBuilderBase::CreateIntMinReduce(Value *Src, bool IsSigned) {
374 auto ID = IsSigned ? Intrinsic::experimental_vector_reduce_smin
375 : Intrinsic::experimental_vector_reduce_umin;
376 return getReductionIntrinsic(this, ID, Src);
379 CallInst *IRBuilderBase::CreateFPMaxReduce(Value *Src, bool NoNaN) {
380 auto Rdx = getReductionIntrinsic(
381 this, Intrinsic::experimental_vector_reduce_fmax, Src);
385 Rdx->setFastMathFlags(FMF);
390 CallInst *IRBuilderBase::CreateFPMinReduce(Value *Src, bool NoNaN) {
391 auto Rdx = getReductionIntrinsic(
392 this, Intrinsic::experimental_vector_reduce_fmin, Src);
396 Rdx->setFastMathFlags(FMF);
401 CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
402 assert(isa<PointerType>(Ptr->getType()) &&
403 "lifetime.start only applies to pointers.");
404 Ptr = getCastedInt8PtrValue(Ptr);
408 assert(Size->getType() == getInt64Ty() &&
409 "lifetime.start requires the size to be an i64");
410 Value *Ops[] = { Size, Ptr };
411 Module *M = BB->getParent()->getParent();
412 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start,
414 return createCallHelper(TheFn, Ops, this);
417 CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
418 assert(isa<PointerType>(Ptr->getType()) &&
419 "lifetime.end only applies to pointers.");
420 Ptr = getCastedInt8PtrValue(Ptr);
424 assert(Size->getType() == getInt64Ty() &&
425 "lifetime.end requires the size to be an i64");
426 Value *Ops[] = { Size, Ptr };
427 Module *M = BB->getParent()->getParent();
428 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end,
430 return createCallHelper(TheFn, Ops, this);
433 CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) {
435 assert(isa<PointerType>(Ptr->getType()) &&
436 "invariant.start only applies to pointers.");
437 Ptr = getCastedInt8PtrValue(Ptr);
441 assert(Size->getType() == getInt64Ty() &&
442 "invariant.start requires the size to be an i64");
444 Value *Ops[] = {Size, Ptr};
445 // Fill in the single overloaded type: memory object type.
446 Type *ObjectPtr[1] = {Ptr->getType()};
447 Module *M = BB->getParent()->getParent();
449 Intrinsic::getDeclaration(M, Intrinsic::invariant_start, ObjectPtr);
450 return createCallHelper(TheFn, Ops, this);
453 CallInst *IRBuilderBase::CreateAssumption(Value *Cond) {
454 assert(Cond->getType() == getInt1Ty() &&
455 "an assumption condition must be of type i1");
457 Value *Ops[] = { Cond };
458 Module *M = BB->getParent()->getParent();
459 Value *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume);
460 return createCallHelper(FnAssume, Ops, this);
463 /// Create a call to a Masked Load intrinsic.
464 /// \p Ptr - base pointer for the load
465 /// \p Align - alignment of the source location
466 /// \p Mask - vector of booleans which indicates what vector lanes should
467 /// be accessed in memory
468 /// \p PassThru - pass-through value that is used to fill the masked-off lanes
470 /// \p Name - name of the result variable
471 CallInst *IRBuilderBase::CreateMaskedLoad(Value *Ptr, unsigned Align,
472 Value *Mask, Value *PassThru,
474 auto *PtrTy = cast<PointerType>(Ptr->getType());
475 Type *DataTy = PtrTy->getElementType();
476 assert(DataTy->isVectorTy() && "Ptr should point to a vector");
477 assert(Mask && "Mask should not be all-ones (null)");
479 PassThru = UndefValue::get(DataTy);
480 Type *OverloadedTypes[] = { DataTy, PtrTy };
481 Value *Ops[] = { Ptr, getInt32(Align), Mask, PassThru};
482 return CreateMaskedIntrinsic(Intrinsic::masked_load, Ops,
483 OverloadedTypes, Name);
486 /// Create a call to a Masked Store intrinsic.
487 /// \p Val - data to be stored,
488 /// \p Ptr - base pointer for the store
489 /// \p Align - alignment of the destination location
490 /// \p Mask - vector of booleans which indicates what vector lanes should
491 /// be accessed in memory
492 CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr,
493 unsigned Align, Value *Mask) {
494 auto *PtrTy = cast<PointerType>(Ptr->getType());
495 Type *DataTy = PtrTy->getElementType();
496 assert(DataTy->isVectorTy() && "Ptr should point to a vector");
497 assert(Mask && "Mask should not be all-ones (null)");
498 Type *OverloadedTypes[] = { DataTy, PtrTy };
499 Value *Ops[] = { Val, Ptr, getInt32(Align), Mask };
500 return CreateMaskedIntrinsic(Intrinsic::masked_store, Ops, OverloadedTypes);
503 /// Create a call to a Masked intrinsic, with given intrinsic Id,
504 /// an array of operands - Ops, and an array of overloaded types -
506 CallInst *IRBuilderBase::CreateMaskedIntrinsic(Intrinsic::ID Id,
507 ArrayRef<Value *> Ops,
508 ArrayRef<Type *> OverloadedTypes,
510 Module *M = BB->getParent()->getParent();
511 Value *TheFn = Intrinsic::getDeclaration(M, Id, OverloadedTypes);
512 return createCallHelper(TheFn, Ops, this, Name);
515 /// Create a call to a Masked Gather intrinsic.
516 /// \p Ptrs - vector of pointers for loading
517 /// \p Align - alignment for one element
518 /// \p Mask - vector of booleans which indicates what vector lanes should
519 /// be accessed in memory
520 /// \p PassThru - pass-through value that is used to fill the masked-off lanes
522 /// \p Name - name of the result variable
523 CallInst *IRBuilderBase::CreateMaskedGather(Value *Ptrs, unsigned Align,
524 Value *Mask, Value *PassThru,
526 auto PtrsTy = cast<VectorType>(Ptrs->getType());
527 auto PtrTy = cast<PointerType>(PtrsTy->getElementType());
528 unsigned NumElts = PtrsTy->getVectorNumElements();
529 Type *DataTy = VectorType::get(PtrTy->getElementType(), NumElts);
532 Mask = Constant::getAllOnesValue(VectorType::get(Type::getInt1Ty(Context),
536 PassThru = UndefValue::get(DataTy);
538 Type *OverloadedTypes[] = {DataTy, PtrsTy};
539 Value * Ops[] = {Ptrs, getInt32(Align), Mask, PassThru};
541 // We specify only one type when we create this intrinsic. Types of other
542 // arguments are derived from this type.
543 return CreateMaskedIntrinsic(Intrinsic::masked_gather, Ops, OverloadedTypes,
547 /// Create a call to a Masked Scatter intrinsic.
548 /// \p Data - data to be stored,
549 /// \p Ptrs - the vector of pointers, where the \p Data elements should be
551 /// \p Align - alignment for one element
552 /// \p Mask - vector of booleans which indicates what vector lanes should
553 /// be accessed in memory
554 CallInst *IRBuilderBase::CreateMaskedScatter(Value *Data, Value *Ptrs,
555 unsigned Align, Value *Mask) {
556 auto PtrsTy = cast<VectorType>(Ptrs->getType());
557 auto DataTy = cast<VectorType>(Data->getType());
558 unsigned NumElts = PtrsTy->getVectorNumElements();
561 auto PtrTy = cast<PointerType>(PtrsTy->getElementType());
562 assert(NumElts == DataTy->getVectorNumElements() &&
563 PtrTy->getElementType() == DataTy->getElementType() &&
564 "Incompatible pointer and data types");
568 Mask = Constant::getAllOnesValue(VectorType::get(Type::getInt1Ty(Context),
571 Type *OverloadedTypes[] = {DataTy, PtrsTy};
572 Value * Ops[] = {Data, Ptrs, getInt32(Align), Mask};
574 // We specify only one type when we create this intrinsic. Types of other
575 // arguments are derived from this type.
576 return CreateMaskedIntrinsic(Intrinsic::masked_scatter, Ops, OverloadedTypes);
579 template <typename T0, typename T1, typename T2, typename T3>
580 static std::vector<Value *>
581 getStatepointArgs(IRBuilderBase &B, uint64_t ID, uint32_t NumPatchBytes,
582 Value *ActualCallee, uint32_t Flags, ArrayRef<T0> CallArgs,
583 ArrayRef<T1> TransitionArgs, ArrayRef<T2> DeoptArgs,
584 ArrayRef<T3> GCArgs) {
585 std::vector<Value *> Args;
586 Args.push_back(B.getInt64(ID));
587 Args.push_back(B.getInt32(NumPatchBytes));
588 Args.push_back(ActualCallee);
589 Args.push_back(B.getInt32(CallArgs.size()));
590 Args.push_back(B.getInt32(Flags));
591 Args.insert(Args.end(), CallArgs.begin(), CallArgs.end());
592 Args.push_back(B.getInt32(TransitionArgs.size()));
593 Args.insert(Args.end(), TransitionArgs.begin(), TransitionArgs.end());
594 Args.push_back(B.getInt32(DeoptArgs.size()));
595 Args.insert(Args.end(), DeoptArgs.begin(), DeoptArgs.end());
596 Args.insert(Args.end(), GCArgs.begin(), GCArgs.end());
601 template <typename T0, typename T1, typename T2, typename T3>
602 static CallInst *CreateGCStatepointCallCommon(
603 IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes,
604 Value *ActualCallee, uint32_t Flags, ArrayRef<T0> CallArgs,
605 ArrayRef<T1> TransitionArgs, ArrayRef<T2> DeoptArgs, ArrayRef<T3> GCArgs,
607 // Extract out the type of the callee.
608 auto *FuncPtrType = cast<PointerType>(ActualCallee->getType());
609 assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
610 "actual callee must be a callable value");
612 Module *M = Builder->GetInsertBlock()->getParent()->getParent();
613 // Fill in the one generic type'd argument (the function is also vararg)
614 Type *ArgTypes[] = { FuncPtrType };
615 Function *FnStatepoint =
616 Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_statepoint,
619 std::vector<Value *> Args =
620 getStatepointArgs(*Builder, ID, NumPatchBytes, ActualCallee, Flags,
621 CallArgs, TransitionArgs, DeoptArgs, GCArgs);
622 return createCallHelper(FnStatepoint, Args, Builder, Name);
625 CallInst *IRBuilderBase::CreateGCStatepointCall(
626 uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
627 ArrayRef<Value *> CallArgs, ArrayRef<Value *> DeoptArgs,
628 ArrayRef<Value *> GCArgs, const Twine &Name) {
629 return CreateGCStatepointCallCommon<Value *, Value *, Value *, Value *>(
630 this, ID, NumPatchBytes, ActualCallee, uint32_t(StatepointFlags::None),
631 CallArgs, None /* No Transition Args */, DeoptArgs, GCArgs, Name);
634 CallInst *IRBuilderBase::CreateGCStatepointCall(
635 uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, uint32_t Flags,
636 ArrayRef<Use> CallArgs, ArrayRef<Use> TransitionArgs,
637 ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
638 return CreateGCStatepointCallCommon<Use, Use, Use, Value *>(
639 this, ID, NumPatchBytes, ActualCallee, Flags, CallArgs, TransitionArgs,
640 DeoptArgs, GCArgs, Name);
643 CallInst *IRBuilderBase::CreateGCStatepointCall(
644 uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
645 ArrayRef<Use> CallArgs, ArrayRef<Value *> DeoptArgs,
646 ArrayRef<Value *> GCArgs, const Twine &Name) {
647 return CreateGCStatepointCallCommon<Use, Value *, Value *, Value *>(
648 this, ID, NumPatchBytes, ActualCallee, uint32_t(StatepointFlags::None),
649 CallArgs, None, DeoptArgs, GCArgs, Name);
652 template <typename T0, typename T1, typename T2, typename T3>
653 static InvokeInst *CreateGCStatepointInvokeCommon(
654 IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes,
655 Value *ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest,
656 uint32_t Flags, ArrayRef<T0> InvokeArgs, ArrayRef<T1> TransitionArgs,
657 ArrayRef<T2> DeoptArgs, ArrayRef<T3> GCArgs, const Twine &Name) {
658 // Extract out the type of the callee.
659 auto *FuncPtrType = cast<PointerType>(ActualInvokee->getType());
660 assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
661 "actual callee must be a callable value");
663 Module *M = Builder->GetInsertBlock()->getParent()->getParent();
664 // Fill in the one generic type'd argument (the function is also vararg)
665 Function *FnStatepoint = Intrinsic::getDeclaration(
666 M, Intrinsic::experimental_gc_statepoint, {FuncPtrType});
668 std::vector<Value *> Args =
669 getStatepointArgs(*Builder, ID, NumPatchBytes, ActualInvokee, Flags,
670 InvokeArgs, TransitionArgs, DeoptArgs, GCArgs);
671 return createInvokeHelper(FnStatepoint, NormalDest, UnwindDest, Args, Builder,
675 InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
676 uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
677 BasicBlock *NormalDest, BasicBlock *UnwindDest,
678 ArrayRef<Value *> InvokeArgs, ArrayRef<Value *> DeoptArgs,
679 ArrayRef<Value *> GCArgs, const Twine &Name) {
680 return CreateGCStatepointInvokeCommon<Value *, Value *, Value *, Value *>(
681 this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
682 uint32_t(StatepointFlags::None), InvokeArgs, None /* No Transition Args*/,
683 DeoptArgs, GCArgs, Name);
686 InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
687 uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
688 BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
689 ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
690 ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
691 return CreateGCStatepointInvokeCommon<Use, Use, Use, Value *>(
692 this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest, Flags,
693 InvokeArgs, TransitionArgs, DeoptArgs, GCArgs, Name);
696 InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
697 uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
698 BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
699 ArrayRef<Value *> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
700 return CreateGCStatepointInvokeCommon<Use, Value *, Value *, Value *>(
701 this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
702 uint32_t(StatepointFlags::None), InvokeArgs, None, DeoptArgs, GCArgs,
706 CallInst *IRBuilderBase::CreateGCResult(Instruction *Statepoint,
709 Intrinsic::ID ID = Intrinsic::experimental_gc_result;
710 Module *M = BB->getParent()->getParent();
711 Type *Types[] = {ResultType};
712 Value *FnGCResult = Intrinsic::getDeclaration(M, ID, Types);
714 Value *Args[] = {Statepoint};
715 return createCallHelper(FnGCResult, Args, this, Name);
718 CallInst *IRBuilderBase::CreateGCRelocate(Instruction *Statepoint,
723 Module *M = BB->getParent()->getParent();
724 Type *Types[] = {ResultType};
725 Value *FnGCRelocate =
726 Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_relocate, Types);
728 Value *Args[] = {Statepoint,
729 getInt32(BaseOffset),
730 getInt32(DerivedOffset)};
731 return createCallHelper(FnGCRelocate, Args, this, Name);
734 CallInst *IRBuilderBase::CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
735 Instruction *FMFSource,
737 Module *M = BB->getModule();
738 Function *Fn = Intrinsic::getDeclaration(M, ID, {V->getType()});
739 return createCallHelper(Fn, {V}, this, Name, FMFSource);
742 CallInst *IRBuilderBase::CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS,
744 Instruction *FMFSource,
746 Module *M = BB->getModule();
747 Function *Fn = Intrinsic::getDeclaration(M, ID, { LHS->getType() });
748 return createCallHelper(Fn, {LHS, RHS}, this, Name, FMFSource);
751 CallInst *IRBuilderBase::CreateIntrinsic(Intrinsic::ID ID,
752 ArrayRef<Type *> Types,
753 ArrayRef<Value *> Args,
754 Instruction *FMFSource,
756 Module *M = BB->getModule();
757 Function *Fn = Intrinsic::getDeclaration(M, ID, Types);
758 return createCallHelper(Fn, Args, this, Name, FMFSource);