Lines Matching defs:TheCall
220 static bool BuiltinAnnotation(Sema &S, CallExpr *TheCall) {
221 if (S.checkArgCount(TheCall, 2))
225 Expr *ValArg = TheCall->getArg(0);
234 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
242 TheCall->setType(Ty);
246 static bool BuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) {
248 if (TheCall->getNumArgs() < 1) {
249 S.Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
250 << 0 << 1 << TheCall->getNumArgs() << /*is non object*/ 0
251 << TheCall->getCallee()->getSourceRange();
256 for (Expr *Arg : TheCall->arguments()) {
270 static bool BuiltinAddressof(Sema &S, CallExpr *TheCall) {
271 if (S.checkArgCount(TheCall, 1))
274 ExprResult Arg(TheCall->getArg(0));
275 QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getBeginLoc());
279 TheCall->setArg(0, Arg.get());
280 TheCall->setType(ResultType);
285 static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall) {
286 if (S.checkArgCount(TheCall, 1))
289 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
293 TheCall->setArg(0, Arg.get());
298 S.Diag(TheCall->getBeginLoc(), diag::err_function_start_invalid_type)
299 << TheCall->getSourceRange();
304 TheCall->getBeginLoc());
309 static bool BuiltinPreserveAI(Sema &S, CallExpr *TheCall) {
310 if (S.checkArgCount(TheCall, 1))
313 TheCall->setType(TheCall->getArg(0)->getType());
320 static bool BuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {
321 if (S.checkArgCount(TheCall, 2))
324 clang::Expr *Source = TheCall->getArg(0);
344 clang::Expr *AlignOp = TheCall->getArg(1);
383 TheCall->setArg(0, SrcArg.get());
390 TheCall->setArg(1, AlignArg.get());
394 TheCall->setType(IsBooleanAlignBuiltin ? S.Context.BoolTy : SrcTy);
398 static bool BuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID) {
399 if (S.checkArgCount(TheCall, 3))
410 return BuiltinID == P.first && TheCall->getExprLoc().isMacroID() &&
411 Lexer::getImmediateMacroName(TheCall->getExprLoc(),
430 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(I));
432 TheCall->setArg(I, Arg.get());
447 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(2));
449 TheCall->setArg(2, Arg.get());
468 const auto Arg = TheCall->getArg(I);
485 CallExpr *TheCall;
486 SourceLocation Loc = TheCall->getBeginLoc();
491 BuiltinDumpStructGenerator(Sema &S, CallExpr *TheCall)
492 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
514 assert(TheCall->getNumArgs() >= 2);
515 Args.reserve((TheCall->getNumArgs() - 2) + /*Format*/ 1 + Exprs.size());
516 Args.assign(TheCall->arg_begin() + 2, TheCall->arg_end());
529 S.BuildCallExpr(/*Scope=*/nullptr, TheCall->getArg(1),
530 TheCall->getBeginLoc(), Args, TheCall->getRParenLoc());
717 auto *Wrapper = PseudoObjectExpr::Create(S.Context, TheCall, Actions,
719 TheCall->setType(Wrapper->getType());
720 TheCall->setValueKind(Wrapper->getValueKind());
726 static ExprResult BuiltinDumpStruct(Sema &S, CallExpr *TheCall) {
727 if (S.checkArgCountAtLeast(TheCall, 2))
730 ExprResult PtrArgResult = S.DefaultLvalueConversion(TheCall->getArg(0));
733 TheCall->setArg(0, PtrArgResult.get());
741 << 1 << TheCall->getDirectCallee() << PtrArgType;
753 QualType FnArgType = TheCall->getArg(1)->getType();
769 S.Diag(TheCall->getArg(1)->getBeginLoc(),
771 << 2 << TheCall->getDirectCallee() << FnArgType;
776 BuiltinDumpStructGenerator Generator(S, TheCall);
1139 CallExpr *TheCall) {
1140 if (TheCall->isValueDependent() || TheCall->isTypeDependent() ||
1173 if (NewIndex >= TheCall->getNumArgs())
1185 Expr *SizeArg = TheCall->getArg(NewIndex);
1211 if (NewIndex >= TheCall->getNumArgs())
1214 const Expr *ObjArg = TheCall->getArg(NewIndex);
1230 const Expr *ObjArg = TheCall->getArg(NewIndex);
1287 TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
1299 DiagRuntimeBehavior(TheCall->getArg(Index)->getBeginLoc(), TheCall,
1322 auto *FormatExpr = TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
1359 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 2);
1361 ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1387 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1401 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1411 const auto *FormatExpr = TheCall->getArg(2)->IgnoreParenImpCasts();
1432 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
1453 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
1458 static bool BuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
1471 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1472 SemaRef.Diag(TheCall->getExprLoc(), DiagID)
1775 static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall) {
1776 if (S.checkArgCount(TheCall, 1))
1785 QualType ArgTy = TheCall->getArg(0)->getType();
1794 TheCall->setType(ParamTy);
1806 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_launder_invalid_arg)
1807 << *DiagSelect << TheCall->getSourceRange();
1817 if (S.RequireCompleteType(TheCall->getBeginLoc(), ParamTy->getPointeeType(),
1827 S.PerformCopyInitialization(Entity, SourceLocation(), TheCall->getArg(0));
1830 TheCall->setArg(0, Arg.get());
1832 return TheCall;
1838 Sema &S, unsigned BuiltinID, CallExpr *TheCall,
1843 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
1844 << TheCall->getSourceRange();
1853 CheckBuiltinTargetInSupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall,
1859 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
1860 << TheCall->getSourceRange();
1868 CallExpr *TheCall) {
1878 return ARM().CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
1882 return ARM().CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
1885 return BPF().CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
1887 return Hexagon().CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
1892 return MIPS().CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
1894 return SystemZ().CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
1897 return X86().CheckBuiltinFunctionCall(TI, BuiltinID, TheCall);
1902 return PPC().CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
1904 return AMDGPU().CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
1907 return RISCV().CheckBuiltinFunctionCall(TI, BuiltinID, TheCall);
1911 TheCall);
1914 return Wasm().CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
1917 return NVPTX().CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
1952 static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall,
1969 return S.Diag(TheCall->getBeginLoc(),
1973 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
1975 Expr *Arg = TheCall->getArg(0)->IgnoreParenImpCasts();
1978 return S.Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
1984 S.Diag(TheCall->getBeginLoc(), diag::warn_invalid_cpu_supports)
1989 return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_is)
1996 static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall) {
1997 if (S.checkArgCount(TheCall, 1))
2000 ExprResult ArgRes = S.DefaultLvalueConversion(TheCall->getArg(0));
2005 TheCall->setArg(0, Arg);
2020 static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) {
2021 if (S.checkArgCountRange(TheCall, 1, 2))
2024 ExprResult Arg0Res = S.DefaultLvalueConversion(TheCall->getArg(0));
2029 TheCall->setArg(0, Arg0);
2039 if (TheCall->getNumArgs() > 1) {
2040 ExprResult Arg1Res = S.UsualUnaryConversions(TheCall->getArg(1));
2045 TheCall->setArg(1, Arg1);
2061 CallExpr *TheCall) {
2062 ExprResult TheCallResult(TheCall);
2079 if (ArgNo < TheCall->getNumArgs() &&
2080 BuiltinConstantArg(TheCall, ArgNo, Result))
2089 if (BuiltinCpu(*this, Context.getTargetInfo(), TheCall,
2095 Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
2096 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
2104 *this, BuiltinID, TheCall,
2107 assert(TheCall->getNumArgs() == 1 &&
2109 if (ObjC().CheckObjCString(TheCall->getArg(0)))
2115 if (BuiltinVAStart(BuiltinID, TheCall))
2123 if (BuiltinVAStartARMMicrosoft(TheCall))
2127 if (BuiltinVAStart(BuiltinID, TheCall))
2142 *this, BuiltinID, TheCall,
2155 *this, BuiltinID, TheCall,
2163 *this, BuiltinID, TheCall,
2175 if (BuiltinUnorderedCompare(TheCall, BuiltinID))
2179 if (BuiltinFPClassification(TheCall, 6, BuiltinID))
2183 if (BuiltinFPClassification(TheCall, 2, BuiltinID))
2197 if (BuiltinFPClassification(TheCall, 1, BuiltinID))
2201 return BuiltinShuffleVector(TheCall);
2202 // TheCall will be freed by the smart pointer here, but that's fine, since
2205 if (BuiltinPrefetch(TheCall))
2210 if (BuiltinAllocaWithAlign(TheCall))
2215 Diag(TheCall->getBeginLoc(), diag::warn_alloca)
2216 << TheCall->getDirectCallee();
2219 if (BuiltinArithmeticFence(TheCall))
2224 if (BuiltinAssume(TheCall))
2228 if (BuiltinAssumeAligned(TheCall))
2233 if (BuiltinConstantArgRange(TheCall, 1, 0, 3))
2237 if (BuiltinLongjmp(TheCall))
2241 if (BuiltinSetjmp(TheCall))
2245 if (checkArgCount(TheCall, 1))
2247 TheCall->setType(Context.IntTy);
2250 if (BuiltinComplex(TheCall))
2254 if (checkArgCount(TheCall, 1))
2256 ExprResult Arg = DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
2258 TheCall->setArg(0, Arg.get());
2259 TheCall->setType(Context.IntTy);
2263 return BuiltinLaunder(*this, TheCall);
2368 Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst)
2369 << TheCall->getCallee()->getSourceRange();
2375 clang::Expr *SizeOp = TheCall->getArg(2);
2382 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
2383 CheckNonNullArgument(*this, TheCall->getArg(1), TheCall->getExprLoc());
2388 clang::Expr *SizeOp = TheCall->getArg(2);
2395 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
2404 if (BuiltinMSVCAnnotation(*this, TheCall))
2408 if (BuiltinAnnotation(*this, TheCall))
2412 if (BuiltinAddressof(*this, TheCall))
2416 if (BuiltinFunctionStart(*this, TheCall))
2422 if (BuiltinAlignment(*this, TheCall, BuiltinID))
2428 if (BuiltinOverflow(*this, TheCall, BuiltinID))
2441 return BuiltinDumpStruct(*this, TheCall);
2444 if (checkArgCount(TheCall, 3))
2447 const Expr *ProbArg = TheCall->getArg(2);
2472 if (BuiltinPreserveAI(*this, TheCall))
2476 if (BuiltinCallWithStaticChain(*this, TheCall))
2481 if (BuiltinSEHScopeCheck(*this, TheCall, Scope::SEHExceptScope,
2487 if (BuiltinSEHScopeCheck(*this, TheCall, Scope::SEHFilterScope,
2492 if (checkArgCount(TheCall, 1))
2496 TheCall->getBeginLoc(),
2498 TheCall))
2501 TheCall->setType(Context.VoidPtrTy);
2513 if (checkArgCount(TheCall, 1))
2524 Diag(TheCall->getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2531 return PointerAuthStrip(*this, TheCall);
2533 return PointerAuthBlendDiscriminator(*this, TheCall);
2535 return PointerAuthSignOrAuth(*this, TheCall, PAO_Sign,
2538 return PointerAuthSignOrAuth(*this, TheCall, PAO_Sign,
2541 return PointerAuthSignOrAuth(*this, TheCall, PAO_Auth,
2544 return PointerAuthSignGenericData(*this, TheCall);
2546 return PointerAuthAuthAndResign(*this, TheCall);
2548 return PointerAuthStringDiscriminator(*this, TheCall);
2554 if (OpenCL().checkBuiltinRWPipe(TheCall))
2561 if (OpenCL().checkBuiltinReserveRWPipe(TheCall))
2566 if (OpenCL().checkSubgroupExt(TheCall) ||
2567 OpenCL().checkBuiltinReserveRWPipe(TheCall))
2574 if (OpenCL().checkBuiltinCommitRWPipe(TheCall))
2579 if (OpenCL().checkSubgroupExt(TheCall) ||
2580 OpenCL().checkBuiltinCommitRWPipe(TheCall))
2585 if (OpenCL().checkBuiltinPipePackets(TheCall))
2591 if (OpenCL().checkBuiltinToAddr(BuiltinID, TheCall))
2596 if (OpenCL().checkBuiltinEnqueueKernel(TheCall))
2601 if (OpenCL().checkBuiltinKernelWorkGroupSize(TheCall))
2606 if (OpenCL().checkBuiltinNDRangeAndBlock(TheCall))
2613 if (BuiltinOSLogFormat(TheCall))
2618 if (BuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
2624 if (!TheCall->getArg(0)->isValueDependent() &&
2625 TheCall->getArg(0)->EvaluateAsInt(Result, getASTContext()) &&
2627 Diag(TheCall->getBeginLoc(), diag::warn_frame_address)
2631 << TheCall->getSourceRange();
2636 if (BuiltinNonDeterministicValue(TheCall))
2644 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2647 QualType ArgTy = TheCall->getArg(0)->getType();
2653 Diag(TheCall->getArg(0)->getBeginLoc(),
2686 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2689 QualType ArgTy = TheCall->getArg(0)->getType();
2690 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2696 if (BuiltinElementwiseTernaryMath(TheCall))
2704 if (BuiltinElementwiseMath(TheCall))
2707 QualType ArgTy = TheCall->getArg(0)->getType();
2708 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2710 checkFPMathBuiltinElementType(*this, TheCall->getArg(1)->getBeginLoc(),
2720 if (BuiltinElementwiseMath(TheCall))
2723 const Expr *Arg = TheCall->getArg(0);
2740 if (BuiltinElementwiseMath(TheCall))
2745 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2748 const Expr *Arg = TheCall->getArg(0);
2764 if (checkArgCount(TheCall, 2))
2767 ExprResult Magnitude = UsualUnaryConversions(TheCall->getArg(0));
2768 ExprResult Sign = UsualUnaryConversions(TheCall->getArg(1));
2774 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2776 checkFPMathBuiltinElementType(*this, TheCall->getArg(1)->getBeginLoc(),
2787 TheCall->setArg(0, Magnitude.get());
2788 TheCall->setArg(1, Sign.get());
2789 TheCall->setType(Magnitude.get()->getType());
2794 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2797 const Expr *Arg = TheCall->getArg(0);
2812 TheCall->setType(ElTy);
2823 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2826 const Expr *Arg = TheCall->getArg(0);
2841 TheCall->setType(ElTy);
2846 return BuiltinMatrixTranspose(TheCall, TheCallResult);
2849 return BuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
2852 return BuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
2855 if (!checkBuiltinVerboseTrap(TheCall, *this))
2860 auto Check = [](CallExpr *TheCall) {
2861 if (TheCall->getNumArgs() != 1)
2863 auto *DRE = dyn_cast<DeclRefExpr>(TheCall->getArg(0)->IgnoreImpCasts());
2872 if (!Check(TheCall)) {
2873 Diag(TheCall->getBeginLoc(),
2880 if (BuiltinPopcountg(*this, TheCall))
2885 if (BuiltinCountZeroBitsGeneric(*this, TheCall))
2890 Expr *Arg = TheCall->getArg(0);
2893 Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
2901 if (getLangOpts().HLSL && HLSL().CheckBuiltinFunctionCall(BuiltinID, TheCall))
2913 Context.BuiltinInfo.getAuxBuiltinID(BuiltinID), TheCall))
2917 TheCall))
2925 bool Sema::ValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum) {
2928 Expr *Arg = TheCall->getArg(ArgNum);
2933 if (BuiltinConstantArg(TheCall, ArgNum, Result))
2940 return Diag(TheCall->getBeginLoc(),
3358 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
3360 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
3362 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
3365 TheCall->getCallee());
3366 Expr** Args = TheCall->getArgs();
3367 unsigned NumArgs = TheCall->getNumArgs();
3380 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
3394 CheckArgAlignment(TheCall->getRParenLoc(), FDecl, "'this'", ThisType,
3399 IsMemberFunction, TheCall->getRParenLoc(),
3400 TheCall->getCallee()->getSourceRange(), CallType);
3410 CheckTCBEnforcement(TheCall->getExprLoc(), FDecl);
3412 CheckAbsoluteValueFunction(TheCall, FDecl);
3413 CheckMaxUnsignedZero(TheCall, FDecl);
3414 CheckInfNaNFunction(TheCall, FDecl);
3427 CheckStrlcpycatArguments(TheCall, FnInfo);
3430 CheckStrncatArguments(TheCall, FnInfo);
3433 CheckFreeArguments(TheCall);
3436 CheckMemaccessArguments(TheCall, CMId, FnInfo);
3442 bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
3466 llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
3467 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
3468 TheCall->getCallee()->getSourceRange(), CallType);
3473 bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
3475 TheCall->getCallee());
3477 llvm::ArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
3478 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
3479 TheCall->getCallee()->getSourceRange(), CallType);
3522 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
3523 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
3524 MultiExprArg Args{TheCall->getArgs(), TheCall->getNumArgs()};
3525 return BuildAtomicExpr({TheCall->getBeginLoc(), TheCall->getEndLoc()},
3526 DRE->getSourceRange(), TheCall->getRParenLoc(), Args,
4125 CallExpr *TheCall = static_cast<CallExpr *>(TheCallResult.get());
4126 Expr *Callee = TheCall->getCallee();
4131 if (TheCall->getNumArgs() < 1) {
4132 Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
4133 << 0 << 1 << TheCall->getNumArgs() << /*is non object*/ 0
4143 Expr *FirstArg = TheCall->getArg(0);
4148 TheCall->setArg(0, FirstArg);
4408 if (TheCall->getNumArgs() < 1+NumFixed) {
4409 Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
4410 << 0 << 1 + NumFixed << TheCall->getNumArgs() << /*is non object*/ 0
4415 Diag(TheCall->getEndLoc(), diag::warn_atomic_implicit_seq_cst)
4419 Diag(TheCall->getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
4445 ExprResult Arg = TheCall->getArg(i+1);
4462 TheCall->setArg(i+1, Arg.get());
4476 TheCall->setCallee(PromotedCall.get());
4481 TheCall->setType(ResultType);
4496 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
4498 cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
4508 if (checkArgCount(TheCall, numArgs))
4515 Expr *PointerArg = TheCall->getArg(numArgs - 1);
4522 TheCall->setArg(numArgs - 1, PointerArg);
4545 TheCall->setType(ValType);
4549 ExprResult ValArg = TheCall->getArg(0);
4556 TheCall->setArg(0, ValArg.get());
4557 TheCall->setType(Context.VoidTy);
4661 bool Sema::BuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) {
4662 Expr *Fn = TheCall->getCallee();
4670 if (checkArgCount(TheCall, 2))
4674 if (checkBuiltinArgument(*this, TheCall, 0))
4687 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
4689 TheCall->getArg(1)->getIntegerConstantExpr(Context);
4711 Diag(TheCall->getArg(1)->getBeginLoc(),
4798 bool Sema::BuiltinUnorderedCompare(CallExpr *TheCall, unsigned BuiltinID) {
4799 if (checkArgCount(TheCall, 2))
4803 TheCall->getFPFeaturesInEffect(getLangOpts()).getNoHonorNaNs())
4804 Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
4805 << 1 << 0 << TheCall->getSourceRange();
4807 ExprResult OrigArg0 = TheCall->getArg(0);
4808 ExprResult OrigArg1 = TheCall->getArg(1);
4813 OrigArg0, OrigArg1, TheCall->getExprLoc(), ACK_Comparison);
4820 TheCall->setArg(0, OrigArg0.get());
4821 TheCall->setArg(1, OrigArg1.get());
4838 bool Sema::BuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs,
4840 if (checkArgCount(TheCall, NumArgs))
4843 FPOptions FPO = TheCall->getFPFeaturesInEffect(getLangOpts());
4847 Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
4848 << 0 << 0 << TheCall->getSourceRange();
4852 Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
4853 << 1 << 0 << TheCall->getSourceRange();
4863 Expr *Arg = TheCall->getArg(i);
4872 TheCall->setArg(i, Res.get());
4875 Expr *OrigArg = TheCall->getArg(FPArgNo);
4887 TheCall->setArg(FPArgNo, OrigArg);
4907 if (BuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
4917 TheCall->setType(ResultTy);
4923 bool Sema::BuiltinComplex(CallExpr *TheCall) {
4924 if (checkArgCount(TheCall, 2))
4929 Expr *Arg = TheCall->getArg(I);
4946 TheCall->setArg(I, Converted.get());
4950 TheCall->setType(Context.DependentTy);
4954 Expr *Real = TheCall->getArg(0);
4955 Expr *Imag = TheCall->getArg(1);
4967 return Diag(TheCall->getBeginLoc(), diag::err_invalid_complex_spec)
4970 return Diag(TheCall->getBeginLoc(), diag::err_invalid_complex_spec)
4973 TheCall->setType(Context.getComplexType(Real->getType()));
4979 ExprResult Sema::BuiltinShuffleVector(CallExpr *TheCall) {
4980 if (TheCall->getNumArgs() < 2)
4981 return ExprError(Diag(TheCall->getEndLoc(),
4983 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
4984 << /*is non object*/ 0 << TheCall->getSourceRange());
4989 QualType resType = TheCall->getArg(0)->getType();
4992 if (!TheCall->getArg(0)->isTypeDependent() &&
4993 !TheCall->getArg(1)->isTypeDependent()) {
4994 QualType LHSType = TheCall->getArg(0)->getType();
4995 QualType RHSType = TheCall->getArg(1)->getType();
4999 Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_non_vector)
5000 << TheCall->getDirectCallee() << /*isMorethantwoArgs*/ false
5001 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5002 TheCall->getArg(1)->getEndLoc()));
5005 unsigned numResElements = TheCall->getNumArgs() - 2;
5010 if (TheCall->getNumArgs() == 2) {
5013 return ExprError(Diag(TheCall->getBeginLoc(),
5015 << TheCall->getDirectCallee()
5017 << SourceRange(TheCall->getArg(1)->getBeginLoc(),
5018 TheCall->getArg(1)->getEndLoc()));
5020 return ExprError(Diag(TheCall->getBeginLoc(),
5022 << TheCall->getDirectCallee()
5024 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5025 TheCall->getArg(1)->getEndLoc()));
5033 for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
5034 if (TheCall->getArg(i)->isTypeDependent() ||
5035 TheCall->getArg(i)->isValueDependent())
5039 if (!(Result = TheCall->getArg(i)->getIntegerConstantExpr(Context)))
5040 return ExprError(Diag(TheCall->getBeginLoc(),
5042 << TheCall->getArg(i)->getSourceRange());
5050 return ExprError(Diag(TheCall->getBeginLoc(),
5052 << TheCall->getArg(i)->getSourceRange());
5057 for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
5058 exprs.push_back(TheCall->getArg(i));
5059 TheCall->setArg(i, nullptr);
5063 TheCall->getCallee()->getBeginLoc(),
5064 TheCall->getRParenLoc());
5097 bool Sema::BuiltinPrefetch(CallExpr *TheCall) {
5098 unsigned NumArgs = TheCall->getNumArgs();
5101 return Diag(TheCall->getEndLoc(),
5104 << TheCall->getSourceRange();
5109 if (BuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
5115 bool Sema::BuiltinArithmeticFence(CallExpr *TheCall) {
5117 return Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
5118 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
5119 if (checkArgCount(TheCall, 1))
5121 Expr *Arg = TheCall->getArg(0);
5127 return Diag(TheCall->getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
5131 TheCall->setArg(0, FirstArg.get());
5133 TheCall->setType(TheCall->getArg(0)->getType());
5137 bool Sema::BuiltinAssume(CallExpr *TheCall) {
5138 Expr *Arg = TheCall->getArg(0);
5144 << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
5149 bool Sema::BuiltinAllocaWithAlign(CallExpr *TheCall) {
5151 Expr *Arg = TheCall->getArg(1);
5159 Diag(TheCall->getBeginLoc(), diag::warn_alloca_align_alignof)
5165 return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two)
5169 return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_small)
5173 return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_big)
5180 bool Sema::BuiltinAssumeAligned(CallExpr *TheCall) {
5181 if (checkArgCountRange(TheCall, 2, 3))
5184 unsigned NumArgs = TheCall->getNumArgs();
5185 Expr *FirstArg = TheCall->getArg(0);
5190 if (checkBuiltinArgument(*this, TheCall, 0))
5193 TheCall->setArg(0, FirstArgResult.get());
5197 Expr *SecondArg = TheCall->getArg(1);
5202 if (BuiltinConstantArg(TheCall, 1, Result))
5206 return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two)
5210 Diag(TheCall->getBeginLoc(), diag::warn_assume_aligned_too_great)
5215 Expr *ThirdArg = TheCall->getArg(2);
5218 TheCall->setArg(2, ThirdArg);
5224 bool Sema::BuiltinOSLogFormat(CallExpr *TheCall) {
5226 cast<FunctionDecl>(TheCall->getCalleeDecl())->getBuiltinID();
5229 unsigned NumArgs = TheCall->getNumArgs();
5232 return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args)
5234 << /*is non object*/ 0 << TheCall->getSourceRange();
5237 return Diag(TheCall->getEndLoc(),
5240 << /*is non object*/ 0 << TheCall->getSourceRange();
5246 ExprResult Arg(TheCall->getArg(i));
5252 TheCall->setArg(i, Arg.get());
5259 ExprResult Arg = CheckOSLogFormatStringArg(TheCall->getArg(i));
5262 TheCall->setArg(i, Arg.get());
5270 TheCall->getArg(i), VariadicFunction, nullptr);
5277 << TheCall->getSourceRange();
5279 TheCall->setArg(i, Arg.get());
5287 ArrayRef<const Expr *> Args(TheCall->getArgs(), TheCall->getNumArgs());
5290 VariadicFunction, TheCall->getBeginLoc(), SourceRange(),
5297 TheCall->setType(Context.getSizeType());
5299 TheCall->setType(Context.VoidPtrTy);
5304 bool Sema::BuiltinConstantArg(CallExpr *TheCall, int ArgNum,
5306 Expr *Arg = TheCall->getArg(ArgNum);
5307 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
5314 return Diag(TheCall->getBeginLoc(), diag::err_constant_integer_arg_type)
5320 bool Sema::BuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
5327 Expr *Arg = TheCall->getArg(ArgNum);
5332 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5337 return Diag(TheCall->getBeginLoc(), diag::err_argument_invalid_range)
5342 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
5351 bool Sema::BuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
5356 Expr *Arg = TheCall->getArg(ArgNum);
5361 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5365 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_multiple)
5371 bool Sema::BuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum) {
5375 Expr *Arg = TheCall->getArg(ArgNum);
5380 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5388 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_power_of_2)
5414 bool Sema::BuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,
5419 Expr *Arg = TheCall->getArg(ArgNum);
5424 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5434 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_shifted_byte)
5438 bool Sema::BuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum,
5443 Expr *Arg = TheCall->getArg(ArgNum);
5448 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5460 return Diag(TheCall->getBeginLoc(),
5465 bool Sema::BuiltinLongjmp(CallExpr *TheCall) {
5467 return Diag(TheCall->getBeginLoc(), diag::err_builtin_longjmp_unsupported)
5468 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
5470 Expr *Arg = TheCall->getArg(1);
5474 if (BuiltinConstantArg(TheCall, 1, Result))
5478 return Diag(TheCall->getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
5484 bool Sema::BuiltinSetjmp(CallExpr *TheCall) {
5486 return Diag(TheCall->getBeginLoc(), diag::err_builtin_setjmp_unsupported)
5487 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
10590 static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
10592 unsigned NumArgs = TheCall->getNumArgs();
10594 Expr *CurrA = TheCall->getArg(i);
10599 IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
10601 IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));
14259 bool Sema::PrepareBuiltinElementwiseMathOneArgCall(CallExpr *TheCall) {
14260 if (checkArgCount(TheCall, 1))
14263 ExprResult A = UsualUnaryConversions(TheCall->getArg(0));
14267 TheCall->setArg(0, A.get());
14273 TheCall->setType(TyA);
14277 bool Sema::BuiltinElementwiseMath(CallExpr *TheCall) {
14279 if (BuiltinVectorMath(TheCall, Res))
14281 TheCall->setType(Res);
14285 bool Sema::BuiltinVectorToScalarMath(CallExpr *TheCall) {
14287 if (BuiltinVectorMath(TheCall, Res))
14291 TheCall->setType(VecTy0->getElementType());
14293 TheCall->setType(Res);
14298 bool Sema::BuiltinVectorMath(CallExpr *TheCall, QualType &Res) {
14299 if (checkArgCount(TheCall, 2))
14302 ExprResult A = TheCall->getArg(0);
14303 ExprResult B = TheCall->getArg(1);
14306 Res = UsualArithmeticConversions(A, B, TheCall->getExprLoc(), ACK_Comparison);
14321 TheCall->setArg(0, A.get());
14322 TheCall->setArg(1, B.get());
14326 bool Sema::BuiltinElementwiseTernaryMath(CallExpr *TheCall,
14328 if (checkArgCount(TheCall, 3))
14333 ExprResult Converted = UsualUnaryConversions(TheCall->getArg(I));
14363 TheCall->setArg(I, Args[I]);
14366 TheCall->setType(Args[0]->getType());
14370 bool Sema::PrepareBuiltinReduceMathOneArgCall(CallExpr *TheCall) {
14371 if (checkArgCount(TheCall, 1))
14374 ExprResult A = UsualUnaryConversions(TheCall->getArg(0));
14378 TheCall->setArg(0, A.get());
14382 bool Sema::BuiltinNonDeterministicValue(CallExpr *TheCall) {
14383 if (checkArgCount(TheCall, 1))
14386 ExprResult Arg = TheCall->getArg(0);
14390 return Diag(TheCall->getArg(0)->getBeginLoc(), diag::err_builtin_invalid_arg_type)
14393 TheCall->setType(TyArg);
14397 ExprResult Sema::BuiltinMatrixTranspose(CallExpr *TheCall,
14399 if (checkArgCount(TheCall, 1))
14402 ExprResult MatrixArg = DefaultLvalueConversion(TheCall->getArg(0));
14420 TheCall->setType(ResultType);
14423 TheCall->setArg(0, Matrix);
14447 ExprResult Sema::BuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
14450 Diag(TheCall->getBeginLoc(), diag::err_builtin_matrix_disabled);
14454 if (checkArgCount(TheCall, 4))
14458 Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
14459 Expr *RowsExpr = TheCall->getArg(1);
14460 Expr *ColumnsExpr = TheCall->getArg(2);
14461 Expr *StrideExpr = TheCall->getArg(3);
14471 TheCall->setArg(0, PtrExpr);
14473 TheCall->setType(Context.DependentTy);
14474 return TheCall;
14508 TheCall->setArg(1, RowsExpr);
14515 TheCall->setArg(2, ColumnsExpr);
14523 TheCall->setType(Context.DependentTy);
14541 TheCall->setArg(3, StrideExpr);
14558 TheCall->setType(
14563 ExprResult Sema::BuiltinMatrixColumnMajorStore(CallExpr *TheCall,
14565 if (checkArgCount(TheCall, 3))
14569 Expr *MatrixExpr = TheCall->getArg(0);
14570 Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
14571 Expr *StrideExpr = TheCall->getArg(2);
14580 TheCall->setArg(0, MatrixExpr);
14583 TheCall->setType(Context.DependentTy);
14584 return TheCall;
14599 TheCall->setArg(1, PtrExpr);
14601 TheCall->setType(Context.DependentTy);
14602 return TheCall;
14639 TheCall->setArg(2, StrideExpr);