Lines Matching refs:TheCall
73 static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
74 if (checkArgCount(S, TheCall, 2))
78 Expr *ValArg = TheCall->getArg(0);
87 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
95 TheCall->setType(Ty);
101 static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall) {
102 if (checkArgCount(S, TheCall, 1))
105 ExprResult Arg(TheCall->getArg(0));
106 QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getLocStart());
110 TheCall->setArg(0, Arg.get());
111 TheCall->setType(ResultType);
115 static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall) {
116 if (checkArgCount(S, TheCall, 3))
121 Expr *Arg = TheCall->getArg(I);
134 Expr *Arg = TheCall->getArg(2);
149 CallExpr *TheCall, unsigned SizeIdx,
151 if (TheCall->getNumArgs() <= SizeIdx ||
152 TheCall->getNumArgs() <= DstSizeIdx)
155 const Expr *SizeArg = TheCall->getArg(SizeIdx);
156 const Expr *DstSizeArg = TheCall->getArg(DstSizeIdx);
170 SourceLocation SL = TheCall->getLocStart();
171 SourceRange SR = TheCall->getSourceRange();
239 static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
252 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
253 SemaRef.Diag(TheCall->getExprLoc(), DiagID)
263 CallExpr *TheCall) {
264 ExprResult TheCallResult(TheCall);
279 if (SemaBuiltinConstantArg(TheCall, ArgNo, Result))
286 assert(TheCall->getNumArgs() == 1 &&
288 if (CheckObjCString(TheCall->getArg(0)))
293 if (SemaBuiltinVAStart(TheCall))
300 if (SemaBuiltinVAStartARM(TheCall))
304 if (SemaBuiltinVAStart(TheCall))
316 if (SemaBuiltinUnorderedCompare(TheCall))
320 if (SemaBuiltinFPClassification(TheCall, 6))
328 if (SemaBuiltinFPClassification(TheCall, 1))
332 return SemaBuiltinShuffleVector(TheCall);
333 // TheCall will be freed by the smart pointer here, but that's fine, since
336 if (SemaBuiltinPrefetch(TheCall))
341 if (SemaBuiltinAssume(TheCall))
345 if (SemaBuiltinAssumeAligned(TheCall))
349 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
353 if (SemaBuiltinLongjmp(TheCall))
357 if (SemaBuiltinSetjmp(TheCall))
362 if (checkArgCount(*this, TheCall, 1))
367 if (checkArgCount(*this, TheCall, 1)) return true;
368 TheCall->setType(Context.IntTy);
371 if (checkArgCount(*this, TheCall, 1)) return true;
372 TheCall->setType(Context.IntTy);
486 if (SemaBuiltinAnnotation(*this, TheCall))
490 if (SemaBuiltinAddressof(*this, TheCall))
496 if (SemaBuiltinOverflow(*this, TheCall))
502 Diag(TheCall->getExprLoc(), diag::err_builtin_requires_language)
524 SemaBuiltinMemChkCall(*this, FDecl, TheCall, 2, 3);
527 SemaBuiltinMemChkCall(*this, FDecl, TheCall, 3, 4);
531 SemaBuiltinMemChkCall(*this, FDecl, TheCall, 1, 3);
535 if (SemaBuiltinCallWithStaticChain(*this, TheCall))
541 if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHExceptScope,
548 if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHFilterScope,
555 if (checkArgCount(*this, TheCall, 1))
559 TheCall->getLocStart(),
561 TheCall))
564 TheCall->setType(Context.VoidPtrTy);
577 if (CheckARMBuiltinFunctionCall(BuiltinID, TheCall))
582 if (CheckAArch64BuiltinFunctionCall(BuiltinID, TheCall))
589 if (CheckMipsBuiltinFunctionCall(BuiltinID, TheCall))
593 if (CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall))
598 if (CheckX86BuiltinFunctionCall(BuiltinID, TheCall))
604 if (CheckPPCBuiltinFunctionCall(BuiltinID, TheCall))
685 bool Sema::CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
699 unsigned ImmArg = TheCall->getNumArgs()-1;
701 if (SemaBuiltinConstantArg(TheCall, ImmArg, Result))
706 return Diag(TheCall->getLocStart(), diag::err_invalid_neon_type_code)
707 << TheCall->getArg(ImmArg)->getSourceRange();
712 Expr *Arg = TheCall->getArg(PtrArgNum);
747 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
750 bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
766 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
769 if (checkArgCount(*this, TheCall, IsLdrex ? 1 : 2))
776 Expr *PointerArg = TheCall->getArg(IsLdrex ? 0 : 1);
814 TheCall->setArg(IsLdrex ? 0 : 1, PointerArg);
848 TheCall->setType(ValType);
853 ExprResult ValArg = TheCall->getArg(0);
859 TheCall->setArg(0, ValArg.get());
863 TheCall->setType(Context.IntTy);
867 bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
874 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
878 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
879 SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
884 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3, false);
890 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
892 if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall))
911 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
915 CallExpr *TheCall) {
922 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
926 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
927 SemaBuiltinConstantArgRange(TheCall, 2, 0, 2) ||
928 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
929 SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
934 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, false);
940 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
942 if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall))
955 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
958 bool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
971 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
974 bool Sema::CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
989 return Diag(TheCall->getLocStart(), diag::err_64_bit_builtin_32_bit_tgt)
990 << TheCall->getSourceRange();
995 return Diag(TheCall->getLocStart(), diag::err_ppc_builtin_only_on_pwr7)
996 << TheCall->getSourceRange();
1002 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
1003 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
1011 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
1012 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
1014 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
1018 CallExpr *TheCall) {
1020 Expr *Arg = TheCall->getArg(0);
1051 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15) ||
1052 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
1070 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
1076 static bool SemaBuiltinCpuSupports(Sema &S, CallExpr *TheCall) {
1077 Expr *Arg = TheCall->getArg(0);
1081 return S.Diag(TheCall->getLocStart(), diag::err_expr_not_string_literal)
1088 return S.Diag(TheCall->getLocStart(), diag::err_invalid_cpu_supports)
1093 bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
1098 return SemaBuiltinCpuSupports(*this, TheCall);
1100 return SemaBuiltinMSVAStart(TheCall);
1154 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
1434 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
1436 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
1438 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
1441 TheCall->getCallee());
1442 Expr** Args = TheCall->getArgs();
1443 unsigned NumArgs = TheCall->getNumArgs();
1452 IsMemberFunction, TheCall->getRParenLoc(),
1453 TheCall->getCallee()->getSourceRange(), CallType);
1461 CheckAbsoluteValueFunction(TheCall, FDecl, FnInfo);
1471 CheckStrlcpycatArguments(TheCall, FnInfo);
1473 CheckStrncatArguments(TheCall, FnInfo);
1475 CheckMemaccessArguments(TheCall, CMId, FnInfo);
1492 bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
1516 llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
1517 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
1518 TheCall->getCallee()->getSourceRange(), CallType);
1525 bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
1527 TheCall->getCallee());
1529 llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
1530 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
1531 TheCall->getCallee()->getSourceRange(), CallType);
1565 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
1566 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1668 if (TheCall->getNumArgs() < NumArgs[Form]) {
1669 Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
1670 << 0 << NumArgs[Form] << TheCall->getNumArgs()
1671 << TheCall->getCallee()->getSourceRange();
1673 } else if (TheCall->getNumArgs() > NumArgs[Form]) {
1674 Diag(TheCall->getArg(NumArgs[Form])->getLocStart(),
1676 << 0 << NumArgs[Form] << TheCall->getNumArgs()
1677 << TheCall->getCallee()->getSourceRange();
1682 Expr *Ptr = TheCall->getArg(0);
1805 Expr *ValArg = TheCall->getArg(i);
1833 ExprResult Arg = TheCall->getArg(i);
1837 TheCall->setArg(i, Arg.get());
1846 SubExprs.push_back(TheCall->getArg(1)); // Val1
1849 SubExprs.push_back(TheCall->getArg(1)); // Order
1854 SubExprs.push_back(TheCall->getArg(2)); // Order
1855 SubExprs.push_back(TheCall->getArg(1)); // Val1
1859 SubExprs.push_back(TheCall->getArg(3)); // Order
1860 SubExprs.push_back(TheCall->getArg(1)); // Val1
1861 SubExprs.push_back(TheCall->getArg(2)); // Val2
1864 SubExprs.push_back(TheCall->getArg(3)); // Order
1865 SubExprs.push_back(TheCall->getArg(1)); // Val1
1866 SubExprs.push_back(TheCall->getArg(4)); // OrderFail
1867 SubExprs.push_back(TheCall->getArg(2)); // Val2
1870 SubExprs.push_back(TheCall->getArg(4)); // Order
1871 SubExprs.push_back(TheCall->getArg(1)); // Val1
1872 SubExprs.push_back(TheCall->getArg(5)); // OrderFail
1873 SubExprs.push_back(TheCall->getArg(2)); // Val2
1874 SubExprs.push_back(TheCall->getArg(3)); // Weak
1887 AtomicExpr *AE = new (Context) AtomicExpr(TheCall->getCallee()->getLocStart(),
1889 TheCall->getRParenLoc());
1935 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
1936 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1940 if (TheCall->getNumArgs() < 1) {
1941 Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
1942 << 0 << 1 << TheCall->getNumArgs()
1943 << TheCall->getCallee()->getSourceRange();
1952 Expr *FirstArg = TheCall->getArg(0);
1957 TheCall->setArg(0, FirstArg);
2211 if (TheCall->getNumArgs() < 1+NumFixed) {
2212 Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
2213 << 0 << 1+NumFixed << TheCall->getNumArgs()
2214 << TheCall->getCallee()->getSourceRange();
2219 Diag(TheCall->getLocEnd(), diag::warn_sync_fetch_and_nand_semantics_change)
2220 << TheCall->getCallee()->getSourceRange();
2245 ExprResult Arg = TheCall->getArg(i+1);
2262 TheCall->setArg(i+1, Arg.get());
2283 TheCall->setCallee(PromotedCall.get());
2288 TheCall->setType(ResultType);
2300 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
2302 cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
2312 if (checkArgCount(*this, TheCall, numArgs))
2319 Expr *PointerArg = TheCall->getArg(numArgs - 1);
2326 TheCall->setArg(numArgs - 1, PointerArg);
2349 TheCall->setType(ValType);
2353 ExprResult ValArg = TheCall->getArg(0);
2360 TheCall->setArg(0, ValArg.get());
2361 TheCall->setType(Context.VoidTy);
2400 bool Sema::SemaBuiltinVAStartImpl(CallExpr *TheCall) {
2401 Expr *Fn = TheCall->getCallee();
2402 if (TheCall->getNumArgs() > 2) {
2403 Diag(TheCall->getArg(2)->getLocStart(),
2405 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
2407 << SourceRange(TheCall->getArg(2)->getLocStart(),
2408 (*(TheCall->arg_end()-1))->getLocEnd());
2412 if (TheCall->getNumArgs() < 2) {
2413 return Diag(TheCall->getLocEnd(),
2415 << 0 /*function call*/ << 2 << TheCall->getNumArgs();
2419 if (checkBuiltinArgument(*this, TheCall, 0))
2440 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
2466 Diag(TheCall->getArg(1)->getLocStart(),
2474 TheCall->setType(Context.VoidTy);
2481 bool Sema::SemaBuiltinVAStart(CallExpr *TheCall) {
2493 return Diag(TheCall->getCallee()->getLocStart(),
2497 return SemaBuiltinVAStartImpl(TheCall);
2503 bool Sema::SemaBuiltinMSVAStart(CallExpr *TheCall) {
2506 Expr *Callee = TheCall->getCallee();
2517 return SemaBuiltinVAStartImpl(TheCall);
2574 bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
2575 if (TheCall->getNumArgs() < 2)
2576 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
2577 << 0 << 2 << TheCall->getNumArgs()/*function call*/;
2578 if (TheCall->getNumArgs() > 2)
2579 return Diag(TheCall->getArg(2)->getLocStart(),
2581 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
2582 << SourceRange(TheCall->getArg(2)->getLocStart(),
2583 (*(TheCall->arg_end()-1))->getLocEnd());
2585 ExprResult OrigArg0 = TheCall->getArg(0);
2586 ExprResult OrigArg1 = TheCall->getArg(1);
2597 TheCall->setArg(0, OrigArg0.get());
2598 TheCall->setArg(1, OrigArg1.get());
2618 bool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) {
2619 if (TheCall->getNumArgs() < NumArgs)
2620 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
2621 << 0 << NumArgs << TheCall->getNumArgs()/*function call*/;
2622 if (TheCall->getNumArgs() > NumArgs)
2623 return Diag(TheCall->getArg(NumArgs)->getLocStart(),
2625 << 0 /*function call*/ << NumArgs << TheCall->getNumArgs()
2626 << SourceRange(TheCall->getArg(NumArgs)->getLocStart(),
2627 (*(TheCall->arg_end()-1))->getLocEnd());
2629 Expr *OrigArg = TheCall->getArg(NumArgs-1);
2647 TheCall->setArg(NumArgs-1, CastArg);
2656 ExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
2657 if (TheCall->getNumArgs() < 2)
2658 return ExprError(Diag(TheCall->getLocEnd(),
2660 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
2661 << TheCall->getSourceRange());
2667 QualType resType = TheCall->getArg(0)->getType();
2670 if (!TheCall->getArg(0)->isTypeDependent() &&
2671 !TheCall->getArg(1)->isTypeDependent()) {
2672 QualType LHSType = TheCall->getArg(0)->getType();
2673 QualType RHSType = TheCall->getArg(1)->getType();
2676 return ExprError(Diag(TheCall->getLocStart(),
2678 << SourceRange(TheCall->getArg(0)->getLocStart(),
2679 TheCall->getArg(1)->getLocEnd()));
2682 unsigned numResElements = TheCall->getNumArgs() - 2;
2687 if (TheCall->getNumArgs() == 2) {
2690 return ExprError(Diag(TheCall->getLocStart(),
2692 << SourceRange(TheCall->getArg(1)->getLocStart(),
2693 TheCall->getArg(1)->getLocEnd()));
2695 return ExprError(Diag(TheCall->getLocStart(),
2697 << SourceRange(TheCall->getArg(0)->getLocStart(),
2698 TheCall->getArg(1)->getLocEnd()));
2706 for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
2707 if (TheCall->getArg(i)->isTypeDependent() ||
2708 TheCall->getArg(i)->isValueDependent())
2712 if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
2713 return ExprError(Diag(TheCall->getLocStart(),
2715 << TheCall->getArg(i)->getSourceRange());
2722 return ExprError(Diag(TheCall->getLocStart(),
2724 << TheCall->getArg(i)->getSourceRange());
2729 for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
2730 exprs.push_back(TheCall->getArg(i));
2731 TheCall->setArg(i, nullptr);
2735 TheCall->getCallee()->getLocStart(),
2736 TheCall->getRParenLoc());
2772 bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
2773 unsigned NumArgs = TheCall->getNumArgs();
2776 return Diag(TheCall->getLocEnd(),
2779 << TheCall->getSourceRange();
2784 if (SemaBuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
2793 bool Sema::SemaBuiltinAssume(CallExpr *TheCall) {
2794 Expr *Arg = TheCall->getArg(0);
2800 << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
2807 bool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {
2808 unsigned NumArgs = TheCall->getNumArgs();
2811 return Diag(TheCall->getLocEnd(),
2814 << TheCall->getSourceRange();
2817 Expr *Arg = TheCall->getArg(1);
2822 if (SemaBuiltinConstantArg(TheCall, 1, Result))
2826 return Diag(TheCall->getLocStart(),
2832 ExprResult Arg(TheCall->getArg(2));
2837 TheCall->setArg(2, Arg.get());
2844 /// TheCall is a constant expression.
2845 bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
2847 Expr *Arg = TheCall->getArg(ArgNum);
2848 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
2854 return Diag(TheCall->getLocStart(), diag::err_constant_integer_arg_type)
2861 /// TheCall is a constant expression in the range [Low, High].
2862 bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
2867 Expr *Arg = TheCall->getArg(ArgNum);
2872 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
2876 return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
2883 /// TheCall is an ARM/AArch64 special register string literal.
2884 bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
2902 Expr *Arg = TheCall->getArg(ArgNum);
2908 return Diag(TheCall->getLocStart(), diag::err_expr_not_string_literal)
2917 return Diag(TheCall->getLocStart(), diag::err_arm_invalid_specialreg)
2959 return Diag(TheCall->getLocStart(), diag::err_arm_invalid_specialreg)
2969 if (TheCall->getNumArgs() != 2)
2977 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
2986 bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
2988 return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_unsupported)
2989 << SourceRange(TheCall->getLocStart(), TheCall->getLocEnd());
2991 Expr *Arg = TheCall->getArg(1);
2995 if (SemaBuiltinConstantArg(TheCall, 1, Result))
2999 return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val)
3008 bool Sema::SemaBuiltinSetjmp(CallExpr *TheCall) {
3010 return Diag(TheCall->getLocStart(), diag::err_builtin_setjmp_unsupported)
3011 << SourceRange(TheCall->getLocStart(), TheCall->getLocEnd());
7024 void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
7026 unsigned NumArgs = TheCall->getNumArgs();
7028 Expr *CurrA = TheCall->getArg(i);
7033 IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
7035 IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));