Lines Matching defs:TheCall
215 static bool BuiltinAnnotation(Sema &S, CallExpr *TheCall) {
216 if (S.checkArgCount(TheCall, 2))
220 Expr *ValArg = TheCall->getArg(0);
229 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
237 TheCall->setType(Ty);
241 static bool BuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) {
243 if (TheCall->getNumArgs() < 1) {
244 S.Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
245 << 0 << 1 << TheCall->getNumArgs() << /*is non object*/ 0
246 << TheCall->getCallee()->getSourceRange();
251 for (Expr *Arg : TheCall->arguments()) {
265 static bool BuiltinAddressof(Sema &S, CallExpr *TheCall) {
266 if (S.checkArgCount(TheCall, 1))
269 ExprResult Arg(TheCall->getArg(0));
270 QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getBeginLoc());
274 TheCall->setArg(0, Arg.get());
275 TheCall->setType(ResultType);
280 static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall) {
281 if (S.checkArgCount(TheCall, 1))
284 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
288 TheCall->setArg(0, Arg.get());
293 S.Diag(TheCall->getBeginLoc(), diag::err_function_start_invalid_type)
294 << TheCall->getSourceRange();
299 TheCall->getBeginLoc());
304 static bool BuiltinPreserveAI(Sema &S, CallExpr *TheCall) {
305 if (S.checkArgCount(TheCall, 1))
308 TheCall->setType(TheCall->getArg(0)->getType());
315 static bool BuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {
316 if (S.checkArgCount(TheCall, 2))
319 clang::Expr *Source = TheCall->getArg(0);
339 clang::Expr *AlignOp = TheCall->getArg(1);
378 TheCall->setArg(0, SrcArg.get());
385 TheCall->setArg(1, AlignArg.get());
389 TheCall->setType(IsBooleanAlignBuiltin ? S.Context.BoolTy : SrcTy);
393 static bool BuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID) {
394 if (S.checkArgCount(TheCall, 3))
405 return BuiltinID == P.first && TheCall->getExprLoc().isMacroID() &&
406 Lexer::getImmediateMacroName(TheCall->getExprLoc(),
425 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(I));
427 TheCall->setArg(I, Arg.get());
442 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(2));
444 TheCall->setArg(2, Arg.get());
463 const auto Arg = TheCall->getArg(I);
480 CallExpr *TheCall;
481 SourceLocation Loc = TheCall->getBeginLoc();
486 BuiltinDumpStructGenerator(Sema &S, CallExpr *TheCall)
487 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
509 assert(TheCall->getNumArgs() >= 2);
510 Args.reserve((TheCall->getNumArgs() - 2) + /*Format*/ 1 + Exprs.size());
511 Args.assign(TheCall->arg_begin() + 2, TheCall->arg_end());
524 S.BuildCallExpr(/*Scope=*/nullptr, TheCall->getArg(1),
525 TheCall->getBeginLoc(), Args, TheCall->getRParenLoc());
712 auto *Wrapper = PseudoObjectExpr::Create(S.Context, TheCall, Actions,
714 TheCall->setType(Wrapper->getType());
715 TheCall->setValueKind(Wrapper->getValueKind());
721 static ExprResult BuiltinDumpStruct(Sema &S, CallExpr *TheCall) {
722 if (S.checkArgCountAtLeast(TheCall, 2))
725 ExprResult PtrArgResult = S.DefaultLvalueConversion(TheCall->getArg(0));
728 TheCall->setArg(0, PtrArgResult.get());
736 << 1 << TheCall->getDirectCallee() << PtrArgType;
748 QualType FnArgType = TheCall->getArg(1)->getType();
764 S.Diag(TheCall->getArg(1)->getBeginLoc(),
766 << 2 << TheCall->getDirectCallee() << FnArgType;
771 BuiltinDumpStructGenerator Generator(S, TheCall);
1134 CallExpr *TheCall) {
1135 if (TheCall->isValueDependent() || TheCall->isTypeDependent() ||
1168 if (NewIndex >= TheCall->getNumArgs())
1180 Expr *SizeArg = TheCall->getArg(NewIndex);
1206 if (NewIndex >= TheCall->getNumArgs())
1209 const Expr *ObjArg = TheCall->getArg(NewIndex);
1225 const Expr *ObjArg = TheCall->getArg(NewIndex);
1282 TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
1294 DiagRuntimeBehavior(TheCall->getArg(Index)->getBeginLoc(), TheCall,
1317 auto *FormatExpr = TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
1354 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 2);
1356 ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1382 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1396 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1406 const auto *FormatExpr = TheCall->getArg(2)->IgnoreParenImpCasts();
1427 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
1448 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
1453 static bool BuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
1466 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1467 SemaRef.Diag(TheCall->getExprLoc(), DiagID)
1477 static void builtinAllocaAddrSpace(Sema &S, CallExpr *TheCall) {
1478 QualType RT = TheCall->getType();
1484 TheCall->setType(S.Context.getPointerType(RT));
1782 static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall) {
1783 if (S.checkArgCount(TheCall, 1))
1792 QualType ArgTy = TheCall->getArg(0)->getType();
1801 TheCall->setType(ParamTy);
1813 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_launder_invalid_arg)
1814 << *DiagSelect << TheCall->getSourceRange();
1824 if (S.RequireCompleteType(TheCall->getBeginLoc(), ParamTy->getPointeeType(),
1834 S.PerformCopyInitialization(Entity, SourceLocation(), TheCall->getArg(0));
1837 TheCall->setArg(0, Arg.get());
1839 return TheCall;
1842 static ExprResult BuiltinIsWithinLifetime(Sema &S, CallExpr *TheCall) {
1843 if (S.checkArgCount(TheCall, 1))
1846 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
1850 TheCall->setArg(0, Arg.get());
1851 TheCall->setType(S.Context.BoolTy);
1858 S.Diag(TheCall->getArg(0)->getExprLoc(),
1866 S.Diag(TheCall->getArg(0)->getExprLoc(), diag::err_vla_unsupported)
1871 S.Diag(TheCall->getArg(0)->getExprLoc(),
1877 return TheCall;
1883 Sema &S, unsigned BuiltinID, CallExpr *TheCall,
1888 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
1889 << TheCall->getSourceRange();
1898 CheckBuiltinTargetInSupported(Sema &S, CallExpr *TheCall,
1904 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
1905 << TheCall->getSourceRange();
1913 CallExpr *TheCall) {
1923 return ARM().CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
1927 return ARM().CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
1930 return BPF().CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
1932 return Hexagon().CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
1937 return MIPS().CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
1939 return SPIRV().CheckSPIRVBuiltinFunctionCall(BuiltinID, TheCall);
1941 return SystemZ().CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
1944 return X86().CheckBuiltinFunctionCall(TI, BuiltinID, TheCall);
1949 return PPC().CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
1951 return AMDGPU().CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
1954 return RISCV().CheckBuiltinFunctionCall(TI, BuiltinID, TheCall);
1958 TheCall);
1961 return Wasm().CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
1964 return NVPTX().CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
1999 static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall,
2016 return S.Diag(TheCall->getBeginLoc(),
2020 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
2022 Expr *Arg = TheCall->getArg(0)->IgnoreParenImpCasts();
2025 return S.Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
2031 S.Diag(TheCall->getBeginLoc(), diag::warn_invalid_cpu_supports)
2036 return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_is)
2043 static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall) {
2044 if (S.checkArgCount(TheCall, 1))
2047 ExprResult ArgRes = S.DefaultLvalueConversion(TheCall->getArg(0));
2052 TheCall->setArg(0, Arg);
2067 static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) {
2068 if (S.checkArgCountRange(TheCall, 1, 2))
2071 ExprResult Arg0Res = S.DefaultLvalueConversion(TheCall->getArg(0));
2076 TheCall->setArg(0, Arg0);
2086 if (TheCall->getNumArgs() > 1) {
2087 ExprResult Arg1Res = S.UsualUnaryConversions(TheCall->getArg(1));
2092 TheCall->setArg(1, Arg1);
2108 CallExpr *TheCall) {
2109 ExprResult TheCallResult(TheCall);
2126 if (ArgNo < TheCall->getNumArgs() &&
2127 BuiltinConstantArg(TheCall, ArgNo, Result))
2136 if (BuiltinCpu(*this, Context.getTargetInfo(), TheCall,
2142 Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
2143 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
2151 *this, BuiltinID, TheCall,
2154 assert(TheCall->getNumArgs() == 1 &&
2156 if (ObjC().CheckObjCString(TheCall->getArg(0)))
2162 if (BuiltinVAStart(BuiltinID, TheCall))
2170 if (BuiltinVAStartARMMicrosoft(TheCall))
2174 if (BuiltinVAStart(BuiltinID, TheCall))
2189 *this, TheCall,
2202 *this, TheCall,
2210 *this, TheCall,
2224 if (BuiltinUnorderedCompare(TheCall, BuiltinID))
2228 if (BuiltinFPClassification(TheCall, 6, BuiltinID))
2232 if (BuiltinFPClassification(TheCall, 2, BuiltinID))
2246 if (BuiltinFPClassification(TheCall, 1, BuiltinID))
2250 return BuiltinShuffleVector(TheCall);
2251 // TheCall will be freed by the smart pointer here, but that's fine, since
2254 if (BuiltinPrefetch(TheCall))
2259 if (BuiltinAllocaWithAlign(TheCall))
2264 Diag(TheCall->getBeginLoc(), diag::warn_alloca)
2265 << TheCall->getDirectCallee();
2267 builtinAllocaAddrSpace(*this, TheCall);
2271 if (BuiltinArithmeticFence(TheCall))
2276 if (BuiltinAssume(TheCall))
2280 if (BuiltinAssumeAligned(TheCall))
2285 if (BuiltinConstantArgRange(TheCall, 1, 0, 3))
2289 if (BuiltinLongjmp(TheCall))
2293 if (BuiltinSetjmp(TheCall))
2297 if (checkArgCount(TheCall, 1))
2299 TheCall->setType(Context.IntTy);
2302 if (BuiltinComplex(TheCall))
2306 if (checkArgCount(TheCall, 1))
2308 ExprResult Arg = DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
2310 TheCall->setArg(0, Arg.get());
2311 TheCall->setType(Context.IntTy);
2315 return BuiltinLaunder(*this, TheCall);
2317 return BuiltinIsWithinLifetime(*this, TheCall);
2422 Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst)
2423 << TheCall->getCallee()->getSourceRange();
2429 clang::Expr *SizeOp = TheCall->getArg(2);
2436 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
2437 CheckNonNullArgument(*this, TheCall->getArg(1), TheCall->getExprLoc());
2442 clang::Expr *SizeOp = TheCall->getArg(2);
2449 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
2458 if (BuiltinMSVCAnnotation(*this, TheCall))
2462 if (BuiltinAnnotation(*this, TheCall))
2466 if (BuiltinAddressof(*this, TheCall))
2470 if (BuiltinFunctionStart(*this, TheCall))
2476 if (BuiltinAlignment(*this, TheCall, BuiltinID))
2482 if (BuiltinOverflow(*this, TheCall, BuiltinID))
2495 return BuiltinDumpStruct(*this, TheCall);
2498 if (checkArgCount(TheCall, 3))
2501 const Expr *ProbArg = TheCall->getArg(2);
2526 if (BuiltinPreserveAI(*this, TheCall))
2530 if (BuiltinCallWithStaticChain(*this, TheCall))
2535 if (BuiltinSEHScopeCheck(*this, TheCall, Scope::SEHExceptScope,
2541 if (BuiltinSEHScopeCheck(*this, TheCall, Scope::SEHFilterScope,
2546 if (checkArgCount(TheCall, 1))
2550 TheCall->getBeginLoc(),
2552 TheCall))
2555 TheCall->setType(Context.VoidPtrTy);
2567 if (checkArgCount(TheCall, 1))
2578 Diag(TheCall->getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2585 return PointerAuthStrip(*this, TheCall);
2587 return PointerAuthBlendDiscriminator(*this, TheCall);
2589 return PointerAuthSignOrAuth(*this, TheCall, PAO_Sign,
2592 return PointerAuthSignOrAuth(*this, TheCall, PAO_Sign,
2595 return PointerAuthSignOrAuth(*this, TheCall, PAO_Auth,
2598 return PointerAuthSignGenericData(*this, TheCall);
2600 return PointerAuthAuthAndResign(*this, TheCall);
2602 return PointerAuthStringDiscriminator(*this, TheCall);
2608 if (OpenCL().checkBuiltinRWPipe(TheCall))
2615 if (OpenCL().checkBuiltinReserveRWPipe(TheCall))
2620 if (OpenCL().checkSubgroupExt(TheCall) ||
2621 OpenCL().checkBuiltinReserveRWPipe(TheCall))
2628 if (OpenCL().checkBuiltinCommitRWPipe(TheCall))
2633 if (OpenCL().checkSubgroupExt(TheCall) ||
2634 OpenCL().checkBuiltinCommitRWPipe(TheCall))
2639 if (OpenCL().checkBuiltinPipePackets(TheCall))
2645 if (OpenCL().checkBuiltinToAddr(BuiltinID, TheCall))
2650 if (OpenCL().checkBuiltinEnqueueKernel(TheCall))
2655 if (OpenCL().checkBuiltinKernelWorkGroupSize(TheCall))
2660 if (OpenCL().checkBuiltinNDRangeAndBlock(TheCall))
2667 if (BuiltinOSLogFormat(TheCall))
2672 if (BuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
2678 if (!TheCall->getArg(0)->isValueDependent() &&
2679 TheCall->getArg(0)->EvaluateAsInt(Result, getASTContext()) &&
2681 Diag(TheCall->getBeginLoc(), diag::warn_frame_address)
2685 << TheCall->getSourceRange();
2690 if (BuiltinNonDeterministicValue(TheCall))
2698 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2701 QualType ArgTy = TheCall->getArg(0)->getType();
2707 Diag(TheCall->getArg(0)->getBeginLoc(),
2740 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2743 QualType ArgTy = TheCall->getArg(0)->getType();
2744 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2750 if (BuiltinElementwiseTernaryMath(TheCall))
2762 if (BuiltinElementwiseMath(TheCall, /*FPOnly=*/true))
2771 if (BuiltinElementwiseMath(TheCall))
2774 const Expr *Arg = TheCall->getArg(0);
2791 if (BuiltinElementwiseMath(TheCall))
2796 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2799 const Expr *Arg = TheCall->getArg(0);
2815 if (checkArgCount(TheCall, 2))
2818 ExprResult Magnitude = UsualUnaryConversions(TheCall->getArg(0));
2819 ExprResult Sign = UsualUnaryConversions(TheCall->getArg(1));
2825 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2827 checkFPMathBuiltinElementType(*this, TheCall->getArg(1)->getBeginLoc(),
2838 TheCall->setArg(0, Magnitude.get());
2839 TheCall->setArg(1, Sign.get());
2840 TheCall->setType(Magnitude.get()->getType());
2845 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2848 const Expr *Arg = TheCall->getArg(0);
2863 TheCall->setType(ElTy);
2868 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2871 const Expr *Arg = TheCall->getArg(0);
2886 TheCall->setType(ElTy);
2897 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2900 const Expr *Arg = TheCall->getArg(0);
2915 TheCall->setType(ElTy);
2920 return BuiltinMatrixTranspose(TheCall, TheCallResult);
2923 return BuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
2926 return BuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
2929 if (!checkBuiltinVerboseTrap(TheCall, *this))
2934 auto Check = [](CallExpr *TheCall) {
2935 if (TheCall->getNumArgs() != 1)
2937 auto *DRE = dyn_cast<DeclRefExpr>(TheCall->getArg(0)->IgnoreImpCasts());
2946 if (!Check(TheCall)) {
2947 Diag(TheCall->getBeginLoc(),
2954 if (BuiltinPopcountg(*this, TheCall))
2959 if (BuiltinCountZeroBitsGeneric(*this, TheCall))
2964 Expr *Arg = TheCall->getArg(0);
2967 Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
2974 if (BuiltinCountedByRef(TheCall))
2979 if (getLangOpts().HLSL && HLSL().CheckBuiltinFunctionCall(BuiltinID, TheCall))
2991 Context.BuiltinInfo.getAuxBuiltinID(BuiltinID), TheCall))
2995 TheCall))
3003 bool Sema::ValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum) {
3006 Expr *Arg = TheCall->getArg(ArgNum);
3011 if (BuiltinConstantArg(TheCall, ArgNum, Result))
3018 return Diag(TheCall->getBeginLoc(),
3484 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
3486 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
3488 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
3491 TheCall->getCallee());
3492 Expr** Args = TheCall->getArgs();
3493 unsigned NumArgs = TheCall->getNumArgs();
3506 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
3520 CheckArgAlignment(TheCall->getRParenLoc(), FDecl, "'this'", ThisType,
3525 IsMemberFunction, TheCall->getRParenLoc(),
3526 TheCall->getCallee()->getSourceRange(), CallType);
3536 CheckTCBEnforcement(TheCall->getExprLoc(), FDecl);
3538 CheckAbsoluteValueFunction(TheCall, FDecl);
3539 CheckMaxUnsignedZero(TheCall, FDecl);
3540 CheckInfNaNFunction(TheCall, FDecl);
3553 CheckStrlcpycatArguments(TheCall, FnInfo);
3556 CheckStrncatArguments(TheCall, FnInfo);
3559 CheckFreeArguments(TheCall);
3562 CheckMemaccessArguments(TheCall, CMId, FnInfo);
3568 bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
3592 llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
3593 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
3594 TheCall->getCallee()->getSourceRange(), CallType);
3599 bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
3601 TheCall->getCallee());
3603 llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
3604 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
3605 TheCall->getCallee()->getSourceRange(), CallType);
3649 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
3650 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
3651 MultiExprArg Args{TheCall->getArgs(), TheCall->getNumArgs()};
3652 return BuildAtomicExpr({TheCall->getBeginLoc(), TheCall->getEndLoc()},
3653 DRE->getSourceRange(), TheCall->getRParenLoc(), Args,
4286 CallExpr *TheCall = static_cast<CallExpr *>(TheCallResult.get());
4287 Expr *Callee = TheCall->getCallee();
4292 if (TheCall->getNumArgs() < 1) {
4293 Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
4294 << 0 << 1 << TheCall->getNumArgs() << /*is non object*/ 0
4304 Expr *FirstArg = TheCall->getArg(0);
4309 TheCall->setArg(0, FirstArg);
4569 if (TheCall->getNumArgs() < 1+NumFixed) {
4570 Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
4571 << 0 << 1 + NumFixed << TheCall->getNumArgs() << /*is non object*/ 0
4576 Diag(TheCall->getEndLoc(), diag::warn_atomic_implicit_seq_cst)
4580 Diag(TheCall->getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
4606 ExprResult Arg = TheCall->getArg(i+1);
4623 TheCall->setArg(i+1, Arg.get());
4637 TheCall->setCallee(PromotedCall.get());
4642 TheCall->setType(ResultType);
4657 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
4659 cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
4669 if (checkArgCount(TheCall, numArgs))
4676 Expr *PointerArg = TheCall->getArg(numArgs - 1);
4683 TheCall->setArg(numArgs - 1, PointerArg);
4706 TheCall->setType(ValType);
4710 ExprResult ValArg = TheCall->getArg(0);
4717 TheCall->setArg(0, ValArg.get());
4718 TheCall->setType(Context.VoidTy);
4822 bool Sema::BuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) {
4823 Expr *Fn = TheCall->getCallee();
4831 if (checkArgCount(TheCall, 2))
4835 if (checkBuiltinArgument(*this, TheCall, 0))
4848 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
4850 TheCall->getArg(1)->getIntegerConstantExpr(Context);
4872 Diag(TheCall->getArg(1)->getBeginLoc(),
4959 bool Sema::BuiltinUnorderedCompare(CallExpr *TheCall, unsigned BuiltinID) {
4960 if (checkArgCount(TheCall, 2))
4964 TheCall->getFPFeaturesInEffect(getLangOpts()).getNoHonorNaNs())
4965 Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
4966 << 1 << 0 << TheCall->getSourceRange();
4968 ExprResult OrigArg0 = TheCall->getArg(0);
4969 ExprResult OrigArg1 = TheCall->getArg(1);
4974 OrigArg0, OrigArg1, TheCall->getExprLoc(), ACK_Comparison);
4981 TheCall->setArg(0, OrigArg0.get());
4982 TheCall->setArg(1, OrigArg1.get());
4999 bool Sema::BuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs,
5001 if (checkArgCount(TheCall, NumArgs))
5004 FPOptions FPO = TheCall->getFPFeaturesInEffect(getLangOpts());
5008 Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
5009 << 0 << 0 << TheCall->getSourceRange();
5013 Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
5014 << 1 << 0 << TheCall->getSourceRange();
5024 Expr *Arg = TheCall->getArg(i);
5034 TheCall->setArg(i, Res.get());
5037 Expr *OrigArg = TheCall->getArg(FPArgNo);
5058 TheCall->setArg(FPArgNo, OrigArg);
5078 if (BuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
5088 TheCall->setType(ResultTy);
5094 bool Sema::BuiltinComplex(CallExpr *TheCall) {
5095 if (checkArgCount(TheCall, 2))
5100 Expr *Arg = TheCall->getArg(I);
5117 TheCall->setArg(I, Converted.get());
5121 TheCall->setType(Context.DependentTy);
5125 Expr *Real = TheCall->getArg(0);
5126 Expr *Imag = TheCall->getArg(1);
5138 return Diag(TheCall->getBeginLoc(), diag::err_invalid_complex_spec)
5141 return Diag(TheCall->getBeginLoc(), diag::err_invalid_complex_spec)
5144 TheCall->setType(Context.getComplexType(Real->getType()));
5150 ExprResult Sema::BuiltinShuffleVector(CallExpr *TheCall) {
5151 if (TheCall->getNumArgs() < 2)
5152 return ExprError(Diag(TheCall->getEndLoc(),
5154 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
5155 << /*is non object*/ 0 << TheCall->getSourceRange());
5160 QualType resType = TheCall->getArg(0)->getType();
5163 if (!TheCall->getArg(0)->isTypeDependent() &&
5164 !TheCall->getArg(1)->isTypeDependent()) {
5165 QualType LHSType = TheCall->getArg(0)->getType();
5166 QualType RHSType = TheCall->getArg(1)->getType();
5170 Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_non_vector)
5171 << TheCall->getDirectCallee() << /*isMorethantwoArgs*/ false
5172 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5173 TheCall->getArg(1)->getEndLoc()));
5176 unsigned numResElements = TheCall->getNumArgs() - 2;
5181 if (TheCall->getNumArgs() == 2) {
5184 return ExprError(Diag(TheCall->getBeginLoc(),
5186 << TheCall->getDirectCallee()
5188 << SourceRange(TheCall->getArg(1)->getBeginLoc(),
5189 TheCall->getArg(1)->getEndLoc()));
5191 return ExprError(Diag(TheCall->getBeginLoc(),
5193 << TheCall->getDirectCallee()
5195 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5196 TheCall->getArg(1)->getEndLoc()));
5204 for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
5205 if (TheCall->getArg(i)->isTypeDependent() ||
5206 TheCall->getArg(i)->isValueDependent())
5210 if (!(Result = TheCall->getArg(i)->getIntegerConstantExpr(Context)))
5211 return ExprError(Diag(TheCall->getBeginLoc(),
5213 << TheCall->getArg(i)->getSourceRange());
5221 return ExprError(Diag(TheCall->getBeginLoc(),
5223 << TheCall->getArg(i)->getSourceRange());
5228 for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
5229 exprs.push_back(TheCall->getArg(i));
5230 TheCall->setArg(i, nullptr);
5234 TheCall->getCallee()->getBeginLoc(),
5235 TheCall->getRParenLoc());
5268 bool Sema::BuiltinPrefetch(CallExpr *TheCall) {
5269 unsigned NumArgs = TheCall->getNumArgs();
5272 return Diag(TheCall->getEndLoc(),
5275 << TheCall->getSourceRange();
5280 if (BuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
5286 bool Sema::BuiltinArithmeticFence(CallExpr *TheCall) {
5288 return Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
5289 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
5290 if (checkArgCount(TheCall, 1))
5292 Expr *Arg = TheCall->getArg(0);
5298 return Diag(TheCall->getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
5302 TheCall->setArg(0, FirstArg.get());
5304 TheCall->setType(TheCall->getArg(0)->getType());
5308 bool Sema::BuiltinAssume(CallExpr *TheCall) {
5309 Expr *Arg = TheCall->getArg(0);
5315 << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
5320 bool Sema::BuiltinAllocaWithAlign(CallExpr *TheCall) {
5322 Expr *Arg = TheCall->getArg(1);
5330 Diag(TheCall->getBeginLoc(), diag::warn_alloca_align_alignof)
5336 return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two)
5340 return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_small)
5344 return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_big)
5351 bool Sema::BuiltinAssumeAligned(CallExpr *TheCall) {
5352 if (checkArgCountRange(TheCall, 2, 3))
5355 unsigned NumArgs = TheCall->getNumArgs();
5356 Expr *FirstArg = TheCall->getArg(0);
5362 Diag(TheCall->getBeginLoc(), diag::err_builtin_assume_aligned_invalid_arg)
5363 << TheCall->getSourceRange();
5366 TheCall->setArg(0, FirstArgResult.get());
5370 Expr *SecondArg = TheCall->getArg(1);
5375 if (BuiltinConstantArg(TheCall, 1, Result))
5379 return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two)
5383 Diag(TheCall->getBeginLoc(), diag::warn_assume_aligned_too_great)
5388 Expr *ThirdArg = TheCall->getArg(2);
5391 TheCall->setArg(2, ThirdArg);
5397 bool Sema::BuiltinOSLogFormat(CallExpr *TheCall) {
5399 cast<FunctionDecl>(TheCall->getCalleeDecl())->getBuiltinID();
5402 unsigned NumArgs = TheCall->getNumArgs();
5405 return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args)
5407 << /*is non object*/ 0 << TheCall->getSourceRange();
5410 return Diag(TheCall->getEndLoc(),
5413 << /*is non object*/ 0 << TheCall->getSourceRange();
5419 ExprResult Arg(TheCall->getArg(i));
5425 TheCall->setArg(i, Arg.get());
5432 ExprResult Arg = CheckOSLogFormatStringArg(TheCall->getArg(i));
5435 TheCall->setArg(i, Arg.get());
5443 TheCall->getArg(i), VariadicFunction, nullptr);
5450 << TheCall->getSourceRange();
5452 TheCall->setArg(i, Arg.get());
5460 ArrayRef<const Expr *> Args(TheCall->getArgs(), TheCall->getNumArgs());
5463 VariadicFunction, TheCall->getBeginLoc(), SourceRange(),
5470 TheCall->setType(Context.getSizeType());
5472 TheCall->setType(Context.VoidPtrTy);
5477 bool Sema::BuiltinConstantArg(CallExpr *TheCall, int ArgNum,
5479 Expr *Arg = TheCall->getArg(ArgNum);
5480 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
5487 return Diag(TheCall->getBeginLoc(), diag::err_constant_integer_arg_type)
5493 bool Sema::BuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
5500 Expr *Arg = TheCall->getArg(ArgNum);
5505 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5510 return Diag(TheCall->getBeginLoc(), diag::err_argument_invalid_range)
5515 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
5524 bool Sema::BuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
5529 Expr *Arg = TheCall->getArg(ArgNum);
5534 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5538 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_multiple)
5544 bool Sema::BuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum) {
5548 Expr *Arg = TheCall->getArg(ArgNum);
5553 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5561 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_power_of_2)
5587 bool Sema::BuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,
5592 Expr *Arg = TheCall->getArg(ArgNum);
5597 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5607 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_shifted_byte)
5611 bool Sema::BuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum,
5616 Expr *Arg = TheCall->getArg(ArgNum);
5621 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5633 return Diag(TheCall->getBeginLoc(),
5638 bool Sema::BuiltinLongjmp(CallExpr *TheCall) {
5640 return Diag(TheCall->getBeginLoc(), diag::err_builtin_longjmp_unsupported)
5641 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
5643 Expr *Arg = TheCall->getArg(1);
5647 if (BuiltinConstantArg(TheCall, 1, Result))
5651 return Diag(TheCall->getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
5657 bool Sema::BuiltinSetjmp(CallExpr *TheCall) {
5659 return Diag(TheCall->getBeginLoc(), diag::err_builtin_setjmp_unsupported)
5660 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
5664 bool Sema::BuiltinCountedByRef(CallExpr *TheCall) {
5665 if (checkArgCount(TheCall, 1))
5668 ExprResult ArgRes = UsualUnaryConversions(TheCall->getArg(0));
5699 TheCall->setType(Context.getPointerType(CountFD->getType()));
5709 TheCall->setType(Context.getPointerType(Context.VoidTy));
10966 static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
10968 unsigned NumArgs = TheCall->getNumArgs();
10970 Expr *CurrA = TheCall->getArg(i);
10975 IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
10977 IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));
14664 bool Sema::PrepareBuiltinElementwiseMathOneArgCall(CallExpr *TheCall) {
14665 if (checkArgCount(TheCall, 1))
14668 ExprResult A = BuiltinVectorMathConversions(*this, TheCall->getArg(0));
14672 TheCall->setArg(0, A.get());
14678 TheCall->setType(TyA);
14682 bool Sema::BuiltinElementwiseMath(CallExpr *TheCall, bool FPOnly) {
14683 if (auto Res = BuiltinVectorMath(TheCall, FPOnly); Res.has_value()) {
14684 TheCall->setType(*Res);
14690 bool Sema::BuiltinVectorToScalarMath(CallExpr *TheCall) {
14691 std::optional<QualType> Res = BuiltinVectorMath(TheCall);
14696 TheCall->setType(VecTy0->getElementType());
14698 TheCall->setType(*Res);
14716 std::optional<QualType> Sema::BuiltinVectorMath(CallExpr *TheCall,
14718 if (checkArgCount(TheCall, 2))
14722 *this, TheCall->getArg(0), TheCall->getArg(1), TheCall->getExprLoc()))
14728 BuiltinVectorMathConversions(*this, TheCall->getArg(I));
14751 TheCall->setArg(0, Args[0]);
14752 TheCall->setArg(1, Args[1]);
14756 bool Sema::BuiltinElementwiseTernaryMath(CallExpr *TheCall,
14758 if (checkArgCount(TheCall, 3))
14761 SourceLocation Loc = TheCall->getExprLoc();
14762 if (checkBuiltinVectorMathMixedEnums(*this, TheCall->getArg(0),
14763 TheCall->getArg(1), Loc) ||
14764 checkBuiltinVectorMathMixedEnums(*this, TheCall->getArg(1),
14765 TheCall->getArg(2), Loc))
14771 BuiltinVectorMathConversions(*this, TheCall->getArg(I));
14801 TheCall->setArg(I, Args[I]);
14804 TheCall->setType(Args[0]->getType());
14808 bool Sema::PrepareBuiltinReduceMathOneArgCall(CallExpr *TheCall) {
14809 if (checkArgCount(TheCall, 1))
14812 ExprResult A = UsualUnaryConversions(TheCall->getArg(0));
14816 TheCall->setArg(0, A.get());
14820 bool Sema::BuiltinNonDeterministicValue(CallExpr *TheCall) {
14821 if (checkArgCount(TheCall, 1))
14824 ExprResult Arg = TheCall->getArg(0);
14828 return Diag(TheCall->getArg(0)->getBeginLoc(), diag::err_builtin_invalid_arg_type)
14831 TheCall->setType(TyArg);
14835 ExprResult Sema::BuiltinMatrixTranspose(CallExpr *TheCall,
14837 if (checkArgCount(TheCall, 1))
14840 ExprResult MatrixArg = DefaultLvalueConversion(TheCall->getArg(0));
14858 TheCall->setType(ResultType);
14861 TheCall->setArg(0, Matrix);
14885 ExprResult Sema::BuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
14888 Diag(TheCall->getBeginLoc(), diag::err_builtin_matrix_disabled);
14892 if (checkArgCount(TheCall, 4))
14896 Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
14897 Expr *RowsExpr = TheCall->getArg(1);
14898 Expr *ColumnsExpr = TheCall->getArg(2);
14899 Expr *StrideExpr = TheCall->getArg(3);
14909 TheCall->setArg(0, PtrExpr);
14911 TheCall->setType(Context.DependentTy);
14912 return TheCall;
14946 TheCall->setArg(1, RowsExpr);
14953 TheCall->setArg(2, ColumnsExpr);
14961 TheCall->setType(Context.DependentTy);
14979 TheCall->setArg(3, StrideExpr);
14996 TheCall->setType(
15001 ExprResult Sema::BuiltinMatrixColumnMajorStore(CallExpr *TheCall,
15003 if (checkArgCount(TheCall, 3))
15007 Expr *MatrixExpr = TheCall->getArg(0);
15008 Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
15009 Expr *StrideExpr = TheCall->getArg(2);
15018 TheCall->setArg(0, MatrixExpr);
15021 TheCall->setType(Context.DependentTy);
15022 return TheCall;
15037 TheCall->setArg(1, PtrExpr);
15039 TheCall->setType(Context.DependentTy);
15040 return TheCall;
15077 TheCall->setArg(2, StrideExpr);