reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

examples/BrainF/BrainF.cpp

  211               builder->CreateCall(getchar_func, {}, tapereg);
  238             CreateCall(putchar_func,

lib/CodeGen/AtomicExpandPass.cpp

 1776   CallInst *Call = Builder.CreateCall(LibcallFn, Args);

lib/CodeGen/IntrinsicLowering.cpp

   46   CallInst *NewCI = Builder.CreateCall(FCache, Args);

lib/CodeGen/PreISelIntrinsicLowering.cpp

   85     CallInst *NewCI = Builder.CreateCall(FCache, Args);

lib/CodeGen/SafeStack.cpp

  480   IRBFail.CreateCall(StackChkFail, {});
  780     UnsafeStackPtr = IRB.CreateCall(Fn);

lib/CodeGen/StackProtector.cpp

  533     B.CreateCall(StackChkFail, B.CreateGlobalStringPtr(F->getName(), "SSH"));
  538     B.CreateCall(StackChkFail, {});

lib/CodeGen/TargetLoweringBase.cpp

 1719   return IRB.CreateCall(Fn);

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  507     Value *Result = Builder.CreateCall(Intrin, {LHS, RHS});

lib/Target/AMDGPU/AMDGPULibCalls.cpp

  225   CallInst *R = B.CreateCall(Callee, Arg, Name);
  234   CallInst *R = B.CreateCall(Callee, {Arg1, Arg2}, Name);
  629   auto *NCI = B.CreateCall(F, Args);

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2274       NewCall = CondBuilder.CreateCall(Fn, {Op0, Op1, NumWords});

lib/Transforms/IPO/CrossDSOCFI.cpp

  134   IRBFail.CreateCall(CFICheckFailFn, {&CFICheckFailData, &Addr});

lib/Transforms/Instrumentation/AddressSanitizer.cpp

  992     IRB.CreateCall(
 1304     IRB.CreateCall(
 1310     IRB.CreateCall(
 1488   IRB.CreateCall(F, Param);
 1617       Call = IRB.CreateCall(AsanErrorCallbackSized[IsWrite][0],
 1620       Call = IRB.CreateCall(AsanErrorCallbackSized[IsWrite][1],
 1625           IRB.CreateCall(AsanErrorCallback[IsWrite][0][AccessSizeIndex], Addr);
 1627       Call = IRB.CreateCall(AsanErrorCallback[IsWrite][1][AccessSizeIndex],
 1669       IRB.CreateCall(AsanMemoryAccessCallback[IsWrite][0][AccessSizeIndex],
 1672       IRB.CreateCall(AsanMemoryAccessCallback[IsWrite][1][AccessSizeIndex],
 1746       IRB.CreateCall(AsanMemoryAccessCallbackSized[IsWrite][0],
 1749       IRB.CreateCall(AsanMemoryAccessCallbackSized[IsWrite][1],
 1768   IRB.CreateCall(AsanPoisonGlobals, ModuleNameAddr);
 2108   IRB.CreateCall(AsanRegisterElfGlobals,
 2116   IRB_Dtor.CreateCall(AsanUnregisterElfGlobals,
 2169   IRB.CreateCall(AsanRegisterImageGlobals,
 2175   IRB_Dtor.CreateCall(AsanUnregisterImageGlobals,
 2196   IRB.CreateCall(AsanRegisterGlobals,
 2203   IRB_Dtor.CreateCall(AsanUnregisterGlobals,
 2550     IRB.CreateCall(AsanInitFunction, {});
 2730     IRB.CreateCall(AsanHandleNoReturnFunc, {});
 2869       IRB.CreateCall(AsanSetShadowFunc[Val],
 3095         IRBIf.CreateCall(AsanStackMallocFunc[StackMallocIdx],
 3226         IRBPoison.CreateCall(
 3247   IRB.CreateCall(
 3307   IRB.CreateCall(AsanAllocaPoisonFunc, {NewAddress, OldSize});

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  988         ThenIRB.CreateCall(DFSF.DFS.DFSanNonzeroLabelFn, {});
 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(
 1484   IRB.CreateCall(DFSF.DFS.DFSanSetLabelFn,
 1556       IRB.CreateCall(DFSF.DFS.DFSanUnimplementedFn,
 1644         CallInst *CustomCI = IRB.CreateCall(CustomF, Args);

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  659     Builder.CreateCall(GCOVFlush);
  876     Builder.CreateCall(GCOVInit, {WriteoutF, FlushF});
 1102   auto *StartFileCall = Builder.CreateCall(
 1133   auto *EmitFunctionCall = Builder.CreateCall(
 1159   auto *EmitArcsCall = Builder.CreateCall(
 1175   Builder.CreateCall(SummaryInfo, {});
 1176   Builder.CreateCall(EndFile, {});

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  704     IRB.CreateCall(
  710     IRB.CreateCall(
  747       IRB.CreateCall(HwasanMemoryAccessCallback[IsWrite][AccessSizeIndex],
  753     IRB.CreateCall(HwasanMemoryAccessCallbackSized[IsWrite],
  782     IRB.CreateCall(HwasanTagMemoryFunc,
  827   return IRB.CreateZExt(IRB.CreateCall(HwasanGenerateTagFunc), IntptrTy);
  950     IRB.CreateCall(HwasanThreadEnterFunc);
 1033     IRB.CreateCall(
 1482     CallInst *WrapperCall = IRB.CreateCall(

lib/Transforms/Instrumentation/InstrProfiling.cpp

  617     Call = Builder.CreateCall(getOrInsertValueProfilingCall(*M, *TLI), Args);
  627         Builder.CreateCall(getOrInsertValueProfilingCall(*M, *TLI, true), Args);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1075     return IRB.CreateCall(MS.MsanChainOriginFn, V);
 1144         IRB.CreateCall(Fn, {ConvertedShadow2,
 1190       IRB.CreateCall(MS.WarningFn, Origin);
 1195       IRB.CreateCall(MS.WarningFn, {});
 1226       IRB.CreateCall(Fn, {ConvertedShadow2, MS.TrackOrigins && Origin
 1256     Value *ContextState = IRB.CreateCall(MS.MsanGetContextStateFn, {});
 1449       ShadowOriginPtrs = IRB.CreateCall(Getter, AddrCast);
 1452       ShadowOriginPtrs = IRB.CreateCall(isStore ? MS.MsanMetadataPtrForStoreN
 2407     IRB.CreateCall(
 2421     IRB.CreateCall(
 2432     IRB.CreateCall(
 3449       IRB.CreateCall(MS.MsanPoisonStackFn,
 3462       IRB.CreateCall(MS.MsanSetAllocaOrigin4Fn,
 3472       IRB.CreateCall(MS.MsanPoisonAllocaFn,
 3476       IRB.CreateCall(MS.MsanUnpoisonAllocaFn,
 3646     IRB.CreateCall(MS.MsanInstrumentAsmStoreFn, {Ptr, SizeVal});

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  469     IRBCtor.CreateCall(InitFunction, {SecStartEnd.first, SecStartEnd.second});
  736     IRB.CreateCall(SanCovTracePCIndir, IRB.CreatePointerCast(Callee, IntptrTy));
  777       IRB.CreateCall(SanCovTraceSwitchFunction,
  796     IRB.CreateCall(SanCovTraceDivFunction[CallbackIdx],
  807         IRB.CreateCall(SanCovTraceGepFunction,
  841       IRB.CreateCall(CallbackFunc, {IRB.CreateIntCast(A0, Ty, true),
  867     IRB.CreateCall(SanCovTracePC); // gets the PC using GET_CALLER_PC.
  875     IRB.CreateCall(SanCovTracePCGuard, GuardPtr);

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

  430   IRB.CreateCall(TsanIgnoreBegin);
  433     AtExit->CreateCall(TsanIgnoreEnd);
  507     IRB.CreateCall(TsanFuncEntry, ReturnAddress);
  511       AtExit->CreateCall(TsanFuncExit, {});
  547     IRB.CreateCall(TsanVptrUpdate,
  554     IRB.CreateCall(TsanVptrLoad,
  569   IRB.CreateCall(OnAccessFunc, IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()));
  603     IRB.CreateCall(
  610     IRB.CreateCall(
  642     Value *C = IRB.CreateCall(TsanAtomicLoad[Idx], Args);
  694     CallInst *C = IRB.CreateCall(TsanAtomicCAS[Idx], Args);

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1028     NewCall = Builder.CreateCall(MSP, {BasePtr, PatternPtr, NumBytes});

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);
 1263       B.CreateCall(F, {castToCStr(Ptr, B), Size,
 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);
 1367       B.CreateCall(F, {castToCStr(Str, B), Size, File}, FGetSUnlockedName);
 1390   CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});

lib/Transforms/Utils/ModuleUtils.cpp

  133   IRB.CreateCall(InitFunction, InitArgs);
  138     IRB.CreateCall(VersionCheckFunction, {});

lib/Transforms/Utils/SanitizerStats.cpp

   68   B.CreateCall(StatReport, ConstantExpr::getBitCast(InitAddr, Int8PtrTy));
  103   B.CreateCall(StatInit, ConstantExpr::getBitCast(NewModuleStatsGV, Int8PtrTy));

lib/Transforms/Utils/SimplifyLibCalls.cpp

 2106   SinCos = B.CreateCall(Callee, Arg, "sincospi");

tools/clang/lib/CodeGen/CGBuiltin.cpp

 1405   Value *Res = CGF.Builder.CreateCall(Func, {GString});
 1445     Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
 1470     TmpRes = CGF.Builder.CreateCall(Func, {GString, FieldPtr});
 1475   Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
 3587           Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3606       return RValue::get(Builder.CreateCall(
 3650         Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3688         Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3712     return RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3735         Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, NewName), {NewArg});
 3778           Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name, ByValAttrSet),
 3839           RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3898             Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3915           RValue::get(Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name),
 3932     return RValue::get(Builder.CreateCall(
 3946     return RValue::get(Builder.CreateCall(
 3967     return RValue::get(Builder.CreateCall(
10153   return Builder.CreateCall(Func);

tools/clang/lib/CodeGen/CGCUDANV.cpp

  434     Builder.CreateCall(RegisterFunc, Args);
  460     Builder.CreateCall(RegisterVar, Args);
  648       llvm::CallInst *RegisterFatbinCall = CtorBuilder.CreateCall(
  666     llvm::CallInst *RegisterFatbinCall = CtorBuilder.CreateCall(
  687       CtorBuilder.CreateCall(RegisterFatbinEndFunc, RegisterFatbinCall);
  713     CtorBuilder.CreateCall(RegisterLinkedBinaryFunc, Args);
  726     CtorBuilder.CreateCall(AtExitFunc, CleanupFn);
  788     DtorBuilder.CreateCall(UnregisterFatbinFunc, HandleValue);
  794     DtorBuilder.CreateCall(UnregisterFatbinFunc, HandleValue);

tools/clang/lib/CodeGen/CGClass.cpp

  814     Builder.CreateCall(

tools/clang/lib/CodeGen/CGDeclCXX.cpp

  248   llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);

tools/clang/lib/CodeGen/CGExpr.cpp

 3145     CheckCall = Builder.CreateCall(
 3151     CheckCall = Builder.CreateCall(SlowPathFn, {TypeId, Ptr});

tools/clang/lib/CodeGen/CGObjCGNU.cpp

  964     B.CreateCall(Fn, Args);
 2546       ReceiverClass = Builder.CreateCall(classLookupFunction,
 3808   Builder.CreateCall(Register, module);
 3972   return B.CreateCall(WeakReadFn, AddrWeakObj.getPointer());
 3980   B.CreateCall(WeakAssignFn, {src, dst.getPointer()});
 3991   B.CreateCall(GlobalAssignFn, {src, dst.getPointer()});
 4000   B.CreateCall(IvarAssignFn, {src, dst.getPointer(), ivarOffset});
 4008   B.CreateCall(StrongCastAssignFn, {src, dst.getPointer()});
 4019   B.CreateCall(MemMoveFn, {DestPtr.getPointer(), SrcPtr.getPointer(), Size});

tools/clang/lib/CodeGen/CGObjCMac.cpp

 3028   llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);

tools/clang/lib/CodeGen/CGObjCRuntime.cpp

  343   CGF.Builder.CreateCall(syncEnterFn, lock)->setDoesNotThrow();

tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

 1734   llvm::CallInst *Call = CGF.Builder.CreateCall(

tools/clang/lib/CodeGen/CGVTables.cpp

  420   llvm::CallInst *Call = Builder.CreateCall(Callee, Args);

tools/clang/lib/CodeGen/CodeGenModule.cpp

 5927   return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy,

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

 2031     CGF.Builder.CreateCall(F, NumElementsPtr.getPointer());
 2062   return CGF.Builder.CreateCall(F, numElementsPtr.getPointer());
 4342     llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
 4347     llvm::CallInst *termCall = builder.CreateCall(CGM.getTerminateFn());

tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp

  261     Builder.CreateCall(RegFuncC, BinDesc);
  282     Builder.CreateCall(UnRegFuncC, BinDesc);