|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/IR/IntrinsicInst.h 43 class IntrinsicInst : public CallInst {
Declarations
include/llvm/Analysis/AssumptionCache.h 29 class CallInst;
include/llvm/Analysis/MemoryBuiltins.h 33 class CallInst;
include/llvm/CodeGen/FastISel.h 38 class CallInst;
include/llvm/CodeGen/GlobalISel/IRTranslator.h 37 class CallInst;
include/llvm/CodeGen/IntrinsicLowering.h 21 class CallInst;
include/llvm/CodeGen/MachineModuleInfo.h 47 class CallInst;
include/llvm/IR/AutoUpgrade.h 19 class CallInst;
include/llvm/IR/BasicBlock.h 34 class CallInst;
include/llvm/IR/Instruction.def 209 HANDLE_OTHER_INST(56, Call , CallInst ) // Call a function
include/llvm/Transforms/Scalar/GVN.h 41 class CallInst;
include/llvm/Transforms/Scalar/MemCpyOptimizer.h 27 class CallInst;
include/llvm/Transforms/Utils/Cloning.h 37 class CallInst;
include/llvm/Transforms/Utils/CodeExtractor.h 31 class CallInst;
include/llvm/Transforms/Utils/GuardUtils.h 17 class CallInst;
include/llvm/Transforms/Utils/Local.h 44 class CallInst;
include/llvm/Transforms/Utils/SimplifyLibCalls.h 24 class CallInst;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 50 class CallInst;
lib/CodeGen/SelectionDAG/StatepointLowering.h 27 class CallInst;
tools/clang/lib/CodeGen/CGCXXABI.h 24 class CallInst;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h 28 class CallInst;
References
examples/BrainF/BrainF.cpp 97 ptr_arr = CallInst::CreateMalloc(BB, IntPtrTy, Int8Ty, allocsize, val_mem,
111 CallInst *memset_call = builder->
133 endbb->getInstList().push_back(CallInst::CreateFree(ptr_arr, endbb));
178 CallInst *puts_call =
179 CallInst::Create(puts_func,
210 CallInst *getchar_call =
237 CallInst *putchar_call = builder->
examples/BrainF/BrainFDriver.cpp 96 CallInst *brainf_call = CallInst::Create(mod->getFunction("brainf"),
96 CallInst *brainf_call = CallInst::Create(mod->getFunction("brainf"),
examples/Fibonacci/fibonacci.cpp 84 CallInst *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB);
84 CallInst *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB);
89 CallInst *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB);
89 CallInst *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB);
examples/HowToUseJIT/HowToUseJIT.cpp 116 CallInst *Add1CallRes = builder.CreateCall(Add1F, Ten);
examples/ParallelJIT/ParallelJIT.cpp 114 Value *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB);
118 Value *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB);
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Analysis/AssumptionCache.h 104 void registerAssumption(CallInst *CI);
108 void unregisterAssumption(CallInst *CI);
112 void updateAffectedValues(CallInst *CI);
include/llvm/Analysis/MemoryBuiltins.h 119 const CallInst *
122 inline CallInst *
133 PointerType *getMallocType(const CallInst *CI, const TargetLibraryInfo *TLI);
140 Type *getMallocAllocatedType(const CallInst *CI, const TargetLibraryInfo *TLI);
147 Value *getMallocArraySize(CallInst *CI, const DataLayout &DL,
157 const CallInst *extractCallocCall(const Value *I, const TargetLibraryInfo *TLI);
158 inline CallInst *extractCallocCall(Value *I, const TargetLibraryInfo *TLI) {
171 const CallInst *isFreeCall(const Value *I, const TargetLibraryInfo *TLI);
173 inline CallInst *isFreeCall(Value *I, const TargetLibraryInfo *TLI) {
include/llvm/Analysis/ObjCARCAnalysisUtils.h 83 V = cast<CallInst>(V)->getArgOperand(0);
121 V = cast<CallInst>(V)->getArgOperand(0);
138 return GetRCIdentityRoot(cast<CallInst>(Inst)->getArgOperand(0));
216 if (isa<CallInst>(V) || isa<InvokeInst>(V) ||
include/llvm/Analysis/ObjCARCInstKind.h 107 if (const CallInst *CI = dyn_cast<CallInst>(V)) {
107 if (const CallInst *CI = dyn_cast<CallInst>(V)) {
include/llvm/Analysis/TargetTransformInfoImpl.h 900 if (auto *CI = dyn_cast<CallInst>(I)) {
include/llvm/Analysis/TypeMetadataUtils.h 43 SmallVectorImpl<CallInst *> &Assumes, const CallInst *CI,
43 SmallVectorImpl<CallInst *> &Assumes, const CallInst *CI,
52 const CallInst *CI, DominatorTree &DT);
include/llvm/Analysis/VectorUtils.h 161 Intrinsic::ID getVectorIntrinsicIDForCall(const CallInst *CI,
include/llvm/CodeGen/BasicTTIImpl.h 479 if (isa<CallInst>(J) || isa<InvokeInst>(J)) {
include/llvm/CodeGen/CommandFlags.inc 399 if (auto *Call = dyn_cast<CallInst>(&I))
399 if (auto *Call = dyn_cast<CallInst>(&I))
include/llvm/CodeGen/FastISel.h 509 bool lowerCallTo(const CallInst *CI, MCSymbol *Symbol, unsigned NumArgs);
510 bool lowerCallTo(const CallInst *CI, const char *SymName,
526 bool lowerCall(const CallInst *I);
532 bool selectStackmap(const CallInst *I);
533 bool selectPatchpoint(const CallInst *I);
540 bool selectXRayCustomEvent(const CallInst *II);
541 bool selectXRayTypedEvent(const CallInst *II);
590 const CallInst *CI, unsigned StartIdx);
591 bool lowerCallOperands(const CallInst *CI, unsigned ArgIdx, unsigned NumArgs,
include/llvm/CodeGen/GlobalISel/IRTranslator.h 216 bool translateMemFunc(const CallInst &CI, MachineIRBuilder &MIRBuilder,
221 bool translateOverflowIntrinsic(const CallInst &CI, unsigned Op,
232 bool translateSimpleIntrinsic(const CallInst &CI, Intrinsic::ID ID,
235 bool translateKnownIntrinsic(const CallInst &CI, Intrinsic::ID ID,
238 bool translateInlineAsm(const CallInst &CI, MachineIRBuilder &MIRBuilder);
include/llvm/CodeGen/IntrinsicLowering.h 41 void LowerIntrinsicCall(CallInst *CI);
45 static bool LowerToByteSwap(CallInst *CI);
include/llvm/CodeGen/TargetLowering.h 853 virtual bool getTgtMemIntrinsic(IntrinsicInfo &, const CallInst &,
1683 virtual bool shouldAlignPointerArgs(CallInst * /*CI*/, unsigned & /*MinSize*/,
3686 virtual bool mayBeEmittedAsTailCall(const CallInst *) const {
3838 virtual bool ExpandInlineAsm(CallInst *) const {
include/llvm/IR/AutoUpgrade.h 37 void UpgradeIntrinsicCall(CallInst *CI, Function *NewFn);
include/llvm/IR/BasicBlock.h 130 const CallInst *getTerminatingDeoptimizeCall() const;
131 CallInst *getTerminatingDeoptimizeCall() {
139 const CallInst *getTerminatingMustTailCall() const;
140 CallInst *getTerminatingMustTailCall() {
include/llvm/IR/CallSite.h 63 CallSiteBase(CallTy *CI) : I(CI, 1) { assert(CI); }
280 return isCall() && cast<CallInst>(getInstruction())->isMustTailCall();
285 return isCall() && cast<CallInst>(getInstruction())->isTailCall();
673 Instruction, CallInst, InvokeInst,
678 CallSite(CallInst *CI) : CallSiteBase(CI) {}
909 ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {}
include/llvm/IR/DerivedTypes.h 175 FunctionCallee(T *Fn)
include/llvm/IR/IRBuilder.h 267 void setConstrainedFPCallAttr(CallInst *I) {
455 CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align,
463 CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
474 CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
485 CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
497 CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
508 CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
523 CallInst *CreateElementUnorderedAtomicMemCpy(
533 CallInst *CreateElementUnorderedAtomicMemCpy(
545 CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
553 CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
567 CallInst *CreateElementUnorderedAtomicMemMove(
577 CallInst *CreateElementUnorderedAtomicMemMove(
585 CallInst *CreateFAddReduce(Value *Acc, Value *Src);
589 CallInst *CreateFMulReduce(Value *Acc, Value *Src);
592 CallInst *CreateAddReduce(Value *Src);
595 CallInst *CreateMulReduce(Value *Src);
598 CallInst *CreateAndReduce(Value *Src);
601 CallInst *CreateOrReduce(Value *Src);
604 CallInst *CreateXorReduce(Value *Src);
608 CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
612 CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
616 CallInst *CreateFPMaxReduce(Value *Src, bool NoNaN = false);
620 CallInst *CreateFPMinReduce(Value *Src, bool NoNaN = false);
625 CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
630 CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
635 CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
638 CallInst *CreateMaskedLoad(Value *Ptr, unsigned Align, Value *Mask,
642 CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align,
646 CallInst *CreateMaskedGather(Value *Ptrs, unsigned Align,
652 CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Align,
657 CallInst *CreateAssumption(Value *Cond);
661 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
670 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
681 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
717 CallInst *CreateGCResult(Instruction *Statepoint,
723 CallInst *CreateGCRelocate(Instruction *Statepoint,
731 CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
737 CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
744 CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
750 CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
755 CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
760 CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
765 CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
771 CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
845 InstTy *Insert(InstTy *I, const Twine &Name = "") const {
845 InstTy *Insert(InstTy *I, const Twine &Name = "") const {
1483 CallInst *CreateConstrainedFPBinOp(
1495 CallInst *C = CreateIntrinsic(ID, {L->getType()},
2077 CallInst *CreateConstrainedFPCast(
2089 CallInst *C;
2257 CallInst *CreateCall(FunctionType *FTy, Value *Callee,
2260 CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2260 CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2268 CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
2271 CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2271 CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2279 CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = None,
2285 CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
2293 CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
2301 CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
2449 CallInst *Fn = CreateCall(FnLaunderInvariantGroup, {Ptr});
2477 CallInst *Fn = CreateCall(FnStripInvariantGroup, {Ptr});
2545 CallInst *Fn =
2564 CallInst *Fn =
2588 CallInst *Fn = CreateCall(FnPreserveStructAccessIndex,
2601 CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
2639 CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
2666 CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
include/llvm/IR/InstVisitor.h 222 RetTy visitCallInst(CallInst &I) {
302 RetTy delegateCallInst(CallInst &I) {
include/llvm/IR/Instructions.h 1401 CallInst(const CallInst &CI);
1440 CallInst *cloneImpl() const;
1443 static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
1445 return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
1448 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1452 CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
1455 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1464 CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
1467 static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
1469 return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd);
1472 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1475 CallInst(Ty, Func, Args, None, NameStr, InsertAtEnd);
1478 static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1486 CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
1489 static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
1495 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1503 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1510 static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
1516 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1522 static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
1530 static CallInst *Create(Value *Func, const Twine &NameStr = "",
1538 static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1547 static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1557 static CallInst *Create(Value *Func, const Twine &NameStr,
1565 static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1573 static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1587 static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
1587 static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
include/llvm/IR/IntrinsicInst.h 43 class IntrinsicInst : public CallInst {
55 static bool classof(const CallInst *I) {
61 return isa<CallInst>(V) && classof(cast<CallInst>(V));
61 return isa<CallInst>(V) && classof(cast<CallInst>(V));
include/llvm/IR/PatternMatch.h 47 template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
1675 if (const auto *CI = dyn_cast<CallInst>(V))
1675 if (const auto *CI = dyn_cast<CallInst>(V))
1693 template <typename OpTy> bool match(OpTy *V) {
1694 if (const auto *CI = dyn_cast<CallInst>(V))
1694 if (const auto *CI = dyn_cast<CallInst>(V))
include/llvm/Support/Casting.h 34 using SimpleType = From; // The real type this represents...
37 static SimpleType &getSimplifiedValue(From &Val) { return Val; }
41 using NonConstSimpleType = typename simplify_type<From>::SimpleType;
47 static RetType getSimplifiedValue(const From& Val) {
57 static inline bool doit(const From &Val) {
58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
76 static inline bool doit(const From &Val) {
77 return isa_impl<To, From>::doit(Val);
77 return isa_impl<To, From>::doit(Val);
92 return isa_impl<To, From>::doit(*Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
142 return isa_impl_wrap<X, const Y,
142 return isa_impl_wrap<X, const Y,
143 typename simplify_type<const Y>::SimpleType>::doit(Val);
165 using ret_type = To &; // Normal case, return Ty&
168 using ret_type = const To &; // Normal case, return Ty&
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
218 static typename cast_retty<To, From>::ret_type doit(From &Val) {
219 return cast_convert_val<To, SimpleFrom,
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
228 typename cast_retty<To, FromTy>::ret_type Res2
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
248 typename cast_retty<X, const Y>::ret_type>::type
252 X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
258 return cast_convert_val<X, Y,
259 typename simplify_type<Y>::SimpleType>::doit(Val);
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
331 typename cast_retty<X, const Y>::ret_type>::type
333 return isa<X>(Val) ? cast<X>(Val) : nullptr;
333 return isa<X>(Val) ? cast<X>(Val) : nullptr;
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
338 return isa<X>(Val) ? cast<X>(Val) : nullptr;
338 return isa<X>(Val) ? cast<X>(Val) : nullptr;
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
352 typename cast_retty<X, const Y>::ret_type>::type
354 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
354 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
360 typename cast_retty<X, Y>::ret_type>::type
362 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
362 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/type_traits.h 55 struct add_const_past_pointer { using type = const T; };
include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h 38 bool extractAlignmentInfo(CallInst *I, Value *&AAPtr, const SCEV *&AlignSCEV,
40 bool processAssumption(CallInst *I);
include/llvm/Transforms/Scalar/GVN.h 120 uint32_t lookupOrAddCall(CallInst *C);
include/llvm/Transforms/Scalar/GVNExpression.h 298 CallInst *Call;
301 CallExpression(unsigned NumOperands, CallInst *C,
include/llvm/Transforms/Scalar/MemCpyOptimizer.h 65 uint64_t cpyLen, unsigned cpyAlign, CallInst *C);
include/llvm/Transforms/Utils/CodeExtractor.h 226 CallInst *emitCallAndSwitchStatement(Function *newFunction,
include/llvm/Transforms/Utils/GuardUtils.h 25 void makeGuardControlFlowExplicit(Function *DeoptIntrinsic, CallInst *Guard);
include/llvm/Transforms/Utils/Local.h 278 CallInst *createCallMatchingInvoke(InvokeInst *II);
401 BasicBlock *changeToInvokeAndSplitBasicBlock(CallInst *CI,
518 void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI,
include/llvm/Transforms/Utils/SimplifyLibCalls.h 53 Value *optimizeCall(CallInst *CI);
56 Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
57 Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
58 Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
61 Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
62 Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
63 Value *optimizeMemCCpyChk(CallInst *CI, IRBuilder<> &B);
64 Value *optimizeSNPrintfChk(CallInst *CI, IRBuilder<> &B);
65 Value *optimizeSPrintfChk(CallInst *CI,IRBuilder<> &B);
66 Value *optimizeStrCatChk(CallInst *CI, IRBuilder<> &B);
67 Value *optimizeStrLCat(CallInst *CI, IRBuilder<> &B);
68 Value *optimizeStrNCatChk(CallInst *CI, IRBuilder<> &B);
69 Value *optimizeStrLCpyChk(CallInst *CI, IRBuilder<> &B);
70 Value *optimizeVSNPrintfChk(CallInst *CI, IRBuilder<> &B);
71 Value *optimizeVSPrintfChk(CallInst *CI, IRBuilder<> &B);
91 bool isFortifiedCallFoldable(CallInst *CI, unsigned ObjSizeOp,
135 Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B);
153 Value *optimizeCall(CallInst *CI);
157 Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B);
158 Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B);
159 Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B);
160 Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B);
161 Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B);
162 Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B);
163 Value *optimizeStrNDup(CallInst *CI, IRBuilder<> &B);
164 Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B);
165 Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B);
166 Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B);
167 Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B);
168 Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B);
169 Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B);
170 Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B);
171 Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B);
172 Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B);
173 Value *optimizeMemChr(CallInst *CI, IRBuilder<> &B);
174 Value *optimizeMemRChr(CallInst *CI, IRBuilder<> &B);
175 Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
176 Value *optimizeBCmp(CallInst *CI, IRBuilder<> &B);
177 Value *optimizeMemCmpBCmpCommon(CallInst *CI, IRBuilder<> &B);
178 Value *optimizeMemPCpy(CallInst *CI, IRBuilder<> &B);
179 Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
180 Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
181 Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
182 Value *optimizeRealloc(CallInst *CI, IRBuilder<> &B);
183 Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
184 Value *optimizeBCopy(CallInst *CI, IRBuilder<> &B);
186 Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
189 Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
190 Value *optimizePow(CallInst *CI, IRBuilder<> &B);
191 Value *replacePowWithExp(CallInst *Pow, IRBuilder<> &B);
192 Value *replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B);
193 Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
194 Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
195 Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
196 Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
197 Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
198 Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
200 Value *optimizeFloatingPointLibCall(CallInst *CI, LibFunc Func,
204 Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
205 Value *optimizeFls(CallInst *CI, IRBuilder<> &B);
206 Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
207 Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
208 Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
209 Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
210 Value *optimizeAtoi(CallInst *CI, IRBuilder<> &B);
211 Value *optimizeStrtol(CallInst *CI, IRBuilder<> &B);
214 Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
216 Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
217 Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
218 Value *optimizeSnPrintF(CallInst *CI, IRBuilder<> &B);
219 Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
220 Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
221 Value *optimizeFRead(CallInst *CI, IRBuilder<> &B);
222 Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
223 Value *optimizeFGets(CallInst *CI, IRBuilder<> &B);
224 Value *optimizeFPutc(CallInst *CI, IRBuilder<> &B);
225 Value *optimizeFGetc(CallInst *CI, IRBuilder<> &B);
226 Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
231 SmallVectorImpl<CallInst *> &SinCalls,
232 SmallVectorImpl<CallInst *> &CosCalls,
233 SmallVectorImpl<CallInst *> &SinCosCalls);
234 Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
235 Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
236 Value *optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B);
237 Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
244 Value *optimizeStringLength(CallInst *CI, IRBuilder<> &B, unsigned CharSize);
lib/Analysis/AssumptionCache.cpp 56 static void findAffectedValues(CallInst *CI,
113 void AssumptionCache::updateAffectedValues(CallInst *CI) {
124 void AssumptionCache::unregisterAssumption(CallInst *CI) {
186 updateAffectedValues(cast<CallInst>(A));
189 void AssumptionCache::registerAssumption(CallInst *CI) {
235 OS << " " << *cast<CallInst>(VH)->getArgOperand(0) << "\n";
279 SmallPtrSet<const CallInst *, 4> AssumptionSet;
283 AssumptionSet.insert(cast<CallInst>(VH));
288 !AssumptionSet.count(cast<CallInst>(&II)))
lib/Analysis/BasicAliasAnalysis.cpp 883 if (const CallInst *CI = dyn_cast<CallInst>(Call))
883 if (const CallInst *CI = dyn_cast<CallInst>(Call))
lib/Analysis/BranchProbabilityInfo.cpp 199 if (const CallInst *CI = dyn_cast<CallInst>(&I))
199 if (const CallInst *CI = dyn_cast<CallInst>(&I))
692 if (CallInst *Call = dyn_cast<CallInst>(CI->getOperand(0)))
692 if (CallInst *Call = dyn_cast<CallInst>(CI->getOperand(0)))
lib/Analysis/CodeMetrics.cpp 163 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
163 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
lib/Analysis/GlobalsModRef.cpp 638 if (isa<GlobalValue>(Input) || isa<Argument>(Input) || isa<CallInst>(Input) ||
751 if (isa<Argument>(Input) || isa<CallInst>(Input) ||
lib/Analysis/InlineCost.cpp 1238 if (isa<CallInst>(Call) && cast<CallInst>(Call).cannotDuplicate())
1238 if (isa<CallInst>(Call) && cast<CallInst>(Call).cannotDuplicate())
2116 if (!ReturnsTwice && isa<CallInst>(Call) &&
2117 cast<CallInst>(Call)->canReturnTwice())
lib/Analysis/InstructionSimplify.cpp 5374 Result = SimplifyCall(cast<CallInst>(I), Q);
lib/Analysis/LazyValueInfo.cpp 831 auto *I = cast<CallInst>(AssumeVH);
831 auto *I = cast<CallInst>(AssumeVH);
lib/Analysis/Lint.cpp 102 void visitCallInst(CallInst &I);
300 const CallInst *CI = cast<CallInst>(CS.getInstruction());
300 const CallInst *CI = cast<CallInst>(CS.getInstruction());
393 void Lint::visitCallInst(CallInst &I) {
lib/Analysis/Loads.cpp 299 if (isa<CallInst>(BBI) && BBI->mayWriteToMemory() &&
lib/Analysis/LoopAccessAnalysis.cpp 1840 auto *Call = dyn_cast<CallInst>(&I);
1840 auto *Call = dyn_cast<CallInst>(&I);
lib/Analysis/MemoryBuiltins.cpp 320 const CallInst *llvm::extractMallocCall(
323 return isMallocLikeFn(I, GetTLI) ? dyn_cast<CallInst>(I) : nullptr;
326 static Value *computeArraySize(const CallInst *CI, const DataLayout &DL,
356 PointerType *llvm::getMallocType(const CallInst *CI,
388 Type *llvm::getMallocAllocatedType(const CallInst *CI,
399 Value *llvm::getMallocArraySize(CallInst *CI, const DataLayout &DL,
408 const CallInst *llvm::extractCallocCall(const Value *I,
410 return isCallocLikeFn(I, TLI) ? cast<CallInst>(I) : nullptr;
462 const CallInst *llvm::isFreeCall(const Value *I, const TargetLibraryInfo *TLI) {
474 return isLibFreeFunction(Callee, TLIFn) ? dyn_cast<CallInst>(I) : nullptr;
lib/Analysis/MemoryDependenceAnalysis.cpp 149 if (const CallInst *CI = isFreeCall(Inst, &TLI)) {
lib/Analysis/ModuleSummaryAnalysis.cpp 161 const CallInst *CI, SetVector<GlobalValue::GUID> &TypeTests,
180 auto *AssumeCI = dyn_cast<CallInst>(CIU.getUser());
180 auto *AssumeCI = dyn_cast<CallInst>(CIU.getUser());
190 SmallVector<CallInst *, 4> Assumes;
310 const auto *CI = dyn_cast<CallInst>(&I);
310 const auto *CI = dyn_cast<CallInst>(&I);
lib/Analysis/ObjCARCInstKind.cpp 223 const CallInst *CI = cast<CallInst>(I);
223 const CallInst *CI = cast<CallInst>(I);
lib/Analysis/ProfileSummaryInfo.cpp 155 if (isa<CallInst>(I) || isa<InvokeInst>(I))
184 if (isa<CallInst>(I) || isa<InvokeInst>(I))
209 if (isa<CallInst>(I) || isa<InvokeInst>(I))
lib/Analysis/ScalarEvolution.cpp 7717 if (const CallInst *CI = dyn_cast<CallInst>(I))
7717 if (const CallInst *CI = dyn_cast<CallInst>(I))
9506 auto *CI = cast<CallInst>(AssumeVH);
9506 auto *CI = cast<CallInst>(AssumeVH);
9661 auto *CI = cast<CallInst>(AssumeVH);
9661 auto *CI = cast<CallInst>(AssumeVH);
10991 if (Unknown && !isa<CallInst>(Unknown->getValue())) {
lib/Analysis/ScalarEvolutionExpander.cpp 2287 CallInst *Mul = Builder.CreateCall(MulF, {AbsStep, TruncTripCount}, "mul");
lib/Analysis/TypeMetadataUtils.cpp 26 const CallInst *CI, DominatorTree &DT) {
40 } else if (auto CI = dyn_cast<CallInst>(User)) {
53 int64_t Offset, const CallInst *CI, DominatorTree &DT) {
75 SmallVectorImpl<CallInst *> &Assumes, const CallInst *CI,
75 SmallVectorImpl<CallInst *> &Assumes, const CallInst *CI,
83 if (auto *AssumeCI = dyn_cast<CallInst>(CIU.getUser())) {
83 if (auto *AssumeCI = dyn_cast<CallInst>(CIU.getUser())) {
101 const CallInst *CI, DominatorTree &DT) {
lib/Analysis/ValueTracking.cpp 502 if (const CallInst *CI = dyn_cast<CallInst>(I))
502 if (const CallInst *CI = dyn_cast<CallInst>(I))
593 CallInst *I = cast<CallInst>(AssumeVH);
593 CallInst *I = cast<CallInst>(AssumeVH);
2921 if (auto *Call = dyn_cast<CallInst>(Op)) {
3018 const auto *CI = cast<CallInst>(I);
3018 const auto *CI = cast<CallInst>(I);
3946 auto *CI = cast<const CallInst>(Inst);
lib/Analysis/VectorUtils.cpp 112 Intrinsic::ID llvm::getVectorIntrinsicIDForCall(const CallInst *CI,
lib/AsmParser/LLParser.cpp 150 } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
150 } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
5828 case lltok::kw_call: return ParseCall(Inst, PFS, CallInst::TCK_None);
5829 case lltok::kw_tail: return ParseCall(Inst, PFS, CallInst::TCK_Tail);
5830 case lltok::kw_musttail: return ParseCall(Inst, PFS, CallInst::TCK_MustTail);
5831 case lltok::kw_notail: return ParseCall(Inst, PFS, CallInst::TCK_NoTail);
6760 CallInst::TailCallKind TCK) {
6773 if (TCK != CallInst::TCK_None &&
6784 ParseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
6853 CallInst *CI = CallInst::Create(Ty, Callee, Args, BundleList);
6853 CallInst *CI = CallInst::Create(Ty, Callee, Args, BundleList);
lib/AsmParser/LLParser.h 593 CallInst::TailCallKind TCK);
lib/Bitcode/Reader/BitcodeReader.cpp 5062 I = CallInst::Create(FTy, Callee, Args, OperandBundles);
5066 cast<CallInst>(I)->setCallingConv(
5068 CallInst::TailCallKind TCK = CallInst::TCK_None;
5068 CallInst::TailCallKind TCK = CallInst::TCK_None;
5070 TCK = CallInst::TCK_Tail;
5072 TCK = CallInst::TCK_MustTail;
5074 TCK = CallInst::TCK_NoTail;
5075 cast<CallInst>(I)->setTailCallKind(TCK);
5076 cast<CallInst>(I)->setAttributes(PAL);
5255 if (CallInst *CI = dyn_cast<CallInst>(U))
5255 if (CallInst *CI = dyn_cast<CallInst>(U))
5320 if (CallInst *CI = dyn_cast<CallInst>(U))
5320 if (CallInst *CI = dyn_cast<CallInst>(U))
lib/Bitcode/Writer/BitcodeWriter.cpp 2990 const CallInst &CI = cast<CallInst>(I);
2990 const CallInst &CI = cast<CallInst>(I);
lib/CodeGen/Analysis.cpp 567 AttrBuilder CalleeAttrs(cast<CallInst>(I)->getAttributes(),
637 const CallInst *Call = cast<CallInst>(I);
637 const CallInst *Call = cast<CallInst>(I);
lib/CodeGen/AtomicExpandPass.cpp 1776 CallInst *Call = Builder.CreateCall(LibcallFn, Args);
lib/CodeGen/CodeGenPrepare.cpp 362 bool optimizeInlineAsmInst(CallInst *CS);
363 bool optimizeCallInst(CallInst *CI, bool &ModifiedDT);
1774 bool CodeGenPrepare::optimizeCallInst(CallInst *CI, bool &ModifiedDT) {
2019 CallInst *CI = dyn_cast<CallInst>(IncomingVal);
2019 CallInst *CI = dyn_cast<CallInst>(IncomingVal);
2040 CallInst *CI = dyn_cast<CallInst>(&*RI);
2040 CallInst *CI = dyn_cast<CallInst>(&*RI);
4387 static bool IsOperandAMemoryOperand(CallInst *CI, InlineAsm *IA, Value *OpVal,
4471 if (CallInst *CI = dyn_cast<CallInst>(UserI)) {
4471 if (CallInst *CI = dyn_cast<CallInst>(UserI)) {
5031 bool CodeGenPrepare::optimizeInlineAsmInst(CallInst *CS) {
7052 return optimizeCallInst(cast<CallInst>(I), ModifiedDT);
lib/CodeGen/DwarfEHPrepare.cpp 225 CallInst *CI = CallInst::Create(RewindFunction, ExnObj, "", UnwindBB);
225 CallInst *CI = CallInst::Create(RewindFunction, ExnObj, "", UnwindBB);
250 CallInst *CI = CallInst::Create(RewindFunction, PN, "", UnwindBB);
250 CallInst *CI = CallInst::Create(RewindFunction, PN, "", UnwindBB);
lib/CodeGen/ExpandMemCmp.cpp 61 CallInst *const CI;
114 MemCmpExpansion(CallInst *CI, uint64_t Size,
203 CallInst *const CI, uint64_t Size,
722 static bool expandMemCmp(CallInst *CI, const TargetTransformInfo *TTI,
826 CallInst *CI = dyn_cast<CallInst>(&I);
826 CallInst *CI = dyn_cast<CallInst>(&I);
lib/CodeGen/GCRootLowering.cpp 134 if (CallInst *CI = dyn_cast<CallInst>(I))
134 if (CallInst *CI = dyn_cast<CallInst>(I))
lib/CodeGen/GlobalISel/CallLowering.cpp 76 const FuncInfoTy &FuncInfo) const {
lib/CodeGen/GlobalISel/IRTranslator.cpp 1118 bool IRTranslator::translateMemFunc(const CallInst &CI,
1186 bool IRTranslator::translateOverflowIntrinsic(const CallInst &CI, unsigned Op,
1258 bool IRTranslator::translateSimpleIntrinsic(const CallInst &CI,
1278 bool IRTranslator::translateKnownIntrinsic(const CallInst &CI, Intrinsic::ID ID,
1525 bool IRTranslator::translateInlineAsm(const CallInst &CI,
1585 const CallInst &CI = cast<CallInst>(U);
1585 const CallInst &CI = cast<CallInst>(U);
2208 const auto *CI = dyn_cast<CallInst>(&I);
2208 const auto *CI = dyn_cast<CallInst>(&I);
lib/CodeGen/IntrinsicLowering.cpp 31 static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
31 static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
46 CallInst *NewCI = Builder.CreateCall(FCache, Args);
211 static void ReplaceFPIntrinsicWithCall(CallInst *CI, const char *Fname,
234 void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
488 bool IntrinsicLowering::LowerToByteSwap(CallInst *CI) {
504 Op = CallInst::Create(Int, Op, CI->getName(), CI);
lib/CodeGen/PreISelIntrinsicLowering.cpp 38 auto CI = dyn_cast<CallInst>(I->getUser());
79 auto *CI = cast<CallInst>(I->getUser());
79 auto *CI = cast<CallInst>(I->getUser());
85 CallInst *NewCI = Builder.CreateCall(FCache, Args);
lib/CodeGen/SafeStack.cpp 400 } else if (auto CI = dyn_cast<CallInst>(&I)) {
719 if (!isa<CallInst>(UnsafeStackPtr))
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp 65 bool optimizeCallInst(CallInst *CI, bool &ModifiedDT);
126 static void scalarizeMaskedLoad(CallInst *CI, bool &ModifiedDT) {
264 static void scalarizeMaskedStore(CallInst *CI, bool &ModifiedDT) {
389 static void scalarizeMaskedGather(CallInst *CI, bool &ModifiedDT) {
513 static void scalarizeMaskedScatter(CallInst *CI, bool &ModifiedDT) {
598 static void scalarizeMaskedExpandLoad(CallInst *CI, bool &ModifiedDT) {
711 static void scalarizeMaskedCompressStore(CallInst *CI, bool &ModifiedDT) {
838 if (CallInst *CI = dyn_cast<CallInst>(&*CurInstIterator++))
838 if (CallInst *CI = dyn_cast<CallInst>(&*CurInstIterator++))
847 bool ScalarizeMaskedMemIntrin::optimizeCallInst(CallInst *CI,
lib/CodeGen/SelectionDAG/FastISel.cpp 761 const CallInst *CI, unsigned StartIdx) {
790 bool FastISel::selectStackmap(const CallInst *I) {
867 bool FastISel::lowerCallOperands(const CallInst *CI, unsigned ArgIdx,
903 bool FastISel::selectPatchpoint(const CallInst *I) {
1041 bool FastISel::selectXRayCustomEvent(const CallInst *I) {
1060 bool FastISel::selectXRayTypedEvent(const CallInst *I) {
1096 bool FastISel::lowerCallTo(const CallInst *CI, const char *SymName,
1105 bool FastISel::lowerCallTo(const CallInst *CI, MCSymbol *Symbol,
1248 bool FastISel::lowerCall(const CallInst *CI) {
1288 const CallInst *Call = cast<CallInst>(I);
1288 const CallInst *Call = cast<CallInst>(I);
1615 if (const auto *Call = dyn_cast<CallInst>(I)) {
1615 if (const auto *Call = dyn_cast<CallInst>(I)) {
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 180 if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
211 if (const auto *CI = dyn_cast<CallInst>(&I)) {
211 if (const auto *CI = dyn_cast<CallInst>(&I)) {
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 171 if (auto *CI = dyn_cast<CallInst>(V)) {
345 if (const CallInst *CI = dyn_cast<CallInst>(I))
345 if (const CallInst *CI = dyn_cast<CallInst>(I))
2951 if (const CallInst *Call = dyn_cast<CallInst>(&*PredI)) {
2951 if (const CallInst *Call = dyn_cast<CallInst>(&*PredI)) {
4265 void SelectionDAGBuilder::visitMaskedStore(const CallInst &I,
4384 void SelectionDAGBuilder::visitMaskedScatter(const CallInst &I) {
4426 void SelectionDAGBuilder::visitMaskedLoad(const CallInst &I, bool IsExpanding) {
4490 void SelectionDAGBuilder::visitMaskedGather(const CallInst &I) {
4760 void SelectionDAGBuilder::visitTargetIntrinsic(const CallInst &I,
5629 void SelectionDAGBuilder::lowerCallToExternalSymbol(const CallInst &I,
5639 void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
7260 bool SelectionDAGBuilder::visitMemCmpCall(const CallInst &I) {
7352 bool SelectionDAGBuilder::visitMemChrCall(const CallInst &I) {
7376 bool SelectionDAGBuilder::visitMemPCpyCall(const CallInst &I) {
7416 bool SelectionDAGBuilder::visitStrCpyCall(const CallInst &I, bool isStpcpy) {
7439 bool SelectionDAGBuilder::visitStrCmpCall(const CallInst &I) {
7462 bool SelectionDAGBuilder::visitStrLenCall(const CallInst &I) {
7483 bool SelectionDAGBuilder::visitStrNLenCall(const CallInst &I) {
7505 bool SelectionDAGBuilder::visitUnaryFloatCall(const CallInst &I,
7521 bool SelectionDAGBuilder::visitBinaryFloatCall(const CallInst &I,
7534 void SelectionDAGBuilder::visitCall(const CallInst &I) {
8538 void SelectionDAGBuilder::visitVAStart(const CallInst &I) {
8560 void SelectionDAGBuilder::visitVAEnd(const CallInst &I) {
8567 void SelectionDAGBuilder::visitVACopy(const CallInst &I) {
8686 void SelectionDAGBuilder::visitStackmap(const CallInst &CI) {
8899 void SelectionDAGBuilder::visitVectorReduce(const CallInst &I,
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 616 void LowerDeoptimizeCall(const CallInst *CI);
723 void visitMaskedLoad(const CallInst &I, bool IsExpanding = false);
724 void visitMaskedStore(const CallInst &I, bool IsCompressing = false);
725 void visitMaskedGather(const CallInst &I);
726 void visitMaskedScatter(const CallInst &I);
731 void visitCall(const CallInst &I);
732 bool visitMemCmpCall(const CallInst &I);
733 bool visitMemPCpyCall(const CallInst &I);
734 bool visitMemChrCall(const CallInst &I);
735 bool visitStrCpyCall(const CallInst &I, bool isStpcpy);
736 bool visitStrCmpCall(const CallInst &I);
737 bool visitStrLenCall(const CallInst &I);
738 bool visitStrNLenCall(const CallInst &I);
739 bool visitUnaryFloatCall(const CallInst &I, unsigned Opcode);
740 bool visitBinaryFloatCall(const CallInst &I, unsigned Opcode);
747 void visitIntrinsicCall(const CallInst &I, unsigned Intrinsic);
748 void visitTargetIntrinsic(const CallInst &I, unsigned Intrinsic);
751 void visitVAStart(const CallInst &I);
753 void visitVAEnd(const CallInst &I);
754 void visitVACopy(const CallInst &I);
755 void visitStackmap(const CallInst &I);
763 void visitVectorReduce(const CallInst &I, unsigned Intrinsic);
799 void lowerCallToExternalSymbol(const CallInst &I, const char *FunctionName);
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 1497 if (isa<CallInst>(Inst) && !isStatepoint(Inst) && !isGCRelocate(Inst) &&
lib/CodeGen/SelectionDAG/StatepointLowering.cpp 1047 void SelectionDAGBuilder::LowerDeoptimizeCall(const CallInst *CI) {
lib/CodeGen/SelectionDAG/StatepointLowering.h 68 void scheduleRelocCall(const CallInst &RelocCall) {
77 void relocCallVisited(const CallInst &RelocCall) {
123 SmallVector<const CallInst *, 10> PendingGCRelocateCalls;
lib/CodeGen/ShadowStackGCLowering.cpp 61 std::vector<std::pair<CallInst *, AllocaInst *>> Roots;
234 SmallVector<std::pair<CallInst *, AllocaInst *>, 16> MetaRoots;
241 std::pair<CallInst *, AllocaInst *> Pair = std::make_pair(
lib/CodeGen/SjLjEHPrepare.cpp 424 CallInst::Create(CallSiteFn, CallSiteNum, "", Invokes[I]);
441 CallInst *Register =
442 CallInst::Create(RegisterFn, FuncCtx, "", EntryBB->getTerminator());
451 if (auto *CI = dyn_cast<CallInst>(&I)) {
451 if (auto *CI = dyn_cast<CallInst>(&I)) {
457 Instruction *StackAddr = CallInst::Create(StackAddrFn, "sp");
467 CallInst::Create(UnregisterFn, FuncCtx, "", Return);
lib/CodeGen/StackProtector.cpp 180 const auto *CI = cast<CallInst>(I);
180 const auto *CI = cast<CallInst>(I);
223 static const CallInst *findStackProtectorIntrinsic(Function &F) {
226 if (const CallInst *CI = dyn_cast<CallInst>(&I))
226 if (const CallInst *CI = dyn_cast<CallInst>(&I))
431 const CallInst *SPCall = findStackProtectorIntrinsic(*F);
449 CallInst *Call = B.CreateCall(GuardCheck, {Guard});
lib/CodeGen/WasmEHPrepare.cpp 185 auto *ThrowI = cast<CallInst>(U);
185 auto *ThrowI = cast<CallInst>(U);
283 if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
283 if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
335 CallInst *PersCI = IRB.CreateCall(CallPersonalityF, ExtractExnCI,
lib/CodeGen/WinEHPrepare.cpp 968 auto *CI = cast<CallInst>(&*CallI);
968 auto *CI = cast<CallInst>(&*CallI);
lib/ExecutionEngine/Interpreter/Execution.cpp 1146 IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
lib/ExecutionEngine/Interpreter/Interpreter.h 154 void visitCallInst(CallInst &I) { visitCallSite (CallSite (&I)); }
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 247 CallInst *Call = Builder.CreateCall(F.getFunctionType(), ImplAddr, CallArgs);
lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp 62 if (auto CI = dyn_cast<CallInst>(&I))
lib/IR/AsmWriter.cpp 1068 if (const CallInst *CI = dyn_cast<CallInst>(&I))
1068 if (const CallInst *CI = dyn_cast<CallInst>(&I))
3677 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3677 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3839 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3839 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
4270 if (const auto *CI = dyn_cast<CallInst>(&I))
4270 if (const auto *CI = dyn_cast<CallInst>(&I))
lib/IR/AutoUpgrade.cpp 1031 static Value *UpgradeX86VPERMT2Intrinsics(IRBuilder<> &Builder, CallInst &CI,
1092 static Value *UpgradeX86AddSubSatIntrinsics(IRBuilder<> &Builder, CallInst &CI,
1112 static Value *upgradeX86Rotate(IRBuilder<> &Builder, CallInst &CI,
1139 static Value *upgradeX86vpcom(IRBuilder<> &Builder, CallInst &CI, unsigned Imm,
1178 static Value *upgradeX86ConcatShift(IRBuilder<> &Builder, CallInst &CI,
1252 static Value *upgradeAbs(IRBuilder<> &Builder, CallInst &CI) {
1266 static Value *upgradeIntMinMax(IRBuilder<> &Builder, CallInst &CI,
1279 static Value *upgradePMULDQ(IRBuilder<> &Builder, CallInst &CI, bool IsSigned) {
1331 static Value *upgradeMaskedCompare(IRBuilder<> &Builder, CallInst &CI,
1361 static Value *UpgradeX86MaskedShift(IRBuilder<> &Builder, CallInst &CI,
1369 static Value* upgradeMaskedMove(IRBuilder<> &Builder, CallInst &CI) {
1384 static Value* UpgradeMaskToInt(IRBuilder<> &Builder, CallInst &CI) {
1394 CallInst &CI, Value *&Rep) {
1646 void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
3491 CallInst *NewCall = nullptr;
3735 if (CallInst *CI = dyn_cast<CallInst>(*UI++))
3735 if (CallInst *CI = dyn_cast<CallInst>(*UI++))
3872 CallInst *CI = dyn_cast<CallInst>(*I++);
3872 CallInst *CI = dyn_cast<CallInst>(*I++);
3911 CallInst *NewCall = Builder.CreateCall(NewFuncTy, NewFn, Args);
3912 NewCall->setTailCallKind(cast<CallInst>(CI)->getTailCallKind());
lib/IR/BasicBlock.cpp 150 const CallInst *BasicBlock::getTerminatingMustTailCall() const {
174 if (auto *CI = dyn_cast<CallInst>(Prev)) {
181 const CallInst *BasicBlock::getTerminatingDeoptimizeCall() const {
188 if (auto *CI = dyn_cast_or_null<CallInst>(RI->getPrevNode()))
lib/IR/Core.cpp 2850 return unwrap<CallInst>(Call)->isTailCall();
2854 unwrap<CallInst>(Call)->setTailCall(isTailCall);
3425 Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(),
3436 Instruction* Malloc = CallInst::CreateMalloc(unwrap(B)->GetInsertBlock(),
3478 CallInst::CreateFree(unwrap(PointerVal), unwrap(B)->GetInsertBlock())));
lib/IR/IRBuilder.cpp 74 static CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
78 CallInst *CI = CallInst::Create(Callee, Ops, Name);
78 CallInst *CI = CallInst::Create(Callee, Ops, Name);
99 CallInst *IRBuilderBase::
109 CallInst *CI = createCallHelper(TheFn, Ops, this);
127 CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet(
140 CallInst *CI = createCallHelper(TheFn, Ops, this);
157 CallInst *IRBuilderBase::
171 CallInst *CI = createCallHelper(TheFn, Ops, this);
196 CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemCpy(
213 CallInst *CI = createCallHelper(TheFn, Ops, this);
237 CallInst *IRBuilderBase::
251 CallInst *CI = createCallHelper(TheFn, Ops, this);
272 CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemMove(
289 CallInst *CI = createCallHelper(TheFn, Ops, this);
314 static CallInst *getReductionIntrinsic(IRBuilderBase *Builder, Intrinsic::ID ID,
323 CallInst *IRBuilderBase::CreateFAddReduce(Value *Acc, Value *Src) {
332 CallInst *IRBuilderBase::CreateFMulReduce(Value *Acc, Value *Src) {
341 CallInst *IRBuilderBase::CreateAddReduce(Value *Src) {
346 CallInst *IRBuilderBase::CreateMulReduce(Value *Src) {
351 CallInst *IRBuilderBase::CreateAndReduce(Value *Src) {
356 CallInst *IRBuilderBase::CreateOrReduce(Value *Src) {
361 CallInst *IRBuilderBase::CreateXorReduce(Value *Src) {
366 CallInst *IRBuilderBase::CreateIntMaxReduce(Value *Src, bool IsSigned) {
372 CallInst *IRBuilderBase::CreateIntMinReduce(Value *Src, bool IsSigned) {
378 CallInst *IRBuilderBase::CreateFPMaxReduce(Value *Src, bool NoNaN) {
389 CallInst *IRBuilderBase::CreateFPMinReduce(Value *Src, bool NoNaN) {
400 CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
416 CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
432 CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) {
452 CallInst *IRBuilderBase::CreateAssumption(Value *Cond) {
470 CallInst *IRBuilderBase::CreateMaskedLoad(Value *Ptr, unsigned Align,
491 CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr,
505 CallInst *IRBuilderBase::CreateMaskedIntrinsic(Intrinsic::ID Id,
522 CallInst *IRBuilderBase::CreateMaskedGather(Value *Ptrs, unsigned Align,
553 CallInst *IRBuilderBase::CreateMaskedScatter(Value *Data, Value *Ptrs,
601 static CallInst *CreateGCStatepointCallCommon(
624 CallInst *IRBuilderBase::CreateGCStatepointCall(
633 CallInst *IRBuilderBase::CreateGCStatepointCall(
642 CallInst *IRBuilderBase::CreateGCStatepointCall(
705 CallInst *IRBuilderBase::CreateGCResult(Instruction *Statepoint,
717 CallInst *IRBuilderBase::CreateGCRelocate(Instruction *Statepoint,
733 CallInst *IRBuilderBase::CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
741 CallInst *IRBuilderBase::CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS,
750 CallInst *IRBuilderBase::CreateIntrinsic(Intrinsic::ID ID,
lib/IR/Instruction.cpp 402 if (const CallInst *CI = dyn_cast<CallInst>(I1))
402 if (const CallInst *CI = dyn_cast<CallInst>(I1))
403 return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
404 CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
405 CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
406 CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
593 if (const CallInst *CI = dyn_cast<CallInst>(this))
593 if (const CallInst *CI = dyn_cast<CallInst>(this))
603 return (!isa<CallInst>(this) || !this->mayHaveSideEffects()) &&
lib/IR/Instructions.cpp 270 if (const CallInst *CI = dyn_cast<CallInst>(this))
270 if (const CallInst *CI = dyn_cast<CallInst>(this))
279 if (auto *CI = dyn_cast<CallInst>(this))
286 if (auto *CI = dyn_cast<CallInst>(this))
436 CallInst::CallInst(const CallInst &CI)
449 CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
449 CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
453 auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledValue(),
453 auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledValue(),
575 CallInst *MCall = nullptr;
578 MCall = CallInst::Create(MallocFunc, AllocSize, OpB, "malloccall",
585 MCall = CallInst::Create(MallocFunc, AllocSize, OpB, "malloccall");
668 CallInst *Result = nullptr;
673 Result = CallInst::Create(FreeFunc, PtrCast, Bundles, "", InsertBefore);
677 Result = CallInst::Create(FreeFunc, PtrCast, Bundles, "");
4224 CallInst *CallInst::cloneImpl() const {
4227 return new(getNumOperands(), DescriptorBytes) CallInst(*this);
4229 return new(getNumOperands()) CallInst(*this);
lib/IR/Verifier.cpp 460 void visitCallInst(CallInst &CI);
498 void verifyMustTailCall(CallInst &CI);
2039 const CallInst *UserCall = dyn_cast<const CallInst>(U);
2039 const CallInst *UserCall = dyn_cast<const CallInst>(U);
3049 void Verifier::verifyMustTailCall(CallInst &CI) {
3113 void Verifier::visitCallInst(CallInst &CI) {
3789 } else if (isa<CallInst>(U)) {
4037 else if (isa<CallInst>(&I) || isa<InvokeInst>(&I))
4467 if (auto *CI = dyn_cast<CallInst>(&Call))
4467 if (auto *CI = dyn_cast<CallInst>(&Call))
4670 if (isa<CallInst>(Call)) {
lib/Target/AArch64/AArch64ISelLowering.cpp 8361 const CallInst &I,
8852 CallInst *LdN = Builder.CreateCall(
11852 bool AArch64TargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
lib/Target/AArch64/AArch64ISelLowering.h 339 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
746 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/AArch64/AArch64PromoteConstant.cpp 305 const CallInst *CI = dyn_cast<const CallInst>(Instr);
305 const CallInst *CI = dyn_cast<const CallInst>(Instr);
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp 449 CallInst *const Ballot = B.CreateIntrinsic(
497 CallInst *const ReadLaneLo = B.CreateIntrinsic(
499 CallInst *const ReadLaneHi = B.CreateIntrinsic(
596 CallInst *const ReadFirstLaneLo =
598 CallInst *const ReadFirstLaneHi =
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp 691 CallInst *FQ = Builder.CreateUnaryIntrinsic(Intrinsic::trunc, FQM);
lib/Target/AMDGPU/AMDGPUInline.cpp 165 if (!isa<CallInst>(I)) {
lib/Target/AMDGPU/AMDGPULibCalls.cpp 76 bool replaceWithNative(CallInst *CI, const FuncInfo &FInfo);
81 bool TDOFold(CallInst *CI, const FuncInfo &FInfo);
86 bool fold_recip(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
89 bool fold_divide(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
92 bool fold_pow(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
95 bool fold_rootn(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
98 bool fold_fma_mad(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
101 bool sincosUseNative(CallInst *aCI, const FuncInfo &FInfo);
106 bool evaluateCall(CallInst *aCI, FuncInfo &FInfo);
109 bool fold_exp(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
112 bool fold_exp2(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
115 bool fold_exp10(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
118 bool fold_log(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
121 bool fold_log2(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
124 bool fold_log10(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
127 bool fold_sqrt(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
130 bool fold_sincos(CallInst * CI, IRBuilder<> &B, AliasAnalysis * AA);
133 bool fold_read_write_pipe(CallInst *CI, IRBuilder<> &B, FuncInfo &FInfo);
136 bool fold_wavefrontsize(CallInst *CI, IRBuilder<> &B);
139 BasicBlock::iterator getEntryIns(CallInst * UI);
141 AllocaInst* insertAlloca(CallInst * UI, IRBuilder<> &B, const char *prefix);
146 CallInst *CI;
148 bool isUnsafeMath(const CallInst *CI) const;
158 bool fold(CallInst *CI, AliasAnalysis *AA = nullptr);
163 bool useNative(CallInst *CI);
223 static CallInst *CreateCallEx(IRB &B, FunctionCallee Callee, Value *Arg,
225 CallInst *R = B.CreateCall(Callee, Arg, Name);
232 static CallInst *CreateCallEx2(IRB &B, FunctionCallee Callee, Value *Arg1,
234 CallInst *R = B.CreateCall(Callee, {Arg1, Arg2}, Name);
491 bool AMDGPULibCalls::isUnsafeMath(const CallInst *CI) const {
511 bool AMDGPULibCalls::sincosUseNative(CallInst *aCI, const FuncInfo &FInfo) {
531 Value *sinval = CallInst::Create(sinExpr, opr0, "splitsin", aCI);
532 Value *cosval = CallInst::Create(cosExpr, opr0, "splitcos", aCI);
545 bool AMDGPULibCalls::useNative(CallInst *aCI) {
578 bool AMDGPULibCalls::fold_read_write_pipe(CallInst *CI, IRBuilder<> &B,
629 auto *NCI = B.CreateCall(F, Args);
639 bool AMDGPULibCalls::fold(CallInst *CI, AliasAnalysis *AA) {
735 bool AMDGPULibCalls::TDOFold(CallInst *CI, const FuncInfo &FInfo) {
799 bool AMDGPULibCalls::replaceWithNative(CallInst *CI, const FuncInfo &FInfo) {
821 bool AMDGPULibCalls::fold_recip(CallInst *CI, IRBuilder<> &B,
839 bool AMDGPULibCalls::fold_divide(CallInst *CI, IRBuilder<> &B,
869 bool AMDGPULibCalls::fold_pow(CallInst *CI, IRBuilder<> &B,
1154 bool AMDGPULibCalls::fold_rootn(CallInst *CI, IRBuilder<> &B,
1208 bool AMDGPULibCalls::fold_fma_mad(CallInst *CI, IRBuilder<> &B,
1263 bool AMDGPULibCalls::fold_sqrt(CallInst *CI, IRBuilder<> &B,
1281 bool AMDGPULibCalls::fold_sincos(CallInst *CI, IRBuilder<> &B,
1314 CallInst *UI = nullptr;
1316 CallInst *XI = dyn_cast_or_null<CallInst>(U);
1316 CallInst *XI = dyn_cast_or_null<CallInst>(U);
1359 CallInst *Call = CreateCallEx2(B, Fsincos, UI->getArgOperand(0), P);
1381 bool AMDGPULibCalls::fold_wavefrontsize(CallInst *CI, IRBuilder<> &B) {
1405 BasicBlock::iterator AMDGPULibCalls::getEntryIns(CallInst * UI) {
1414 AllocaInst* AMDGPULibCalls::insertAlloca(CallInst *UI, IRBuilder<> &B,
1622 bool AMDGPULibCalls::evaluateCall(CallInst *aCI, FuncInfo &FInfo) {
1758 CallInst *CI = dyn_cast<CallInst>(I);
1758 CallInst *CI = dyn_cast<CallInst>(I);
1783 CallInst *CI = dyn_cast<CallInst>(I);
1783 CallInst *CI = dyn_cast<CallInst>(I);
lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp 122 auto *CI = dyn_cast<CallInst>(U);
122 auto *CI = dyn_cast<CallInst>(U);
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp 84 CallInst *KernArgSegment =
lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp 51 bool processUse(CallInst *CI);
72 bool AMDGPULowerKernelAttributes::processUse(CallInst *CI) {
250 CallInst *CI = cast<CallInst>(U);
250 CallInst *CI = cast<CallInst>(U);
lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp 82 if (auto *CI = dyn_cast<CallInst>(&*U)) {
82 if (auto *CI = dyn_cast<CallInst>(&*U)) {
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 75 SmallVector<CallInst *, 32> Printfs;
351 CallInst *pcall =
352 CallInst::Create(PrintfAllocFn, alloc_args, "printf_alloc_fn", CI);
575 if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
575 if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp 191 CallInst *LocalSizeY = Builder.CreateCall(LocalSizeYFn, {});
192 CallInst *LocalSizeZ = Builder.CreateCall(LocalSizeZFn, {});
237 CallInst *DispatchPtr = Builder.CreateCall(DispatchPtrFn, {});
292 CallInst *CI = Builder.CreateCall(WorkitemIdFn);
467 static bool isCallPromotable(CallInst *CI) {
530 if (CallInst *CI = dyn_cast<CallInst>(User)) {
530 if (CallInst *CI = dyn_cast<CallInst>(User)) {
830 CallInst *Call = dyn_cast<CallInst>(V);
830 CallInst *Call = dyn_cast<CallInst>(V);
924 CallInst *NewCall = Builder.CreateCall(
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp 445 CallInst *StubCall = B.CreateCall(NewFunc, StubCallArgs);
lib/Target/AMDGPU/AMDGPUSubtarget.cpp 439 if (auto *CI = dyn_cast<CallInst>(I)) {
439 if (auto *CI = dyn_cast<CallInst>(I)) {
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp 572 if (isa<CallInst>(V) || isa<InvokeInst>(V))
lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp 242 CallInst::Create(UnreachableIntrin, {}, "", UnreachableBlock);
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp 170 auto Inst = dyn_cast<CallInst>(Use.getUser());
203 auto Inst = dyn_cast<CallInst>(Use.getUser());
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 213 Value *Ret = CallInst::Create(If, Term->getCondition(), "", Term);
223 Value *Ret = CallInst::Create(Else, popSaved(), "", Term);
241 return CallInst::Create(IfBreak, Args, "", Insert);
250 return CallInst::Create(IfBreak, Args, "", Insert);
285 Term->setCondition(CallInst::Create(Loop, Arg, "", Term));
316 CallInst::Create(EndCf, Exec, "", FirstInsertionPt);
lib/Target/AMDGPU/SIISelLowering.cpp 905 const CallInst &CI,
2655 bool SITargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
11015 if (const CallInst *CI = dyn_cast<CallInst>(V)) {
11015 if (const CallInst *CI = dyn_cast<CallInst>(V)) {
lib/Target/AMDGPU/SIISelLowering.h 229 bool getTgtMemIntrinsic(IntrinsicInfo &, const CallInst &,
321 bool mayBeEmittedAsTailCall(const CallInst *) const override;
lib/Target/ARC/ARCISelLowering.cpp 705 bool ARCTargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
lib/Target/ARC/ARCISelLowering.h 114 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/ARM/ARMCodeGenPrepare.cpp 245 else if (auto *Call = dyn_cast<CallInst>(V))
245 else if (auto *Call = dyn_cast<CallInst>(V))
277 return isa<CallInst>(V);
597 CallInst *Call = Builder.CreateCall(DSPInst, Args);
630 if (auto *Call = dyn_cast<CallInst>(I)) {
630 if (auto *Call = dyn_cast<CallInst>(I)) {
756 if (auto *Call = dyn_cast<CallInst>(I)) {
756 if (auto *Call = dyn_cast<CallInst>(I)) {
836 auto *Call = cast<CallInst>(I);
836 auto *Call = cast<CallInst>(I);
lib/Target/ARM/ARMFastISel.cpp 2295 const CallInst *CI = cast<CallInst>(I);
2295 const CallInst *CI = cast<CallInst>(I);
lib/Target/ARM/ARMISelLowering.cpp 1710 bool ARMTargetLowering::shouldAlignPointerArgs(CallInst *CI, unsigned &MinSize,
2943 bool ARMTargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
15559 bool ARMTargetLowering::ExpandInlineAsm(CallInst *CI) const {
16241 const CallInst &I,
16812 CallInst *VldN = Builder.CreateCall(VldnFunc, Ops, "vldN");
lib/Target/ARM/ARMISelLowering.h 419 bool ExpandInlineAsm(CallInst *CI) const override;
488 bool shouldAlignPointerArgs(CallInst *CI, unsigned &MinSize,
509 const CallInst &I,
816 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/ARM/ARMTargetTransformInfo.cpp 883 if (auto *Call = dyn_cast<CallInst>(&I)) {
883 if (auto *Call = dyn_cast<CallInst>(&I)) {
1040 if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
lib/Target/BPF/BPFAbstractMemberAccess.cpp 123 typedef std::stack<std::pair<CallInst *, CallInfo>> CallInfoStack;
135 std::map<CallInst *, std::pair<CallInst *, CallInfo>> AIChain;
135 std::map<CallInst *, std::pair<CallInst *, CallInfo>> AIChain;
139 std::map<CallInst *, CallInfo> BaseAICalls;
143 void traceAICall(CallInst *Call, CallInfo &ParentInfo);
144 void traceBitCast(BitCastInst *BitCast, CallInst *Parent,
146 void traceGEP(GetElementPtrInst *GEP, CallInst *Parent,
150 bool IsPreserveDIAccessIndexCall(const CallInst *Call, CallInfo &Cinfo);
154 void replaceWithGEP(std::vector<CallInst *> &CallList,
163 Value *computeBaseAndAccessKey(CallInst *Call, CallInfo &CInfo,
166 bool transformGEPChain(Module &M, CallInst *Call, CallInfo &CInfo);
231 bool BPFAbstractMemberAccess::IsPreserveDIAccessIndexCall(const CallInst *Call,
280 void BPFAbstractMemberAccess::replaceWithGEP(std::vector<CallInst *> &CallList,
303 std::vector<CallInst *> PreserveArrayIndexCalls;
304 std::vector<CallInst *> PreserveUnionIndexCalls;
305 std::vector<CallInst *> PreserveStructIndexCalls;
311 auto *Call = dyn_cast<CallInst>(&I);
311 auto *Call = dyn_cast<CallInst>(&I);
397 void BPFAbstractMemberAccess::traceAICall(CallInst *Call,
406 } else if (auto *CI = dyn_cast<CallInst>(Inst)) {
406 } else if (auto *CI = dyn_cast<CallInst>(Inst)) {
429 CallInst *Parent,
438 } else if (auto *CI = dyn_cast<CallInst>(Inst)) {
438 } else if (auto *CI = dyn_cast<CallInst>(Inst)) {
459 void BPFAbstractMemberAccess::traceGEP(GetElementPtrInst *GEP, CallInst *Parent,
468 } else if (auto *CI = dyn_cast<CallInst>(Inst)) {
468 } else if (auto *CI = dyn_cast<CallInst>(Inst)) {
496 auto *Call = dyn_cast<CallInst>(&I);
496 auto *Call = dyn_cast<CallInst>(&I);
694 Value *BPFAbstractMemberAccess::computeBaseAndAccessKey(CallInst *Call,
840 bool BPFAbstractMemberAccess::transformGEPChain(Module &M, CallInst *Call,
lib/Target/Hexagon/HexagonISelLowering.cpp 233 bool HexagonTargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
1777 const CallInst &I,
lib/Target/Hexagon/HexagonISelLowering.h 121 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
230 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 2157 CallInst *NewCall;
lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp 301 bool isCallInstCommutative(CallInst *C);
336 bool HexagonVectorLoopCarriedReuse::isCallInstCommutative(CallInst *C) {
408 if (CallInst *C1 = dyn_cast<CallInst>(I1)) {
408 if (CallInst *C1 = dyn_cast<CallInst>(I1)) {
409 if (CallInst *C2 = dyn_cast<CallInst>(I2)) {
409 if (CallInst *C2 = dyn_cast<CallInst>(I2)) {
517 CallInst *C1 = dyn_cast<CallInst>(I);
517 CallInst *C1 = dyn_cast<CallInst>(I);
lib/Target/Mips/Mips16HardFloat.cpp 54 CallInst::Create(IA, AsmArgs, "", BB);
418 CallInst::Create(F, Params, "", &I);
419 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
419 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
lib/Target/Mips/MipsOs16.cpp 97 if (const CallInst *CI = dyn_cast<CallInst>(I)) {
97 if (const CallInst *CI = dyn_cast<CallInst>(I)) {
lib/Target/NVPTX/NVPTXISelLowering.cpp 1318 const CallInst *CallI = cast<CallInst>(CS.getInstruction());
1318 const CallInst *CallI = cast<CallInst>(CS.getInstruction());
1389 if (isa<CallInst>(CalleeI)) {
1391 if (getAlign(*cast<CallInst>(CalleeI), Idx, Align))
1394 const Value *CalleeV = cast<CallInst>(CalleeI)->getCalledValue();
3455 IntrinsicInfo &Info, const CallInst &I,
lib/Target/NVPTX/NVPTXISelLowering.h 450 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
lib/Target/NVPTX/NVPTXImageOptimizer.cpp 64 if (CallInst *CI = dyn_cast<CallInst>(I)) {
64 if (CallInst *CI = dyn_cast<CallInst>(I)) {
150 for (CallInst::use_iterator UI = From->use_begin(), UE = From->use_end();
lib/Target/NVPTX/NVPTXTargetTransformInfo.cpp 106 if (isa<CallInst>(I))
lib/Target/NVPTX/NVPTXUtilities.cpp 299 bool getAlign(const CallInst &I, unsigned index, unsigned &align) {
lib/Target/NVPTX/NVPTXUtilities.h 60 bool getAlign(const CallInst &, unsigned index, unsigned &);
lib/Target/NVPTX/NVVMIntrRange.cpp 66 static bool addRangeMetadata(uint64_t Low, uint64_t High, CallInst *C) {
84 CallInst *Call = dyn_cast<CallInst>(&I);
84 CallInst *Call = dyn_cast<CallInst>(&I);
lib/Target/NVPTX/NVVMReflect.cpp 115 CallInst *Call = dyn_cast<CallInst>(&I);
115 CallInst *Call = dyn_cast<CallInst>(&I);
130 if (const CallInst *ConvCall = dyn_cast<CallInst>(Str)) {
130 if (const CallInst *ConvCall = dyn_cast<CallInst>(Str)) {
lib/Target/PowerPC/PPCBoolRetToInt.cpp 83 if (CurrUser && !isa<CallInst>(Curr))
141 return isa<ReturnInst>(V) || isa<CallInst>(V) || isa<PHINode>(V) ||
145 return isa<Constant>(V) || isa<Argument>(V) || isa<CallInst>(V) ||
208 if (auto *CI = dyn_cast<CallInst>(&I))
208 if (auto *CI = dyn_cast<CallInst>(&I))
231 !isa<Argument>(V) && !isa<CallInst>(V))
241 if (isa<CallInst>(U.getUser()))
257 if (First && !isa<CallInst>(First))
lib/Target/PowerPC/PPCISelLowering.cpp14625 const CallInst &I,
15405 bool PPCTargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
lib/Target/PowerPC/PPCISelLowering.h 875 const CallInst &I,
1225 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/PowerPC/PPCTargetTransformInfo.cpp 265 if (CallInst *CI = dyn_cast<CallInst>(J)) {
265 if (CallInst *CI = dyn_cast<CallInst>(J)) {
lib/Target/RISCV/RISCVISelLowering.cpp 225 const CallInst &I,
lib/Target/RISCV/RISCVISelLowering.h 65 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
lib/Target/SystemZ/SystemZISelLowering.cpp 1215 bool SystemZTargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
lib/Target/SystemZ/SystemZISelLowering.h 486 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/SystemZ/SystemZTDC.cpp 215 if (CallInst *CI = dyn_cast<CallInst>(Op0)) {
215 if (CallInst *CI = dyn_cast<CallInst>(Op0)) {
258 } else if (auto *CI = dyn_cast<CallInst>(Op0)) {
258 } else if (auto *CI = dyn_cast<CallInst>(Op0)) {
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp 248 if (isa<CallInst>(&I) || isa<InvokeInst>(&I)) {
990 if (auto *CI = dyn_cast<CallInst>(I))
lib/Target/WebAssembly/WebAssemblyFastISel.cpp 746 const auto *Call = cast<CallInst>(I);
746 const auto *Call = cast<CallInst>(I);
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp 177 CallInst *Call = CallInst::Create(F, Args, "", BB);
177 CallInst *Call = CallInst::Create(F, Args, "", BB);
241 CallInst *CallMain = nullptr;
267 CallMain = CallInst::Create(MainTy, Casted, Args, "call_main");
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp 571 const CallInst &I,
lib/Target/WebAssembly/WebAssemblyISelLowering.h 69 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp 264 template <typename CallOrInvoke> Function *getInvokeWrapper(CallOrInvoke *CI);
374 Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallOrInvoke *CI) {
399 CallInst *NewCall = IRB.CreateCall(getInvokeWrapper(CI), Args);
771 CallInst *NewCall =
810 auto *CI = dyn_cast<CallInst>(&I);
810 auto *CI = dyn_cast<CallInst>(&I);
820 CallInst *NewCI =
856 CallInst *FMCI = IRB.CreateCall(FMCF, FMCArgs, "fmc");
894 Instruction *SetjmpTable = CallInst::CreateMalloc(
907 auto *CI = dyn_cast<CallInst>(U);
907 auto *CI = dyn_cast<CallInst>(U);
961 auto *CI = dyn_cast<CallInst>(&I);
961 auto *CI = dyn_cast<CallInst>(&I);
1056 CallInst::CreateFree(SetjmpTable, TI);
lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp 150 CallInst::Create(VoidVoid, Dtor, "", BB);
167 Value *Res = CallInst::Create(AtExit, Args, "call", EntryBB);
175 CallInst::Create(Intrinsic::getDeclaration(&M, Intrinsic::trap), "",
lib/Target/X86/X86FastISel.cpp 3188 const CallInst *CI =
3189 CLI.CS ? dyn_cast<CallInst>(CLI.CS->getInstruction()) : nullptr;
lib/Target/X86/X86ISelLowering.cpp 2995 bool X86TargetLowering::mayBeEmittedAsTailCall(const CallInst *CI) const {
3622 const auto *CI = dyn_cast_or_null<CallInst>(CLI.CS.getInstruction());
3622 const auto *CI = dyn_cast_or_null<CallInst>(CLI.CS.getInstruction());
4784 const CallInst &I,
45242 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
lib/Target/X86/X86ISelLowering.h 950 bool ExpandInlineAsm(CallInst *CI) const override;
1070 bool getTgtMemIntrinsic(IntrinsicInfo &Info, const CallInst &I,
1395 bool mayBeEmittedAsTailCall(const CallInst *CI) const override;
lib/Target/X86/X86WinEHState.cpp 415 CallInst *Call = Builder.CreateCall(TargetFuncTy, CastPersonality, Args);
495 auto *CI = cast<CallInst>(Inst);
495 auto *CI = cast<CallInst>(Inst);
496 CallInst *NewCI = Builder.CreateCall(SetJmp3, Args, OpBundles);
lib/Transforms/CFGuard/CFGuard.cpp 173 CallInst *GuardCheck =
208 if (CallInst *CI = dyn_cast<CallInst>(CB)) {
208 if (CallInst *CI = dyn_cast<CallInst>(CB)) {
209 NewCB = CallInst::Create(CI, Bundles, CB);
lib/Transforms/Coroutines/CoroElide.cpp 68 static bool operandReferences(CallInst *CI, AllocaInst *Frame, AAResults &AA) {
81 if (auto *Call = dyn_cast<CallInst>(&I))
81 if (auto *Call = dyn_cast<CallInst>(&I))
lib/Transforms/Coroutines/CoroFrame.cpp 1210 if (isa<CallInst>(Call)) {
lib/Transforms/Coroutines/CoroInternal.h 92 SmallVector<CallInst*, 2> SwiftErrorOps;
lib/Transforms/Coroutines/CoroSplit.cpp 526 for (CallInst *Op : Shape.SwiftErrorOps) {
527 auto MappedOp = VMap ? cast<CallInst>((*VMap)[Op]) : Op;
950 SmallVector<CallInst *, 4> Resumes;
952 if (auto *Call = dyn_cast<CallInst>(&I))
952 if (auto *Call = dyn_cast<CallInst>(&I))
960 for (CallInst *Call : Resumes)
962 Call->setTailCallKind(CallInst::TCK_MustTail);
1404 auto *IndirectCall = CallInst::Create(FnTy, DevirtFnAddr, Null, "", InsertPt);
1404 auto *IndirectCall = CallInst::Create(FnTy, DevirtFnAddr, Null, "", InsertPt);
1436 static void replacePrepare(CallInst *Prepare, CallGraph &CG) {
1501 auto *Prepare = cast<CallInst>((PI++)->getUser());
1501 auto *Prepare = cast<CallInst>((PI++)->getUser());
lib/Transforms/Coroutines/Coroutines.cpp 115 auto *Call = CallInst::Create(Fn, {Arg, IndexVal}, "", InsertPt);
115 auto *Call = CallInst::Create(Fn, {Arg, IndexVal}, "", InsertPt);
241 cast<CoroSaveInst>(CallInst::Create(Fn, CoroBegin, "", SuspendInst));
488 static void propagateCallAttrsFromCallee(CallInst *Call, Function *Callee) {
493 static void addCallToCallGraph(CallGraph *CG, CallInst *Call, Function *Callee){
510 auto *Call = Builder.CreateCall(Alloc, Size);
530 auto *Call = Builder.CreateCall(Dealloc, Ptr);
lib/Transforms/IPO/ArgumentPromotion.cpp 332 auto *NewCall = CallInst::Create(NF, Args, OpBundles, "", Call);
332 auto *NewCall = CallInst::Create(NF, Args, OpBundles, "", Call);
333 NewCall->setTailCallKind(cast<CallInst>(Call)->getTailCallKind());
412 CallInst *Call = dyn_cast<CallInst>(U);
412 CallInst *Call = dyn_cast<CallInst>(U);
lib/Transforms/IPO/Attributor.cpp 2185 CallInst *CI = createCallMatchingInvoke(II);
3611 CallInst::Create(Fn, Ops, "", BI->getNextNode());
lib/Transforms/IPO/CalledValuePropagation.cpp 174 return visitCallSite(cast<CallInst>(&I), ChangedValues, SS);
lib/Transforms/IPO/DeadArgumentElimination.cpp 141 CallInst *CI = dyn_cast<CallInst>(&I);
141 CallInst *CI = dyn_cast<CallInst>(&I);
203 NewCS = CallInst::Create(NF, Args, OpBundles, "", Call);
204 cast<CallInst>(NewCS.getInstruction())
205 ->setTailCallKind(cast<CallInst>(Call)->getTailCallKind());
941 NewCS = CallInst::Create(NFTy, NF, Args, OpBundles, "", Call);
942 cast<CallInst>(NewCS.getInstruction())
943 ->setTailCallKind(cast<CallInst>(Call)->getTailCallKind());
lib/Transforms/IPO/FunctionAttrs.cpp 1235 if (const auto *CI = dyn_cast<CallInst>(&I)) {
1235 if (const auto *CI = dyn_cast<CallInst>(&I)) {
lib/Transforms/IPO/GlobalDCE.cpp 240 auto CI = dyn_cast<CallInst>(U);
lib/Transforms/IPO/GlobalOpt.cpp 630 } else if (const CallInst *CI = dyn_cast<CallInst>(U)) {
630 } else if (const CallInst *CI = dyn_cast<CallInst>(U)) {
695 } else if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
837 OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, CallInst *CI, Type *AllocTy,
1276 static GlobalVariable *PerformHeapAllocSRoA(GlobalVariable *GV, CallInst *CI,
1314 Value *NMI = CallInst::CreateMalloc(CI, IntPtrTy, FieldTy,
1377 CallInst::CreateFree(GVVal, OpBundles, BI);
1469 static bool tryToOptimizeStoreOfMallocToGlobal(GlobalVariable *GV, CallInst *CI,
1546 CallInst::CreateMalloc(CI, IntPtrTy, AllocSTy, AllocSize, NumElements,
1552 CI = cast<CallInst>(BCI->getOperand(0));
1554 CI = cast<CallInst>(Malloc);
1590 } else if (CallInst *CI = extractMallocCall(StoredOnceVal, GetTLI)) {
2148 CallInst* CI = dyn_cast<CallInst>(U);
2148 CallInst* CI = dyn_cast<CallInst>(U);
2219 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
2219 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
2890 CallInst *CI = dyn_cast<CallInst>(*I++);
2890 CallInst *CI = dyn_cast<CallInst>(*I++);
lib/Transforms/IPO/HotColdSplitting.cpp 118 if (auto *CI =
119 dyn_cast_or_null<CallInst>(BB.getTerminator()->getPrevNode()))
320 CallInst *CI = cast<CallInst>(U);
320 CallInst *CI = cast<CallInst>(U);
lib/Transforms/IPO/LowerTypeTests.cpp 311 static ICallBranchFunnel *create(BumpPtrAllocator &Alloc, CallInst *CI,
325 CallInst *CI;
405 std::vector<CallInst *> CallSites;
445 void importTypeTest(CallInst *CI);
459 Value *lowerTypeTestCall(Metadata *TypeId, CallInst *CI,
728 Value *LowerTypeTestsModule::lowerTypeTestCall(Metadata *TypeId, CallInst *CI,
1026 void LowerTypeTestsModule::importTypeTest(CallInst *CI) {
1159 for (CallInst *CI : TIUI.CallSites) {
1703 auto *Usr = dyn_cast<CallInst>(U.getUser());
1703 auto *Usr = dyn_cast<CallInst>(U.getUser());
1773 auto *CI = cast<CallInst>((*UI++).getUser());
1773 auto *CI = cast<CallInst>((*UI++).getUser());
2000 auto CI = cast<CallInst>(U.getUser());
2016 auto CI = cast<CallInst>(U.getUser());
lib/Transforms/IPO/MergeFunctions.cpp 713 CallInst *CI = Builder.CreateCall(F, Args);
lib/Transforms/IPO/PartialInlining.cpp 307 if (CallInst *CI = dyn_cast<CallInst>(U))
307 if (CallInst *CI = dyn_cast<CallInst>(U))
871 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
871 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
lib/Transforms/IPO/PruneEH.cpp 125 if (const auto *CI = dyn_cast<CallInst>(&I)) {
125 if (const auto *CI = dyn_cast<CallInst>(&I)) {
205 if (CallInst *CI = dyn_cast<CallInst>(I++))
205 if (CallInst *CI = dyn_cast<CallInst>(I++))
lib/Transforms/IPO/SampleProfile.cpp 678 if ((isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) &&
776 if (const CallInst *CI = dyn_cast<CallInst>(&Inst))
776 if (const CallInst *CI = dyn_cast<CallInst>(&Inst))
922 if ((isa<CallInst>(I) || isa<InvokeInst>(I)) &&
974 if ((isa<CallInst>(DI) || isa<InvokeInst>(DI)) &&
1425 if (!isa<CallInst>(I) && !isa<InvokeInst>(I))
lib/Transforms/IPO/StripSymbols.cpp 258 CallInst *CI = cast<CallInst>(Declare->user_back());
258 CallInst *CI = cast<CallInst>(Declare->user_back());
lib/Transforms/IPO/SyntheticCountsPropagation.cpp 69 if (!isa<CallInst>(U) && !isa<InvokeInst>(U))
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 107 auto CI = cast<CallInst>(U.getUser());
115 auto CI = cast<CallInst>(U.getUser());
lib/Transforms/IPO/WholeProgramDevirt.cpp 469 std::map<CallInst *, unsigned> NumUnsafeUsesForTypeTest;
1076 auto *CI = CallInst::Create(Intr, JTArgs, "", BB);
1076 auto *CI = CallInst::Create(Intr, JTArgs, "", BB);
1077 CI->setTailCallKind(CallInst::TCK_MustTail);
1561 auto CI = dyn_cast<CallInst>(I->getUser());
1568 SmallVector<CallInst *, 1> Assumes;
1604 auto CI = dyn_cast<CallInst>(I->getUser());
1641 CallInst *TypeTestCall = CallB.CreateCall(TypeTestFunc, {Ptr, TypeIdValue});
lib/Transforms/InstCombine/InstCombineAddSub.cpp 1089 return CallInst::Create(getUAddSat(), { X, Y });
1095 return CallInst::Create(getUAddSat(), { X, ConstantInt::get(Ty, *C) });
lib/Transforms/InstCombine/InstCombineCalls.cpp 1194 return CallInst::Create(F, {X, II.getArgOperand(1)});
1326 CallInst *NewMaskedLoad =
1720 return CallInst::Create(
1758 static Instruction *canonicalizeConstantArg0ToArg1(CallInst &Call) {
1782 Instruction *InstCombiner::visitCallInst(CallInst &CI) {
1971 return CallInst::Create(Fshl, { Op0, Op1, LeftShiftC });
1991 return CallInst::Create(Bswap, { Op0 });
2287 CallInst *Call0 = Builder.CreateCall(II->getCalledFunction(), {LHS});
2288 CallInst *Call1 = Builder.CreateCall(II->getCalledFunction(), {RHS});
3445 CallInst *NewCall = Builder.CreateCall(II->getCalledFunction(),
3607 CallInst *NewCall = nullptr;
3694 CallInst *NewCall = Builder.CreateCall(NewF, Args);
3790 CallInst *NewCall = Builder.CreateCall(NewF, Args);
3881 if (CallInst *BCI = dyn_cast<CallInst>(BI)) {
3881 if (CallInst *BCI = dyn_cast<CallInst>(BI)) {
4122 Instruction *InstCombiner::tryOptimizeCall(CallInst *CI) {
4326 if (isa<CallInst>(OldCall))
4393 if (CallInst *CI = dyn_cast<CallInst>(&Call)) {
4393 if (CallInst *CI = dyn_cast<CallInst>(&Call)) {
4636 cast<CallInst>(NewCall)->setTailCallKind(
4637 cast<CallInst>(Caller)->getTailCallKind());
4820 NewCaller = CallInst::Create(NewFTy, NewCallee, NewArgs, OpBundles);
4821 cast<CallInst>(NewCaller)->setTailCallKind(
4822 cast<CallInst>(Call).getTailCallKind());
4823 cast<CallInst>(NewCaller)->setCallingConv(
4824 cast<CallInst>(Call).getCallingConv());
4825 cast<CallInst>(NewCaller)->setAttributes(NewPAL);
lib/Transforms/InstCombine/InstCombineCasts.cpp 1665 CallInst *NewCI =
1666 CallInst::Create(Overload, {InnerTrunc}, OpBundles, II->getName());
lib/Transforms/InstCombine/InstCombineCompares.cpp 1326 CallInst *Call = Builder.CreateCall(F, {TruncA, TruncB}, "sadd");
3648 CallInst *Call = Builder.CreateCall(F, {X, Y}, "umul");
4289 CallInst *CtPop = Builder.CreateUnaryIntrinsic(Intrinsic::ctpop, A);
4686 CallInst *Call = Builder.CreateCall(F, {MulA, MulB}, "umul");
lib/Transforms/InstCombine/InstCombineInternal.h 424 Instruction *visitCallInst(CallInst &CI);
433 Instruction *visitFree(CallInst &FI);
504 Instruction *tryOptimizeCall(CallInst *CI);
lib/Transforms/InstCombine/InstCombineSelect.cpp 827 return CallInst::Create(F, {X, II->getArgOperand(1)});
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 1052 CallInst *NewCall = Builder.CreateCall(NewIntrin, Args);
lib/Transforms/InstCombine/InstructionCombining.cpp 2445 static Instruction *tryToMoveFreeBeforeNullTest(CallInst &FI,
2511 Instruction *InstCombiner::visitFree(CallInst &FI) {
3139 if (auto *CI = dyn_cast<CallInst>(I)) {
3139 if (auto *CI = dyn_cast<CallInst>(I)) {
3522 AC.registerAssumption(cast<CallInst>(I));
lib/Transforms/Instrumentation/AddressSanitizer.cpp 911 std::unique_ptr<CallInst> EmptyInlineAsm;
918 EmptyInlineAsm(CallInst::Create(ASan.EmptyAsm)) {}
1080 if (CallInst *CI = dyn_cast<CallInst>(I)) {
1080 if (CallInst *CI = dyn_cast<CallInst>(I)) {
1381 } else if (auto CI = dyn_cast<CallInst>(I)) {
1614 CallInst *Call = nullptr;
1773 CallInst::Create(AsanUnpoisonGlobals, "", RI);
2691 if (CallInst *CI = dyn_cast<CallInst>(&Inst))
2691 if (CallInst *CI = dyn_cast<CallInst>(&Inst))
2752 CallInst *CI = dyn_cast<CallInst>(I);
2752 CallInst *CI = dyn_cast<CallInst>(I);
lib/Transforms/Instrumentation/BoundsChecking.cpp 189 CallInst *TrapCall = IRB.CreateCall(F, {});
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 661 CallInst::Create(DFSanVarargWrapperFn,
670 CallInst *CI = CallInst::Create(F, Args, "", BB);
670 CallInst *CI = CallInst::Create(F, Args, "", BB);
692 CallInst *CI = CallInst::Create(FT, &*F->arg_begin(), Args, "", BB);
692 CallInst *CI = CallInst::Create(FT, &*F->arg_begin(), Args, "", BB);
1119 CallInst *Call = IRB.CreateCall(DFS.DFSanCheckedUnionFn, {V1, V2});
1132 CallInst *Call = ThenIRB.CreateCall(DFS.DFSanUnionFn, {V1, V2});
1233 CallInst *FallbackCall = FallbackIRB.CreateCall(
1293 CallInst *FallbackCall = IRB.CreateCall(
1572 if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) {
1572 if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) {
1644 CallInst *CustomCI = IRB.CreateCall(CustomF, Args);
lib/Transforms/Instrumentation/GCOVProfiling.cpp 636 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
636 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
1102 auto *StartFileCall = Builder.CreateCall(
1133 auto *EmitFunctionCall = Builder.CreateCall(
1159 auto *EmitArcsCall = Builder.CreateCall(
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 1482 CallInst *WrapperCall = IRB.CreateCall(
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp 241 if (ICPInvokeOnly && isa<CallInst>(Inst)) {
lib/Transforms/Instrumentation/InstrProfiling.cpp 611 CallInst *Call = nullptr;
lib/Transforms/Instrumentation/MemorySanitizer.cpp 1905 if (auto *CI = dyn_cast<CallInst>(I.getOperand(0)))
1905 if (auto *CI = dyn_cast<CallInst>(I.getOperand(0)))
3258 if (CS.isCallBr() || (CS.isCall() && cast<CallInst>(&I)->isInlineAsm())) {
3270 CallInst *Call = cast<CallInst>(&I);
3270 CallInst *Call = cast<CallInst>(&I);
3354 if (CS.isCall() && cast<CallInst>(&I)->isMustTailCall()) return;
3393 if (auto *I = dyn_cast<CallInst>(RetVal)) {
3393 if (auto *I = dyn_cast<CallInst>(RetVal)) {
3604 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
3604 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
3750 SmallVector<CallInst*, 16> VAStartInstrumentationList;
3958 CallInst *OrigInst = VAStartInstrumentationList[i];
4012 SmallVector<CallInst*, 16> VAStartInstrumentationList;
4101 CallInst *OrigInst = VAStartInstrumentationList[i];
4140 SmallVector<CallInst*, 16> VAStartInstrumentationList;
4295 CallInst *OrigInst = VAStartInstrumentationList[i];
4388 SmallVector<CallInst*, 16> VAStartInstrumentationList;
4538 CallInst *OrigInst = VAStartInstrumentationList[i];
lib/Transforms/Instrumentation/PoisonChecking.cpp 117 auto *OverflowOp =
122 auto *OverflowOp =
130 auto *OverflowOp =
135 auto *OverflowOp =
143 auto *OverflowOp =
148 auto *OverflowOp =
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 630 (isa<CallInst>(Inst) && !isa<IntrinsicInst>(Inst)))
lib/Transforms/Instrumentation/ThreadSanitizer.cpp 460 else if (isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) {
461 if (CallInst *CI = dyn_cast<CallInst>(&Inst))
461 if (CallInst *CI = dyn_cast<CallInst>(&Inst))
657 CallInst *C = CallInst::Create(TsanAtomicStore[Idx], Args);
657 CallInst *C = CallInst::Create(TsanAtomicStore[Idx], Args);
674 CallInst *C = CallInst::Create(F, Args);
674 CallInst *C = CallInst::Create(F, Args);
694 CallInst *C = IRB.CreateCall(TsanAtomicCAS[Idx], Args);
714 CallInst *C = CallInst::Create(F, Args);
714 CallInst *C = CallInst::Create(F, Args);
lib/Transforms/ObjCARC/ObjCARC.h 52 Value *OldArg = cast<CallInst>(CI)->getArgOperand(0);
79 if (const auto *C = dyn_cast<CallInst>(Opnd))
79 if (const auto *C = dyn_cast<CallInst>(Opnd))
lib/Transforms/ObjCARC/ObjCARCAPElim.cpp 103 if (Push && cast<CallInst>(Inst)->getArgOperand(0) == Push) {
lib/Transforms/ObjCARC/ObjCARCContract.cpp 78 SmallPtrSet<CallInst *, 8> StoreStrongCalls;
147 cast<CallInst>(Retain)->setCalledFunction(Decl);
162 CallInst *Retain = nullptr;
178 Retain = dyn_cast_or_null<CallInst>(*DependingInstructions.begin());
319 static CallInst *
332 return CallInst::Create(FTy, Func, Args, OpBundles, NameStr, InsertBefore);
335 static CallInst *
424 CallInst *StoreStrong = createCallInst(Decl, Args, "", Store, BlockColors);
507 CallInst *CI = cast<CallInst>(Inst);
507 CallInst *CI = cast<CallInst>(Inst);
691 Value *Arg = cast<CallInst>(Inst)->getArgOperand(0);
742 for (CallInst *CI : StoreStrongCalls)
lib/Transforms/ObjCARC/ObjCARCExpand.cpp 113 Value *Value = cast<CallInst>(Inst)->getArgOperand(0);
lib/Transforms/ObjCARC/ObjCARCOpts.cpp 100 cast<CallInst>(Arg)->getArgOperand(0));
662 cast<CallInst>(RetainRV)->setCalledFunction(NewDecl);
709 CallInst *AutoreleaseRVCI = cast<CallInst>(AutoreleaseRV);
709 CallInst *AutoreleaseRVCI = cast<CallInst>(AutoreleaseRV);
720 CloneCallInstForBB(CallInst &CI, BasicBlock &BB,
739 return CallInst::Create(&CI, OpBundles);
800 CallInst *CI = cast<CallInst>(Inst);
800 CallInst *CI = cast<CallInst>(Inst);
820 CallInst *CI = cast<CallInst>(Inst);
820 CallInst *CI = cast<CallInst>(Inst);
852 CallInst *Call = cast<CallInst>(Inst);
852 CallInst *Call = cast<CallInst>(Inst);
863 CallInst *NewCall = CallInst::Create(Decl, Call->getArgOperand(0), "",
863 CallInst *NewCall = CallInst::Create(Decl, Call->getArgOperand(0), "",
881 if (IsAlwaysTail(Class) && !cast<CallInst>(Inst)->isNoTailCall()) {
887 cast<CallInst>(Inst)->setTailCall();
896 cast<CallInst>(Inst)->setTailCall(false);
904 cast<CallInst>(Inst)->setDoesNotThrow();
1005 CallInst *CInst = cast<CallInst>(Inst);
1005 CallInst *CInst = cast<CallInst>(Inst);
1013 CallInst *Clone = cast<CallInst>(CloneCallInstForBB(
1013 CallInst *Clone = cast<CallInst>(CloneCallInstForBB(
1581 CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
1581 CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
1594 CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
1594 CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
1920 CallInst *Call = cast<CallInst>(Inst);
1920 CallInst *Call = cast<CallInst>(Inst);
1921 CallInst *EarlierCall = cast<CallInst>(EarlierInst);
1921 CallInst *EarlierCall = cast<CallInst>(EarlierInst);
1930 CallInst *CI = CallInst::Create(Decl, EarlierCall, "", Call);
1930 CallInst *CI = CallInst::Create(Decl, EarlierCall, "", Call);
1949 CallInst *Call = cast<CallInst>(Inst);
1949 CallInst *Call = cast<CallInst>(Inst);
1950 CallInst *EarlierCall = cast<CallInst>(EarlierInst);
1950 CallInst *EarlierCall = cast<CallInst>(EarlierInst);
1959 CallInst *CI = CallInst::Create(Decl, EarlierCall, "", Call);
1959 CallInst *CI = CallInst::Create(Decl, EarlierCall, "", Call);
2001 CallInst *Call = cast<CallInst>(Inst);
2001 CallInst *Call = cast<CallInst>(Inst);
2017 CallInst *UserInst = cast<CallInst>(*UI++);
2017 CallInst *UserInst = cast<CallInst>(*UI++);
2079 auto *Call = dyn_cast_or_null<CallInst>(*DepInsts.begin());
2079 auto *Call = dyn_cast_or_null<CallInst>(*DepInsts.begin());
2093 static CallInst *
2104 auto *Retain = dyn_cast_or_null<CallInst>(*DepInsts.begin());
2104 auto *Retain = dyn_cast_or_null<CallInst>(*DepInsts.begin());
2118 static CallInst *
2129 auto *Autorelease = dyn_cast_or_null<CallInst>(*DepInsts.begin());
2129 auto *Autorelease = dyn_cast_or_null<CallInst>(*DepInsts.begin());
2169 CallInst *Autorelease = FindPredecessorAutoreleaseWithSafePath(
2177 CallInst *Retain = FindPredecessorRetainWithSafePath(
lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp 100 if (isa<CallInst>(Ur))
lib/Transforms/ObjCARC/PtrState.cpp 198 SetTailCallRelease(cast<CallInst>(I)->isTailCall());
368 SetTailCallRelease(cast<CallInst>(Release)->isTailCall());
lib/Transforms/Scalar/ADCE.cpp 345 if (CallInst *CI = dyn_cast<CallInst>(&I))
345 if (CallInst *CI = dyn_cast<CallInst>(&I))
lib/Transforms/Scalar/AlignmentFromAssumptions.cpp 197 bool AlignmentFromAssumptionsPass::extractAlignmentInfo(CallInst *I,
291 bool AlignmentFromAssumptionsPass::processAssumption(CallInst *ACall) {
393 Changed |= processAssumption(cast<CallInst>(AssumeVH));
lib/Transforms/Scalar/CallSiteSplitting.cpp 192 if (!isa<CallInst>(Instr))
lib/Transforms/Scalar/DeadStoreElimination.cpp 656 static bool handleFree(CallInst *F, AliasAnalysis *AA,
1088 if (CallInst *F = isFreeCall(&*BBI, TLI)) {
lib/Transforms/Scalar/EarlyCSE.cpp 109 if (CallInst *CI = dyn_cast<CallInst>(Inst))
109 if (CallInst *CI = dyn_cast<CallInst>(Inst))
388 CallInst *CI = dyn_cast<CallInst>(Inst);
388 CallInst *CI = dyn_cast<CallInst>(Inst);
924 dyn_cast<Instruction>(cast<CallInst>(Inst)->getArgOperand(0));
957 auto *CI = cast<CallInst>(Inst);
957 auto *CI = cast<CallInst>(Inst);
967 dyn_cast<Instruction>(cast<CallInst>(Inst)->getArgOperand(0))) {
982 cast<CallInst>(Inst)->setArgOperand(0, KnownCond);
lib/Transforms/Scalar/GVN.cpp 375 uint32_t GVN::ValueTable::lookupOrAddCall(CallInst *C) {
397 CallInst* local_cdep = cast<CallInst>(local_dep.getInst());
397 CallInst* local_cdep = cast<CallInst>(local_dep.getInst());
422 CallInst* cdep = nullptr;
438 CallInst *NonLocalDepCall = dyn_cast<CallInst>(I->getResult().getInst());
438 CallInst *NonLocalDepCall = dyn_cast<CallInst>(I->getResult().getInst());
495 return lookupOrAddCall(cast<CallInst>(I));
1608 CallInst *Call = nullptr;
1611 Call = dyn_cast<CallInst>(Vals->Val);
lib/Transforms/Scalar/GVNHoist.cpp 223 void insert(CallInst *Call, GVN::ValueTable &VN) {
904 } else if (isa<CallInst>(Repl)) {
1064 else if (isa<CallInst>(Repl))
1107 else if (auto *Call = dyn_cast<CallInst>(&I1)) {
1107 else if (auto *Call = dyn_cast<CallInst>(&I1)) {
lib/Transforms/Scalar/GVNSink.cpp 103 (isa<CallInst>(I) && !cast<CallInst>(I)->doesNotAccessMemory());
103 (isa<CallInst>(I) && !cast<CallInst>(I)->doesNotAccessMemory());
545 CallInst *CI = dyn_cast<CallInst>(&*I);
545 CallInst *CI = dyn_cast<CallInst>(&*I);
738 if ((isa<CallInst>(I0) || isa<InvokeInst>(I0)) && OpNum == E - 1 &&
lib/Transforms/Scalar/IndVarSimplify.cpp 2178 if(I->mayReadFromMemory() || isa<CallInst>(I) || isa<InvokeInst>(I))
lib/Transforms/Scalar/JumpThreading.cpp 531 if (const CallInst *CI = dyn_cast<CallInst>(I)) {
531 if (const CallInst *CI = dyn_cast<CallInst>(I)) {
lib/Transforms/Scalar/LICM.cpp 1035 return (isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
1131 } else if (CallInst *CI = dyn_cast<CallInst>(&I)) {
1131 } else if (CallInst *CI = dyn_cast<CallInst>(&I)) {
1258 if (auto *CI = dyn_cast<CallInst>(MD->getMemoryInst())) {
1258 if (auto *CI = dyn_cast<CallInst>(MD->getMemoryInst())) {
1341 if (isa<CallInst>(I))
1362 if (auto *CI = dyn_cast<CallInst>(&I)) {
1362 if (auto *CI = dyn_cast<CallInst>(&I)) {
1387 New = CallInst::Create(CI, OpBundles);
1573 else if (isa<CallInst>(I))
1698 else if (isa<CallInst>(I))
lib/Transforms/Scalar/LoopDataPrefetch.cpp 228 if (CallInst *CI = dyn_cast<CallInst>(&I))
228 if (CallInst *CI = dyn_cast<CallInst>(&I))
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 1006 CallInst *NewCall;
1141 CallInst *NewCall = nullptr;
1634 static CallInst *createPopcntIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
1641 CallInst *CI = IRBuilder.CreateCall(Func, Ops);
1647 static CallInst *createFFSIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
1655 CallInst *CI = IRBuilder.CreateCall(Func, Ops);
2648 auto *CmpCall =
2649 cast<CallInst>(HasBCmp ? emitBCmp(PtrA, PtrB, Len, Builder, *DL, TLI)
lib/Transforms/Scalar/LoopInterchange.cpp 978 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
978 if (CallInst *CI = dyn_cast<CallInst>(&I)) {
lib/Transforms/Scalar/LoopUnrollPass.cpp 539 if (auto *CI = dyn_cast<CallInst>(&I)) {
539 if (auto *CI = dyn_cast<CallInst>(&I)) {
lib/Transforms/Scalar/LowerExpectIntrinsic.cpp 58 CallInst *CI = dyn_cast<CallInst>(SI.getCondition());
58 CallInst *CI = dyn_cast<CallInst>(SI.getCondition());
99 static void handlePhiDef(CallInst *Expect) {
249 CallInst *CI;
255 CI = dyn_cast<CallInst>(BSI.getCondition());
265 CI = dyn_cast<CallInst>(CmpI->getOperand(0));
339 CallInst *CI = dyn_cast<CallInst>(Inst);
339 CallInst *CI = dyn_cast<CallInst>(Inst);
lib/Transforms/Scalar/LowerGuardIntrinsic.cpp 50 SmallVector<CallInst *, 8> ToLower;
53 ToLower.push_back(cast<CallInst>(&I));
62 for (auto *CI : ToLower) {
lib/Transforms/Scalar/LowerWidenableCondition.cpp 51 SmallVector<CallInst *, 8> ToLower;
54 ToLower.push_back(cast<CallInst>(&I));
59 for (auto *CI : ToLower) {
lib/Transforms/Scalar/MakeGuardsExplicit.cpp 57 static void turnToExplicitForm(CallInst *Guard, Function *DeoptIntrinsic) {
68 auto *WidenableCondition =
87 SmallVector<CallInst *, 8> GuardIntrinsics;
90 GuardIntrinsics.push_back(cast<CallInst>(&I));
99 for (auto *Guard : GuardIntrinsics)
lib/Transforms/Scalar/MemCpyOptimizer.cpp 621 CallInst *C = nullptr;
623 C = dyn_cast<CallInst>(ldep.getInst());
689 auto *M =
724 unsigned cpyAlign, CallInst *C) {
1184 if (CallInst *C = dyn_cast<CallInst>(DepInfo.getInst())) {
1184 if (CallInst *C = dyn_cast<CallInst>(DepInfo.getInst())) {
lib/Transforms/Scalar/NewGVN.cpp 688 const CallExpression *createCallExpression(CallInst *,
1251 NewGVN::createCallExpression(CallInst *CI, const MemoryAccess *MA) const {
1629 auto *CI = cast<CallInst>(I);
1629 auto *CI = cast<CallInst>(I);
lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp 30 static bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
99 CallInst *Call = dyn_cast<CallInst>(&*II);
99 CallInst *Call = dyn_cast<CallInst>(&*II);
lib/Transforms/Scalar/PlaceSafepoints.cpp 186 if (auto *CI = dyn_cast<CallInst>(Call)) {
186 if (auto *CI = dyn_cast<CallInst>(Call)) {
266 std::vector<CallInst *> &Calls,
272 if (CallInst *CI = dyn_cast<CallInst>(&*BBI))
272 if (CallInst *CI = dyn_cast<CallInst>(&*BBI))
293 std::vector<CallInst *> &Calls,
637 CallInst *PollCall = CallInst::Create(F, "", InsertBefore);
637 CallInst *PollCall = CallInst::Create(F, "", InsertBefore);
659 std::vector<CallInst *> Calls; // new calls
679 for (auto *CI : Calls) {
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 478 if (isa<CallInst>(I) || isa<InvokeInst>(I))
564 if (isa<CallInst>(I) || isa<InvokeInst>(I))
1319 CallInst *Reloc = Builder.CreateCall(
1358 auto *F = cast<CallInst>(Old)->getCalledFunction();
1488 if (auto *CI = dyn_cast<CallInst>(Call)) {
1488 if (auto *CI = dyn_cast<CallInst>(Call)) {
1489 CallInst *SPCall = Builder.CreateGCStatepointCall(
1570 CallInst *GCResult = Builder.CreateGCResult(Token, Call->getType(), Name);
1891 SmallVectorImpl<CallInst *> &Holders) {
1900 if (isa<CallInst>(Call)) {
1903 CallInst::Create(Func, Values, "", &*++Call->getIterator()));
1909 Holders.push_back(CallInst::Create(
1911 Holders.push_back(CallInst::Create(
2141 if (isa<CallInst>(Call)) {
2198 SmallVector<CallInst *, 64> Holders;
2291 for (CallInst *CI : Holders)
lib/Transforms/Scalar/SCCP.cpp 635 void visitCallInst (CallInst &I) {
1779 CallInst *CI = dyn_cast<CallInst>(V);
1779 CallInst *CI = dyn_cast<CallInst>(V);
1956 if (CallInst *CI = BB.getTerminatingMustTailCall()) {
lib/Transforms/Scalar/SROA.cpp 2801 CallInst *New = IRB.CreateMemSet(
2988 CallInst *New = IRB.CreateMemCpy(DestPtr, DestAlign, SrcPtr, SrcAlign,
lib/Transforms/Scalar/Scalarizer.cpp 197 bool visitCallInst(CallInst &ICI);
211 bool splitCall(CallInst &CI);
494 bool ScalarizerVisitor::splitCall(CallInst &CI) {
818 bool ScalarizerVisitor::visitCallInst(CallInst &CI) {
lib/Transforms/Scalar/TailRecursionElimination.cpp 230 SmallVector<CallInst *, 32> DeferredTails;
239 CallInst *CI = dyn_cast<CallInst>(&I);
239 CallInst *CI = dyn_cast<CallInst>(&I);
309 for (CallInst *CI : DeferredTails) {
328 static bool canMoveAboveCall(Instruction *I, CallInst *CI, AliasAnalysis *AA) {
362 static bool isDynamicConstant(Value *V, CallInst *CI, ReturnInst *RI) {
396 static Value *getCommonReturnValue(ReturnInst *IgnoreRI, CallInst *CI) {
422 static Value *canTransformAccumulatorRecursion(Instruction *I, CallInst *CI) {
448 static CallInst *findTRECandidate(Instruction *TI,
459 CallInst *CI = nullptr;
462 CI = dyn_cast<CallInst>(BBI);
500 CallInst *CI, ReturnInst *Ret, BasicBlock *&OldEntry,
713 if (CallInst *CI = findTRECandidate(BI, CannotTailCallElimCallsMarkedTail, TTI)){
740 CallInst *CI = findTRECandidate(Ret, CannotTailCallElimCallsMarkedTail, TTI);
lib/Transforms/Utils/AddDiscriminators.cpp 238 if (!isa<InvokeInst>(I) && (!isa<CallInst>(I) || isa<IntrinsicInst>(I)))
lib/Transforms/Utils/BuildLibCalls.cpp 840 CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
922 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1050 CallInst *CI = B.CreateCall(Callee, Op, Name);
1092 CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1139 CallInst *CI = B.CreateCall(PutChar,
1162 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1182 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1202 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcUnlockedName);
1221 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1240 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsUnlockedName);
1262 CallInst *CI =
1283 CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1304 CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1328 CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1347 CallInst *CI = B.CreateCall(F, File, FGetCUnlockedName);
1366 CallInst *CI =
1390 CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
lib/Transforms/Utils/CloneFunction.cpp 63 hasCalls |= (isa<CallInst>(I) && !isa<DbgInfoIntrinsic>(I));
367 hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II));
lib/Transforms/Utils/CodeExtractor.cpp 173 if (const CallInst *CI = dyn_cast<CallInst>(I)) {
173 if (const CallInst *CI = dyn_cast<CallInst>(I)) {
581 if (const CallInst *CI = dyn_cast<CallInst>(&I))
581 if (const CallInst *CI = dyn_cast<CallInst>(&I))
1009 CallInst *TheCall) {
1036 auto Marker = CallInst::Create(MarkerFunc, {NegativeOne, MemAsI8Ptr});
1060 CallInst *CodeExtractor::emitCallAndSwitchStatement(Function *newFunction,
1071 CallInst *call = nullptr;
1129 call = CallInst::Create(newFunction, params,
1414 AC->unregisterAssumption(cast<CallInst>(&I));
1525 CallInst *TheCall =
1615 CallInst *I = cast<CallInst>(AssumeVH);
1615 CallInst *I = cast<CallInst>(AssumeVH);
lib/Transforms/Utils/EntryExitInstrumenter.cpp 34 CallInst *Call = CallInst::Create(Fn, "", InsertionPt);
34 CallInst *Call = CallInst::Create(Fn, "", InsertionPt);
45 Instruction *RetAddr = CallInst::Create(
54 CallInst *Call =
55 CallInst::Create(Fn, ArrayRef<Value *>(Args), "", InsertionPt);
101 if (CallInst *CI = dyn_cast_or_null<CallInst>(Prev)) {
101 if (CallInst *CI = dyn_cast_or_null<CallInst>(Prev)) {
lib/Transforms/Utils/EscapeEnumerator.cpp 59 if (CallInst *CI = dyn_cast<CallInst>(&II))
59 if (CallInst *CI = dyn_cast<CallInst>(&II))
88 CallInst *CI = cast<CallInst>(Calls[--I]);
88 CallInst *CI = cast<CallInst>(Calls[--I]);
lib/Transforms/Utils/Evaluator.cpp 478 } else if (isa<CallInst>(CurInst) || isa<InvokeInst>(CurInst)) {
lib/Transforms/Utils/FunctionComparator.cpp 580 if (const CallInst *CI = dyn_cast<CallInst>(L))
580 if (const CallInst *CI = dyn_cast<CallInst>(L))
582 cast<CallInst>(R)->getTailCallKind()))
lib/Transforms/Utils/GuardUtils.cpp 27 CallInst *Guard) {
52 auto *DeoptCall = B.CreateCall(DeoptIntrinsic, Args, {DeoptOB}, "");
lib/Transforms/Utils/InlineFunction.cpp 531 CallInst *CI = dyn_cast<CallInst>(I);
531 CallInst *CI = dyn_cast<CallInst>(I);
1168 CallInst *NewAsmp = IRBuilder<>(CS.getInstruction())
1517 if (isa<CallInst>(Entry.first))
1518 if (auto *CI = dyn_cast_or_null<CallInst>(Entry.second))
1518 if (auto *CI = dyn_cast_or_null<CallInst>(Entry.second))
1525 if (CallInst *CI = dyn_cast<CallInst>(&I))
1525 if (CallInst *CI = dyn_cast<CallInst>(&I))
1772 if (isa<CallInst>(I))
1773 NewI = CallInst::Create(cast<CallInst>(I), OpDefs, I);
1773 NewI = CallInst::Create(cast<CallInst>(I), OpDefs, I);
1873 CallInst::TailCallKind CallSiteTailKind = CallInst::TCK_None;
1873 CallInst::TailCallKind CallSiteTailKind = CallInst::TCK_None;
1874 if (CallInst *CI = dyn_cast<CallInst>(TheCall))
1874 if (CallInst *CI = dyn_cast<CallInst>(TheCall))
1878 if (CallSiteTailKind == CallInst::TCK_NoTail)
1879 CallSiteTailKind = CallInst::TCK_None;
1885 CallInst *CI = dyn_cast<CallInst>(&I);
1885 CallInst *CI = dyn_cast<CallInst>(&I);
1911 CallInst *NewCI = CallInst::Create(
1911 CallInst *NewCI = CallInst::Create(
1940 CallInst::TailCallKind ChildTCK = CI->getTailCallKind();
1941 if (ChildTCK != CallInst::TCK_NoTail)
2016 CallInst *SavedPtr = IRBuilder<>(&*FirstNewBlock, FirstNewBlock->begin())
2077 NewInst = CallInst::Create(cast<CallInst>(I), OpBundles, I);
2077 NewInst = CallInst::Create(cast<CallInst>(I), OpBundles, I);
2130 CallInst *DeoptCall = RI->getParent()->getTerminatingDeoptimizeCall();
2156 CallInst *NewDeoptCall =
2182 CallInst *ReturnedMustTail =
lib/Transforms/Utils/LibCallsShrinkWrap.cpp 77 void visitCallInst(CallInst &CI) { checkCandidate(CI); }
92 bool perform(CallInst *CI);
93 void checkCandidate(CallInst &CI);
94 void shrinkWrapCI(CallInst *CI, Value *Cond);
95 bool performCallDomainErrorOnly(CallInst *CI, const LibFunc &Func);
96 bool performCallErrors(CallInst *CI, const LibFunc &Func);
97 bool performCallRangeErrorOnly(CallInst *CI, const LibFunc &Func);
98 Value *generateOneRangeCond(CallInst *CI, const LibFunc &Func);
99 Value *generateTwoRangeCond(CallInst *CI, const LibFunc &Func);
100 Value *generateCondForPow(CallInst *CI, const LibFunc &Func);
103 Value *createOrCond(CallInst *CI, CmpInst::Predicate Cmp, float Val,
122 Value *createCond(CallInst *CI, CmpInst::Predicate Cmp, float Val) {
130 SmallVector<CallInst *, 16> WorkList;
135 bool LibCallsShrinkWrap::performCallDomainErrorOnly(CallInst *CI,
187 bool LibCallsShrinkWrap::performCallRangeErrorOnly(CallInst *CI,
225 bool LibCallsShrinkWrap::performCallErrors(CallInst *CI,
289 void LibCallsShrinkWrap::checkCandidate(CallInst &CI) {
318 Value *LibCallsShrinkWrap::generateOneRangeCond(CallInst *CI,
340 Value *LibCallsShrinkWrap::generateTwoRangeCond(CallInst *CI,
419 Value *LibCallsShrinkWrap::generateCondForPow(CallInst *CI,
484 void LibCallsShrinkWrap::shrinkWrapCI(CallInst *CI, Value *Cond) {
504 bool LibCallsShrinkWrap::perform(CallInst *CI) {
lib/Transforms/Utils/Local.cpp 425 if (CallInst *CI = isFreeCall(I, TLI))
1431 } else if (CallInst *CI = dyn_cast<CallInst>(U)) {
1431 } else if (CallInst *CI = dyn_cast<CallInst>(U)) {
1921 CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
1921 CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
1941 CallInst *llvm::createCallMatchingInvoke(InvokeInst *II) {
1945 CallInst *NewCall = CallInst::Create(II->getFunctionType(),
1945 CallInst *NewCall = CallInst::Create(II->getFunctionType(),
1956 CallInst *NewCall = createCallMatchingInvoke(II);
1974 BasicBlock *llvm::changeToInvokeAndSplitBasicBlock(CallInst *CI,
2027 if (auto *CI = dyn_cast<CallInst>(&I)) {
2027 if (auto *CI = dyn_cast<CallInst>(&I)) {
2874 auto *CI = CallInst::Create(F, Provider, "rev", I);
2874 auto *CI = CallInst::Create(F, Provider, "rev", I);
2882 InsertedInsts.push_back(CallInst::Create(F, Res->Provider, "rev", I));
2892 CallInst *CI, const TargetLibraryInfo *TLI) {
lib/Transforms/Utils/LowerInvoke.cpp 54 CallInst *NewCall =
55 CallInst::Create(II->getFunctionType(), II->getCalledValue(),
lib/Transforms/Utils/PredicateInfo.cpp 561 CallInst *PIC =
573 CallInst *PIC = B.CreateCall(IF, Op);
lib/Transforms/Utils/PromoteMemoryToRegister.cpp 310 CallInst *CI = CallInst::Create(AssumeIntrinsic, {LoadNotNull});
310 CallInst *CI = CallInst::Create(AssumeIntrinsic, {LoadNotNull});
lib/Transforms/Utils/SimplifyCFG.cpp 1280 auto *C1 = dyn_cast<CallInst>(I1);
1280 auto *C1 = dyn_cast<CallInst>(I1);
1281 auto *C2 = dyn_cast<CallInst>(I2);
1281 auto *C2 = dyn_cast<CallInst>(I2);
2195 const CallInst *CI = dyn_cast<CallInst>(&I);
2195 const CallInst *CI = dyn_cast<CallInst>(&I);
4175 if (isa<CallInst>(BBI) && !isa<DbgInfoIntrinsic>(BBI))
lib/Transforms/Utils/SimplifyLibCalls.cpp 60 static bool isCallingConvCCompatible(CallInst *CI) {
104 static bool callHasFloatingPointArgument(const CallInst *CI) {
110 static bool callHasFP128Argument(const CallInst *CI) {
116 static Value *convertStrToNumber(CallInst *CI, StringRef &Str, int64_t Base) {
141 static bool isLocallyOpenedFile(Value *File, CallInst *CI, IRBuilder<> &B,
143 CallInst *FOpen = dyn_cast<CallInst>(File);
143 CallInst *FOpen = dyn_cast<CallInst>(File);
175 static bool canTransformToMemCmp(CallInst *CI, Value *Str, uint64_t Len,
190 static void annotateDereferenceableBytes(CallInst *CI,
217 static void annotateNonNullBasedOnAccess(CallInst *CI,
235 static void annotateNonNullAndDereferenceable(CallInst *CI, ArrayRef<unsigned> ArgNos,
255 Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilder<> &B) {
296 Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilder<> &B) {
339 Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilder<> &B) {
384 Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilder<> &B) {
412 Value *LibCallSimplifier::optimizeStrCmp(CallInst *CI, IRBuilder<> &B) {
467 Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilder<> &B) {
535 Value *LibCallSimplifier::optimizeStrNDup(CallInst *CI, IRBuilder<> &B) {
548 Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) {
563 CallInst *NewCI =
570 Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilder<> &B) {
592 CallInst *NewCI = B.CreateMemCpy(Dst, 1, Src, 1, LenV);
597 Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilder<> &B) {
627 CallInst *NewCI = B.CreateMemSet(Dst, B.getInt8('\0'), Size, 1);
640 CallInst *NewCI = B.CreateMemCpy(Dst, 1, Src, 1, ConstantInt::get(DL.getIntPtrType(PT), Len));
645 Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilder<> &B,
736 Value *LibCallSimplifier::optimizeStrLen(CallInst *CI, IRBuilder<> &B) {
743 Value *LibCallSimplifier::optimizeWcslen(CallInst *CI, IRBuilder<> &B) {
753 Value *LibCallSimplifier::optimizeStrPBrk(CallInst *CI, IRBuilder<> &B) {
780 Value *LibCallSimplifier::optimizeStrTo(CallInst *CI, IRBuilder<> &B) {
791 Value *LibCallSimplifier::optimizeStrSpn(CallInst *CI, IRBuilder<> &B) {
812 Value *LibCallSimplifier::optimizeStrCSpn(CallInst *CI, IRBuilder<> &B) {
836 Value *LibCallSimplifier::optimizeStrStr(CallInst *CI, IRBuilder<> &B) {
893 Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilder<> &B) {
899 Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilder<> &B) {
987 static Value *optimizeMemCmpConstantSize(CallInst *CI, Value *LHS, Value *RHS,
1064 Value *LibCallSimplifier::optimizeMemCmpBCmpCommon(CallInst *CI,
1088 Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilder<> &B) {
1105 Value *LibCallSimplifier::optimizeBCmp(CallInst *CI, IRBuilder<> &B) {
1109 Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B) {
1116 CallInst *NewCI =
1122 Value *LibCallSimplifier::optimizeMemPCpy(CallInst *CI, IRBuilder<> &B) {
1126 CallInst *NewCI = B.CreateMemCpy(Dst, 1, CI->getArgOperand(1), 1, N);
1131 Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) {
1138 CallInst *NewCI =
1145 Value *LibCallSimplifier::foldMallocMemset(CallInst *Memset, IRBuilder<> &B) {
1155 auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0));
1155 auto *Malloc = dyn_cast<CallInst>(Memset->getArgOperand(0));
1188 Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
1199 CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, 1);
1204 Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilder<> &B) {
1216 static Value *replaceUnaryCall(CallInst *CI, IRBuilder<> &B, Intrinsic::ID IID) {
1224 CallInst *NewCall = B.CreateCall(F, V);
1252 static Value *optimizeDoubleFP(CallInst *CI, IRBuilder<> &B,
1310 static Value *optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B,
1316 static Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B,
1322 Value *LibCallSimplifier::optimizeCAbs(CallInst *CI, IRBuilder<> &B) {
1350 static Value *optimizeTrigReflections(CallInst *Call, LibFunc Func,
1429 Value *LibCallSimplifier::replacePowWithExp(CallInst *Pow, IRBuilder<> &B) {
1451 CallInst *BaseFn = dyn_cast<CallInst>(Base);
1451 CallInst *BaseFn = dyn_cast<CallInst>(Base);
1591 Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B) {
1635 Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
1760 Value *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
1784 Value *LibCallSimplifier::optimizeFMinFMax(CallInst *CI, IRBuilder<> &B) {
1811 Value *LibCallSimplifier::optimizeLog(CallInst *Log, IRBuilder<> &B) {
1824 CallInst *Arg = dyn_cast<CallInst>(Log->getArgOperand(0));
1824 CallInst *Arg = dyn_cast<CallInst>(Log->getArgOperand(0));
1963 Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) {
2032 Value *LibCallSimplifier::optimizeTan(CallInst *CI, IRBuilder<> &B) {
2040 auto *OpC = dyn_cast<CallInst>(Op1);
2040 auto *OpC = dyn_cast<CallInst>(Op1);
2061 static bool isTrigLibCall(CallInst *CI) {
2119 Value *LibCallSimplifier::optimizeSinCosPi(CallInst *CI, IRBuilder<> &B) {
2126 SmallVector<CallInst *, 1> SinCalls;
2127 SmallVector<CallInst *, 1> CosCalls;
2128 SmallVector<CallInst *, 1> SinCosCalls;
2148 for (CallInst *C : Calls)
2161 SmallVectorImpl<CallInst *> &SinCalls,
2162 SmallVectorImpl<CallInst *> &CosCalls,
2163 SmallVectorImpl<CallInst *> &SinCosCalls) {
2164 CallInst *CI = dyn_cast<CallInst>(Val);
2164 CallInst *CI = dyn_cast<CallInst>(Val);
2200 Value *LibCallSimplifier::optimizeFFS(CallInst *CI, IRBuilder<> &B) {
2214 Value *LibCallSimplifier::optimizeFls(CallInst *CI, IRBuilder<> &B) {
2226 Value *LibCallSimplifier::optimizeAbs(CallInst *CI, IRBuilder<> &B) {
2235 Value *LibCallSimplifier::optimizeIsDigit(CallInst *CI, IRBuilder<> &B) {
2243 Value *LibCallSimplifier::optimizeIsAscii(CallInst *CI, IRBuilder<> &B) {
2250 Value *LibCallSimplifier::optimizeToAscii(CallInst *CI, IRBuilder<> &B) {
2256 Value *LibCallSimplifier::optimizeAtoi(CallInst *CI, IRBuilder<> &B) {
2264 Value *LibCallSimplifier::optimizeStrtol(CallInst *CI, IRBuilder<> &B) {
2283 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg);
2285 Value *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
2304 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg) {
2325 Value *LibCallSimplifier::optimizePrintFString(CallInst *CI, IRBuilder<> &B) {
2378 Value *LibCallSimplifier::optimizePrintF(CallInst *CI, IRBuilder<> &B) {
2392 CallInst *New = cast<CallInst>(CI->clone());
2392 CallInst *New = cast<CallInst>(CI->clone());
2405 CallInst *New = cast<CallInst>(CI->clone());
2405 CallInst *New = cast<CallInst>(CI->clone());
2415 Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI, IRBuilder<> &B) {
2474 Value *LibCallSimplifier::optimizeSPrintF(CallInst *CI, IRBuilder<> &B) {
2487 CallInst *New = cast<CallInst>(CI->clone());
2487 CallInst *New = cast<CallInst>(CI->clone());
2500 CallInst *New = cast<CallInst>(CI->clone());
2500 CallInst *New = cast<CallInst>(CI->clone());
2510 Value *LibCallSimplifier::optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B) {
2588 Value *LibCallSimplifier::optimizeSnPrintF(CallInst *CI, IRBuilder<> &B) {
2598 Value *LibCallSimplifier::optimizeFPrintFString(CallInst *CI, IRBuilder<> &B) {
2647 Value *LibCallSimplifier::optimizeFPrintF(CallInst *CI, IRBuilder<> &B) {
2660 CallInst *New = cast<CallInst>(CI->clone());
2660 CallInst *New = cast<CallInst>(CI->clone());
2673 CallInst *New = cast<CallInst>(CI->clone());
2673 CallInst *New = cast<CallInst>(CI->clone());
2682 Value *LibCallSimplifier::optimizeFWrite(CallInst *CI, IRBuilder<> &B) {
2713 Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilder<> &B) {
2745 Value *LibCallSimplifier::optimizeFPutc(CallInst *CI, IRBuilder<> &B) {
2755 Value *LibCallSimplifier::optimizeFGetc(CallInst *CI, IRBuilder<> &B) {
2762 Value *LibCallSimplifier::optimizeFGets(CallInst *CI, IRBuilder<> &B) {
2770 Value *LibCallSimplifier::optimizeFRead(CallInst *CI, IRBuilder<> &B) {
2779 Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilder<> &B) {
2793 Value *LibCallSimplifier::optimizeBCopy(CallInst *CI, IRBuilder<> &B) {
2808 Value *LibCallSimplifier::optimizeStringMemoryLibCall(CallInst *CI,
2886 Value *LibCallSimplifier::optimizeFloatingPointLibCall(CallInst *CI,
2988 Value *LibCallSimplifier::optimizeCall(CallInst *CI) {
3043 CallInst *SimplifiedCI = dyn_cast<CallInst>(SimplifiedFortifiedCI);
3043 CallInst *SimplifiedCI = dyn_cast<CallInst>(SimplifiedFortifiedCI);
3180 FortifiedLibCallSimplifier::isFortifiedCallFoldable(CallInst *CI,
3223 Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
3226 CallInst *NewCI = B.CreateMemCpy(
3234 Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
3237 CallInst *NewCI = B.CreateMemMove(
3245 Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
3251 CallInst *NewCI =
3259 Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(CallInst *CI,
3304 Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(CallInst *CI,
3319 Value *FortifiedLibCallSimplifier::optimizeMemCCpyChk(CallInst *CI,
3328 Value *FortifiedLibCallSimplifier::optimizeSNPrintfChk(CallInst *CI,
3339 Value *FortifiedLibCallSimplifier::optimizeSPrintfChk(CallInst *CI,
3350 Value *FortifiedLibCallSimplifier::optimizeStrCatChk(CallInst *CI,
3358 Value *FortifiedLibCallSimplifier::optimizeStrLCat(CallInst *CI,
3367 Value *FortifiedLibCallSimplifier::optimizeStrNCatChk(CallInst *CI,
3376 Value *FortifiedLibCallSimplifier::optimizeStrLCpyChk(CallInst *CI,
3385 Value *FortifiedLibCallSimplifier::optimizeVSNPrintfChk(CallInst *CI,
3394 Value *FortifiedLibCallSimplifier::optimizeVSPrintfChk(CallInst *CI,
3403 Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI) {
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 669 auto *CI = dyn_cast<CallInst>(&I);
669 auto *CI = dyn_cast<CallInst>(&I);
lib/Transforms/Vectorize/LoopVectorize.cpp 1292 unsigned getVectorIntrinsicCost(CallInst *CI, unsigned VF);
1299 unsigned getVectorCallCost(CallInst *CI, unsigned VF, bool &NeedToScalarize);
3220 unsigned LoopVectorizationCostModel::getVectorCallCost(CallInst *CI,
3264 unsigned LoopVectorizationCostModel::getVectorIntrinsicCost(CallInst *CI,
4264 auto *CI = cast<CallInst>(&I);
4264 auto *CI = cast<CallInst>(&I);
4320 CallInst *V = Builder.CreateCall(VectorF, Args, OpBundles);
5929 CallInst *CI = dyn_cast<CallInst>(I);
5929 CallInst *CI = dyn_cast<CallInst>(I);
6306 CallInst *CI = cast<CallInst>(I);
6306 CallInst *CI = cast<CallInst>(I);
6891 if (CallInst *CI = dyn_cast<CallInst>(I)) {
6891 if (CallInst *CI = dyn_cast<CallInst>(I)) {
6902 if (CallInst *CI = dyn_cast<CallInst>(I)) {
6902 if (CallInst *CI = dyn_cast<CallInst>(I)) {
lib/Transforms/Vectorize/SLPVectorizer.cpp 452 CallInst *CI = cast<CallInst>(UserInst);
452 CallInst *CI = cast<CallInst>(UserInst);
2690 CallInst *CI = cast<CallInst>(VL0);
2690 CallInst *CI = cast<CallInst>(VL0);
2708 CallInst *CI2 = dyn_cast<CallInst>(V);
2708 CallInst *CI2 = dyn_cast<CallInst>(V);
2756 auto *CI2 = cast<CallInst>(V);
2756 auto *CI2 = cast<CallInst>(V);
3195 CallInst *CI = cast<CallInst>(VL0);
3195 CallInst *CI = cast<CallInst>(VL0);
3401 if ((isa<CallInst>(&*PrevInstIt) &&
4110 CallInst *CI = cast<CallInst>(VL0);
4110 CallInst *CI = cast<CallInst>(VL0);
4124 CallInst *CEI = cast<CallInst>(VL0);
4124 CallInst *CEI = cast<CallInst>(VL0);
6989 if (it->use_empty() && (it->getType()->isVoidTy() || isa<CallInst>(it) ||
tools/bugpoint-passes/TestPasses.cpp 37 if (isa<CallInst>(*I))
60 if (CallInst *CI = dyn_cast<CallInst>(I)) {
60 if (CallInst *CI = dyn_cast<CallInst>(I)) {
tools/bugpoint/Miscompilation.cpp 816 CallInst *call = CallInst::Create(oldMainProto, args, "", BB);
816 CallInst *call = CallInst::Create(oldMainProto, args, "", BB);
891 CallInst *Resolver = CallInst::Create(resolverFunc, ResolverArgs,
891 CallInst *Resolver = CallInst::Create(resolverFunc, ResolverArgs,
915 CallInst::Create(FuncTy, FuncPtr, Args, "", DoCallBB);
918 CallInst *Call =
919 CallInst::Create(FuncTy, FuncPtr, Args, "retval", DoCallBB);
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGBuilder.h 274 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, llvm::Value *Size,
280 llvm::CallInst *CreateMemCpy(Address Dest, Address Src, uint64_t Size,
288 llvm::CallInst *CreateMemMove(Address Dest, Address Src, llvm::Value *Size,
296 llvm::CallInst *CreateMemSet(Address Dest, llvm::Value *Value,
tools/clang/lib/CodeGen/CGBuiltin.cpp 409 llvm::CallInst *Call = CGF.Builder.CreateCall(F, V);
1072 llvm::CallInst *CI = Builder.CreateCall(IA, EmitScalarExpr(E->getArg(0)));
12320 llvm::CallInst *CI = Builder.CreateCall(IA);
12978 CallInst *CI = cast<CallInst>(
12978 CallInst *CI = cast<CallInst>(
12987 CallInst *CI = cast<CallInst>(
12987 CallInst *CI = cast<CallInst>(
tools/clang/lib/CodeGen/CGCUDANV.cpp 648 llvm::CallInst *RegisterFatbinCall = CtorBuilder.CreateCall(
666 llvm::CallInst *RegisterFatbinCall = CtorBuilder.CreateCall(
tools/clang/lib/CodeGen/CGCXXABI.cpp 301 llvm::CallInst *
tools/clang/lib/CodeGen/CGCXXABI.h 242 virtual llvm::CallInst *
tools/clang/lib/CodeGen/CGCall.cpp 2618 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
2618 llvm::CallInst *call = dyn_cast<llvm::CallInst>(generator);
2684 llvm::CallInst *retainCall =
2685 dyn_cast<llvm::CallInst>(result->stripPointerCasts());
3655 llvm::CallInst *
3662 llvm::CallInst *
3666 llvm::CallInst *call = EmitRuntimeCall(callee, args, name);
3673 llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee,
3698 llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee,
3701 llvm::CallInst *call = Builder.CreateCall(
3723 llvm::CallInst *call = Builder.CreateCall(callee, args, BundleList);
4397 if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(CI)) {
4397 if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(CI)) {
4399 Call->setTailCallKind(llvm::CallInst::TCK_NoTail);
tools/clang/lib/CodeGen/CGCall.h 352 llvm::CallInst *StackBase;
tools/clang/lib/CodeGen/CGClass.cpp 1430 llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap);
tools/clang/lib/CodeGen/CGCoroutine.cpp 68 llvm::CallInst *CoroId = nullptr;
73 llvm::CallInst *CoroBegin = nullptr;
77 llvm::CallInst *LastCoroFree = nullptr;
91 llvm::CallInst *CoroId,
199 auto *SaveCall = Builder.CreateCall(CoroSave, {NullPtr});
214 auto *SuspendResult = Builder.CreateCall(
403 auto *CoroEnd = CGF.Builder.CreateCall(
443 auto *CoroFree = CGF.CurCoro.Data->LastCoroFree;
554 auto *CoroId = Builder.CreateCall(
562 auto *CoroAlloc = Builder.CreateCall(
594 auto *CoroBegin = Builder.CreateCall(
738 llvm::CallInst *Call = Builder.CreateCall(F, Args);
tools/clang/lib/CodeGen/CGDecl.cpp 1296 llvm::CallInst *C =
1307 llvm::CallInst *C =
tools/clang/lib/CodeGen/CGDeclCXX.cpp 248 llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);
744 llvm::CallInst *CI = Builder.CreateCall(CalleeTy, Callee, Arg);
tools/clang/lib/CodeGen/CGException.cpp 981 llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI);
983 llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI);
1029 llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI);
1109 llvm::CallInst *typeIndex =
1480 llvm::CallInst *terminateCall =
1504 llvm::CallInst *terminateCall =
1549 llvm::CallInst *terminateCall =
1714 llvm::CallInst *RecoverCall = nullptr;
1739 RecoverCall = cast<llvm::CallInst>(ParentRecover->clone());
tools/clang/lib/CodeGen/CGExpr.cpp 2996 llvm::CallInst *HandlerCall = CGF.EmitNounwindRuntimeCall(Fn, FnArgs);
3131 llvm::CallInst *CheckCall;
3175 llvm::CallInst::Create(
3291 llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap);
3302 llvm::CallInst *CodeGenFunction::EmitTrapCall(llvm::Intrinsic::ID IntrID) {
3303 llvm::CallInst *TrapCall = Builder.CreateCall(CGM.getIntrinsic(IntrID));
tools/clang/lib/CodeGen/CGExprScalar.cpp 2030 if (llvm::CallInst *CI = dyn_cast<llvm::CallInst>(Src))
2030 if (llvm::CallInst *CI = dyn_cast<llvm::CallInst>(Src))
4612 auto *ResultAndOverflow = Builder.CreateCall(
tools/clang/lib/CodeGen/CGObjC.cpp 1120 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(CallInstruction))
1120 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(CallInstruction))
1986 llvm::CallInst::TailCallKind tailKind = llvm::CallInst::TCK_None) {
1986 llvm::CallInst::TailCallKind tailKind = llvm::CallInst::TCK_None) {
2000 llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(fn, value);
2051 llvm::CallInst *result = CGF.EmitNounwindRuntimeCall(fn, args);
2146 llvm::CallInst *call
2147 = cast<llvm::CallInst>(result->stripPointerCasts());
2203 llvm::CallInst::TailCallKind tailKind =
2206 ? llvm::CallInst::TCK_NoTail
2207 : llvm::CallInst::TCK_None;
2245 llvm::CallInst *call = EmitNounwindRuntimeCall(fn, value);
2348 llvm::CallInst::TCK_Tail);
2358 llvm::CallInst::TCK_Tail);
2772 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) {
2772 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) {
tools/clang/lib/CodeGen/CGObjCGNU.cpp 795 llvm::CallInst *slot =
tools/clang/lib/CodeGen/CGObjCMac.cpp 3028 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
4257 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4282 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4519 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4556 llvm::CallInst *Caught =
4583 llvm::CallInst *SetJmpResult =
4656 llvm::CallInst *Match =
4714 llvm::CallInst *NewCaught =
4746 llvm::CallInst *Caught =
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 1734 llvm::CallInst *Call = CGF.Builder.CreateCall(
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 2722 llvm::CallInst *Call = CGF.EmitRuntimeCall(
2738 llvm::CallInst *Call = CGF.EmitRuntimeCall(
tools/clang/lib/CodeGen/CGStmt.cpp 2287 llvm::CallInst *Result =
tools/clang/lib/CodeGen/CGVTables.cpp 376 else if (llvm::CallInst* Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
376 else if (llvm::CallInst* Call = dyn_cast<llvm::CallInst>(CallOrInvoke))
377 Call->setTailCallKind(llvm::CallInst::TCK_Tail);
420 llvm::CallInst *Call = Builder.CreateCall(Callee, Args);
421 Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
tools/clang/lib/CodeGen/CodeGenFunction.cpp 2278 llvm::CallInst *Result = Builder.CreateCall(FuncToReturn, Args);
2279 Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2325 llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap);
tools/clang/lib/CodeGen/CodeGenFunction.h 3618 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
3620 llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee,
3623 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
3625 llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee,
4131 llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID);
tools/clang/lib/CodeGen/CodeGenModule.cpp 4322 if (dyn_cast<llvm::CallInst>(callSite)) {
4324 llvm::CallInst::Create(newFn, newArgs, newBundles, "", callSite);
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 166 llvm::CallInst *
1252 llvm::CallInst *ExceptionPtr = CGF.EmitNounwindRuntimeCall(
2680 llvm::CallInst *CallVal = Builder.CreateCall(InitFnTy, Init);
2722 llvm::CallInst *CallVal = CGF.Builder.CreateCall(Wrapper);
4078 llvm::CallInst *call =
4233 llvm::CallInst *rawAdjustedExn =
4342 llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
4347 llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());
4358 llvm::CallInst *
tools/lldb/source/Expression/IRInterpreter.cpp 72 static bool CanIgnoreCall(const CallInst *call) {
525 CallInst *call_inst = dyn_cast<CallInst>(ii);
525 CallInst *call_inst = dyn_cast<CallInst>(ii);
1443 const CallInst *call_inst = dyn_cast<CallInst>(inst);
1443 const CallInst *call_inst = dyn_cast<CallInst>(inst);
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp 352 CallInst::Create(m_valid_pointer_check_func, args, "", inst);
389 CallInst *call_inst = dyn_cast<CallInst>(inst);
389 CallInst *call_inst = dyn_cast<CallInst>(inst);
444 CallInst::Create(m_objc_object_check_func, args, "", inst);
467 static llvm::Function *GetCalledFunction(llvm::CallInst *inst) {
474 CallInst *call_inst = dyn_cast<CallInst>(&i);
474 CallInst *call_inst = dyn_cast<CallInst>(&i);
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp 530 return CallInst::Create(
880 CallInst *srN_call = CallInst::Create(m_sel_registerName, srN_arguments,
880 CallInst *srN_call = CallInst::Create(m_sel_registerName, srN_arguments,
1031 CallInst *ogC_call = CallInst::Create(m_objc_getClass, ogC_arguments,
1031 CallInst *ogC_call = CallInst::Create(m_objc_getClass, ogC_arguments,
1311 bool IRForTarget::MaybeHandleCallArguments(CallInst *Old) {
1387 std::vector<CallInst *> calls_to_remove;
1390 CallInst *call = dyn_cast<CallInst>(&inst);
1390 CallInst *call = dyn_cast<CallInst>(&inst);
1412 for (CallInst *ci : calls_to_remove)
1422 CallInst *call = dyn_cast<CallInst>(&inst);
1422 CallInst *call = dyn_cast<CallInst>(&inst);
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h 370 bool MaybeHandleCallArguments(llvm::CallInst *call_inst);
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp 28 bool isRSAPICall(llvm::Module &module, llvm::CallInst *call_inst) {
42 bool isRSLargeReturnCall(llvm::Module &module, llvm::CallInst *call_inst) {
71 bool isRSAllocationTyCallSite(llvm::Module &module, llvm::CallInst *call_inst) {
81 llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) {
127 std::set<llvm::CallInst *> &rs_callsites,
128 bool (*predicate)(llvm::Module &, llvm::CallInst *)) {
134 llvm::CallInst *call_inst =
135 llvm::dyn_cast_or_null<llvm::CallInst>(&inst);
152 std::set<llvm::CallInst *> rs_callsites;
194 llvm::CallInst *new_call_inst =
195 llvm::CallInst::Create(new_func_type, new_func_addr_load, new_call_args,
224 std::set<llvm::CallInst *> rs_callsites;
tools/llvm-diff/DiffConsumer.cpp 56 } else if (isa<CallInst>(V)) {
58 printValue(cast<CallInst>(V)->getCalledValue(), isL);
tools/llvm-diff/DifferenceEngine.cpp 260 } else if (isa<CallInst>(L)) {
638 if (!isa<CallInst>(*I)) return;
639 CallInst *LCall = cast<CallInst>(&*I);
639 CallInst *LCall = cast<CallInst>(&*I);
651 if (!isa<CallInst>(*I)) return;
652 CallInst *RCall = cast<CallInst>(I);
652 CallInst *RCall = cast<CallInst>(I);
tools/llvm-reduce/deltas/ReduceArguments.cpp 27 if (auto *CI = dyn_cast<CallInst>(*I++)) {
27 if (auto *CI = dyn_cast<CallInst>(*I++)) {
33 CallInst *NewCI = CallInst::Create(&NewF, Args);
33 CallInst *NewCI = CallInst::Create(&NewF, Args);
tools/llvm-reduce/deltas/ReduceFunctions.cpp 39 SetVector<CallInst *> CallsToRemove;
43 if (auto *Call = dyn_cast<CallInst>(U)) {
43 if (auto *Call = dyn_cast<CallInst>(U)) {
51 for (auto *C : CallsToRemove)
tools/opt/Debugify.cpp 55 if (auto *I = BB.getTerminatingMustTailCall())
57 if (auto *I = BB.getTerminatingDeoptimizeCall())
tools/polly/include/polly/ScopDetection.h 351 bool isValidCallInst(CallInst &CI, DetectionContext &Context) const;
tools/polly/include/polly/Support/SCEVValidator.h 28 bool isConstCall(llvm::CallInst *Call);
tools/polly/include/polly/Support/ScopHelper.h 85 /* implicit */ MemAccInst(llvm::CallInst *CI) : I(CI) {}
91 llvm::isa<llvm::CallInst>(V) || llvm::isa<llvm::MemIntrinsic>(V);
95 llvm::isa<llvm::CallInst>(V) || llvm::isa<llvm::MemIntrinsic>(V);
151 MemAccInst &operator=(llvm::CallInst &CI) {
155 MemAccInst &operator=(llvm::CallInst *CI) {
261 bool isCallInst() const { return I && llvm::isa<llvm::CallInst>(I); }
270 llvm::CallInst *asCallInst() const { return llvm::cast<llvm::CallInst>(I); }
270 llvm::CallInst *asCallInst() const { return llvm::cast<llvm::CallInst>(I); }
tools/polly/lib/Analysis/ScopBuilder.cpp 1413 auto *MallocCall = dyn_cast<CallInst>(MallocMem);
1413 auto *MallocCall = dyn_cast<CallInst>(MallocMem);
1527 auto *CI = dyn_cast_or_null<CallInst>(Assumption);
1527 auto *CI = dyn_cast_or_null<CallInst>(Assumption);
1794 auto *CI = dyn_cast_or_null<CallInst>(Inst);
1794 auto *CI = dyn_cast_or_null<CallInst>(Inst);
2113 (isa<CallInst>(Inst) && !isa<IntrinsicInst>(Inst))))
tools/polly/lib/Analysis/ScopDetection.cpp 668 bool ScopDetection::isValidCallInst(CallInst &CI,
1218 if (CallInst *CI = dyn_cast<CallInst>(&Inst)) {
1218 if (CallInst *CI = dyn_cast<CallInst>(&Inst)) {
tools/polly/lib/Analysis/ScopInfo.cpp 1474 static std::string getCallParamName(CallInst *Call) {
1499 CallInst *Call = dyn_cast<CallInst>(Val);
1499 CallInst *Call = dyn_cast<CallInst>(Val);
tools/polly/lib/CodeGen/IRBuilder.cpp 207 if (isa<CallInst>(Inst) && !isa<MemSetInst>(Inst))
tools/polly/lib/CodeGen/IslExprBuilder.cpp 134 auto *ResultStruct = Builder.CreateCall(F, {LHS, RHS}, Name);
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 1481 auto *CreatedArray = CallInst::CreateMalloc(
1490 CallInst::CreateFree(CreatedArray,
tools/polly/lib/Support/SCEVValidator.cpp 120 bool polly::isConstCall(llvm::CallInst *Call) {
356 auto Call = cast<CallInst>(I);
477 CallInst *Call = dyn_cast<CallInst>(Unknown->getValue());
477 CallInst *Call = dyn_cast<CallInst>(Unknown->getValue());
511 CallInst *Call = dyn_cast<CallInst>(Unknown->getValue());
511 CallInst *Call = dyn_cast<CallInst>(Unknown->getValue());
tools/polly/lib/Support/ScopHelper.cpp 430 if (CallInst *CI = dyn_cast<CallInst>(&Inst)) {
430 if (CallInst *CI = dyn_cast<CallInst>(&Inst)) {
725 auto *CI = dyn_cast<CallInst>(Inst);
725 auto *CI = dyn_cast<CallInst>(Inst);
tools/polly/lib/Transform/RewriteByReferenceParameters.cpp 41 auto *Call = dyn_cast<CallInst>(&Inst);
41 auto *Call = dyn_cast<CallInst>(&Inst);
unittests/Analysis/CGSCCPassManagerTest.cpp 1168 auto &H3F = *cast<CallInst>(H2F.begin()->begin())->getCalledFunction();
1220 (void)CallInst::Create(&H3F, {}, "", &*H2F.begin()->begin());
unittests/Analysis/LazyCallGraphTest.cpp 1136 CallInst *C1Call = nullptr, *D1Call = nullptr;
1138 CallInst *CI = dyn_cast<CallInst>(U);
1138 CallInst *CI = dyn_cast<CallInst>(U);
unittests/Analysis/MemoryBuiltinsTest.cpp 35 std::unique_ptr<CallInst> Caller(
36 CallInst::Create(AllocSizeFn, {ConstantInt::get(ArgTy, 100)}));
unittests/Analysis/SparsePropagation.cpp 146 return visitCallSite(cast<CallInst>(&I), ChangedValues, SS);
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp 219 CallInst *Call = Builder.CreateCall(Foo, {});
260 CallInst *Call1 = Builder.CreateCall(Foo1, {});
261 CallInst *Call2 = Builder.CreateCall(Foo2, {});
unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp 40 auto *Call = dyn_cast<CallInst>(std::next(II));
40 auto *Call = dyn_cast<CallInst>(std::next(II));
unittests/IR/IRBuilderTest.cpp 54 CallInst *Call;
127 CallInst *Call;
175 CallInst *Call;
303 CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
304 CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
305 CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));
unittests/IR/InstructionsTest.cpp 87 std::unique_ptr<CallInst> Call(CallInst::Create(F, Args));
87 std::unique_ptr<CallInst> Call(CallInst::Create(F, Args));
514 std::unique_ptr<CallInst> Call(
515 CallInst::Create(FnTy, Callee, Args, "result"));
518 CallInst::TailCallKind Kinds[] = {CallInst::TCK_None, CallInst::TCK_Tail,
518 CallInst::TailCallKind Kinds[] = {CallInst::TCK_None, CallInst::TCK_Tail,
518 CallInst::TailCallKind Kinds[] = {CallInst::TCK_None, CallInst::TCK_Tail,
519 CallInst::TCK_MustTail};
520 for (CallInst::TailCallKind TCK : Kinds) {
522 std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
522 std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
525 Call->setTailCallKind(CallInst::TCK_None);
533 std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
533 std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
545 std::unique_ptr<CallInst> Call(
546 CallInst::Create(FnTy, Callee, Args, OldBundle, "result"));
547 Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail);
554 std::unique_ptr<CallInst> Clone(CallInst::Create(Call.get(), NewBundle));
554 std::unique_ptr<CallInst> Clone(CallInst::Create(Call.get(), NewBundle));
unittests/IR/LegacyPassManagerTest.cpp 537 CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry);
537 CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry);
553 CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5);
553 CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5);
569 CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8);
569 CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8);
unittests/IR/MetadataTest.cpp 385 CallInst::Create(Intrinsic, MAV0, "", BB0);
386 CallInst::Create(Intrinsic, MAV1, "", BB1);
412 CallInst *CI0 = CallInst::Create(F1, "", BB0);
412 CallInst *CI0 = CallInst::Create(F1, "", BB0);
unittests/IR/VerifierTest.cpp 78 CallInst::Create(F2,"call",Entry1);
unittests/IR/WaymarkTest.cpp 31 const CallInst *A = CallInst::Create(F.get(), makeArrayRef(values));
31 const CallInst *A = CallInst::Create(F.get(), makeArrayRef(values));
unittests/Linker/LinkModulesTest.cpp 260 auto *CI = cast<CallInst>(&BB->front());
260 auto *CI = cast<CallInst>(&BB->front());
289 CI = cast<CallInst>(&BB->front());
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-message.h 116 inline Message& operator <<(const T& val) {
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
utils/unittest/googletest/include/gtest/gtest.h 1475 T* rhs) {
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);
54 const T& V;
55 friend std::ostream &operator<<(std::ostream &S, const RawStreamProxy<T> &V) {
69 static const RawStreamProxy<T> printable(const T &V) { return {V}; }
69 static const RawStreamProxy<T> printable(const T &V) { return {V}; }