Lines Matching refs:TheCall
72 static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
73 if (checkArgCount(S, TheCall, 2))
77 Expr *ValArg = TheCall->getArg(0);
86 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
94 TheCall->setType(Ty);
100 static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall) {
101 if (checkArgCount(S, TheCall, 1))
104 ExprResult Arg(TheCall->getArg(0));
105 QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getLocStart());
109 TheCall->setArg(0, Arg.get());
110 TheCall->setType(ResultType);
115 CallExpr *TheCall, unsigned SizeIdx,
117 if (TheCall->getNumArgs() <= SizeIdx ||
118 TheCall->getNumArgs() <= DstSizeIdx)
121 const Expr *SizeArg = TheCall->getArg(SizeIdx);
122 const Expr *DstSizeArg = TheCall->getArg(DstSizeIdx);
136 SourceLocation SL = TheCall->getLocStart();
137 SourceRange SR = TheCall->getSourceRange();
205 static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
218 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
219 SemaRef.Diag(TheCall->getExprLoc(), DiagID)
229 CallExpr *TheCall) {
230 ExprResult TheCallResult(TheCall);
245 if (SemaBuiltinConstantArg(TheCall, ArgNo, Result))
252 assert(TheCall->getNumArgs() == 1 &&
254 if (CheckObjCString(TheCall->getArg(0)))
259 if (SemaBuiltinVAStart(TheCall))
266 if (SemaBuiltinVAStartARM(TheCall))
270 if (SemaBuiltinVAStart(TheCall))
282 if (SemaBuiltinUnorderedCompare(TheCall))
286 if (SemaBuiltinFPClassification(TheCall, 6))
294 if (SemaBuiltinFPClassification(TheCall, 1))
298 return SemaBuiltinShuffleVector(TheCall);
299 // TheCall will be freed by the smart pointer here, but that's fine, since
302 if (SemaBuiltinPrefetch(TheCall))
307 if (SemaBuiltinAssume(TheCall))
311 if (SemaBuiltinAssumeAligned(TheCall))
315 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
319 if (SemaBuiltinLongjmp(TheCall))
323 if (SemaBuiltinSetjmp(TheCall))
328 if (checkArgCount(*this, TheCall, 1))
333 if (checkArgCount(*this, TheCall, 1)) return true;
334 TheCall->setType(Context.IntTy);
337 if (checkArgCount(*this, TheCall, 1)) return true;
338 TheCall->setType(Context.IntTy);
449 if (SemaBuiltinAnnotation(*this, TheCall))
453 if (SemaBuiltinAddressof(*this, TheCall))
459 Diag(TheCall->getExprLoc(), diag::err_builtin_requires_language)
481 SemaBuiltinMemChkCall(*this, FDecl, TheCall, 2, 3);
484 SemaBuiltinMemChkCall(*this, FDecl, TheCall, 3, 4);
488 SemaBuiltinMemChkCall(*this, FDecl, TheCall, 1, 3);
492 if (SemaBuiltinCallWithStaticChain(*this, TheCall))
498 if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHExceptScope,
505 if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHFilterScope,
512 if (checkArgCount(*this, TheCall, 1))
516 TheCall->getLocStart(),
518 TheCall))
521 TheCall->setType(Context.VoidPtrTy);
534 if (CheckARMBuiltinFunctionCall(BuiltinID, TheCall))
539 if (CheckAArch64BuiltinFunctionCall(BuiltinID, TheCall))
546 if (CheckMipsBuiltinFunctionCall(BuiltinID, TheCall))
550 if (CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall))
555 if (CheckX86BuiltinFunctionCall(BuiltinID, TheCall))
561 if (CheckPPCBuiltinFunctionCall(BuiltinID, TheCall))
639 bool Sema::CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
653 unsigned ImmArg = TheCall->getNumArgs()-1;
655 if (SemaBuiltinConstantArg(TheCall, ImmArg, Result))
660 return Diag(TheCall->getLocStart(), diag::err_invalid_neon_type_code)
661 << TheCall->getArg(ImmArg)->getSourceRange();
666 Expr *Arg = TheCall->getArg(PtrArgNum);
701 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
704 bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
720 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
723 if (checkArgCount(*this, TheCall, IsLdrex ? 1 : 2))
730 Expr *PointerArg = TheCall->getArg(IsLdrex ? 0 : 1);
768 TheCall->setArg(IsLdrex ? 0 : 1, PointerArg);
802 TheCall->setType(ValType);
807 ExprResult ValArg = TheCall->getArg(0);
813 TheCall->setArg(0, ValArg.get());
817 TheCall->setType(Context.IntTy);
821 bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
828 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
832 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
833 SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
836 if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall))
855 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
859 CallExpr *TheCall) {
866 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
870 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
871 SemaBuiltinConstantArgRange(TheCall, 2, 0, 2) ||
872 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
873 SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
876 if (CheckNeonBuiltinFunctionCall(BuiltinID, TheCall))
889 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
892 bool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
905 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
908 bool Sema::CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
923 return Diag(TheCall->getLocStart(), diag::err_64_bit_builtin_32_bit_tgt)
924 << TheCall->getSourceRange();
929 return Diag(TheCall->getLocStart(), diag::err_ppc_builtin_only_on_pwr7)
930 << TheCall->getSourceRange();
936 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
937 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
945 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
946 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
948 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
952 CallExpr *TheCall) {
954 Expr *Arg = TheCall->getArg(0);
965 bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
1022 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
1231 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
1233 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
1235 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
1238 TheCall->getCallee());
1240 Expr** Args = TheCall->getArgs();
1241 unsigned NumArgs = TheCall->getNumArgs();
1250 IsMemberFunction, TheCall->getRParenLoc(),
1251 TheCall->getCallee()->getSourceRange(), CallType);
1259 CheckAbsoluteValueFunction(TheCall, FDecl, FnInfo);
1269 CheckStrlcpycatArguments(TheCall, FnInfo);
1271 CheckStrncatArguments(TheCall, FnInfo);
1273 CheckMemaccessArguments(TheCall, CMId, FnInfo);
1290 bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
1310 checkCall(NDecl, llvm::makeArrayRef(TheCall->getArgs(),
1311 TheCall->getNumArgs()),
1312 NumParams, /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
1313 TheCall->getCallee()->getSourceRange(), CallType);
1320 bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
1322 TheCall->getCallee());
1326 llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
1327 NumParams, /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
1328 TheCall->getCallee()->getSourceRange(), CallType);
1362 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
1363 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1465 if (TheCall->getNumArgs() < NumArgs[Form]) {
1466 Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
1467 << 0 << NumArgs[Form] << TheCall->getNumArgs()
1468 << TheCall->getCallee()->getSourceRange();
1470 } else if (TheCall->getNumArgs() > NumArgs[Form]) {
1471 Diag(TheCall->getArg(NumArgs[Form])->getLocStart(),
1473 << 0 << NumArgs[Form] << TheCall->getNumArgs()
1474 << TheCall->getCallee()->getSourceRange();
1479 Expr *Ptr = TheCall->getArg(0);
1610 ExprResult Arg = TheCall->getArg(i);
1614 TheCall->setArg(i, Arg.get());
1623 SubExprs.push_back(TheCall->getArg(1)); // Val1
1626 SubExprs.push_back(TheCall->getArg(1)); // Order
1631 SubExprs.push_back(TheCall->getArg(2)); // Order
1632 SubExprs.push_back(TheCall->getArg(1)); // Val1
1636 SubExprs.push_back(TheCall->getArg(3)); // Order
1637 SubExprs.push_back(TheCall->getArg(1)); // Val1
1638 SubExprs.push_back(TheCall->getArg(2)); // Val2
1641 SubExprs.push_back(TheCall->getArg(3)); // Order
1642 SubExprs.push_back(TheCall->getArg(1)); // Val1
1643 SubExprs.push_back(TheCall->getArg(4)); // OrderFail
1644 SubExprs.push_back(TheCall->getArg(2)); // Val2
1647 SubExprs.push_back(TheCall->getArg(4)); // Order
1648 SubExprs.push_back(TheCall->getArg(1)); // Val1
1649 SubExprs.push_back(TheCall->getArg(5)); // OrderFail
1650 SubExprs.push_back(TheCall->getArg(2)); // Val2
1651 SubExprs.push_back(TheCall->getArg(3)); // Weak
1664 AtomicExpr *AE = new (Context) AtomicExpr(TheCall->getCallee()->getLocStart(),
1666 TheCall->getRParenLoc());
1712 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
1713 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1717 if (TheCall->getNumArgs() < 1) {
1718 Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
1719 << 0 << 1 << TheCall->getNumArgs()
1720 << TheCall->getCallee()->getSourceRange();
1729 Expr *FirstArg = TheCall->getArg(0);
1734 TheCall->setArg(0, FirstArg);
1988 if (TheCall->getNumArgs() < 1+NumFixed) {
1989 Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
1990 << 0 << 1+NumFixed << TheCall->getNumArgs()
1991 << TheCall->getCallee()->getSourceRange();
1996 Diag(TheCall->getLocEnd(), diag::warn_sync_fetch_and_nand_semantics_change)
1997 << TheCall->getCallee()->getSourceRange();
2022 ExprResult Arg = TheCall->getArg(i+1);
2039 TheCall->setArg(i+1, Arg.get());
2060 TheCall->setCallee(PromotedCall.get());
2065 TheCall->setType(ResultType);
2104 bool Sema::SemaBuiltinVAStart(CallExpr *TheCall) {
2105 Expr *Fn = TheCall->getCallee();
2106 if (TheCall->getNumArgs() > 2) {
2107 Diag(TheCall->getArg(2)->getLocStart(),
2109 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
2111 << SourceRange(TheCall->getArg(2)->getLocStart(),
2112 (*(TheCall->arg_end()-1))->getLocEnd());
2116 if (TheCall->getNumArgs() < 2) {
2117 return Diag(TheCall->getLocEnd(),
2119 << 0 /*function call*/ << 2 << TheCall->getNumArgs();
2123 if (checkBuiltinArgument(*this, TheCall, 0))
2144 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
2170 Diag(TheCall->getArg(1)->getLocStart(),
2178 TheCall->setType(Context.VoidTy);
2236 bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
2237 if (TheCall->getNumArgs() < 2)
2238 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
2239 << 0 << 2 << TheCall->getNumArgs()/*function call*/;
2240 if (TheCall->getNumArgs() > 2)
2241 return Diag(TheCall->getArg(2)->getLocStart(),
2243 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
2244 << SourceRange(TheCall->getArg(2)->getLocStart(),
2245 (*(TheCall->arg_end()-1))->getLocEnd());
2247 ExprResult OrigArg0 = TheCall->getArg(0);
2248 ExprResult OrigArg1 = TheCall->getArg(1);
2259 TheCall->setArg(0, OrigArg0.get());
2260 TheCall->setArg(1, OrigArg1.get());
2280 bool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) {
2281 if (TheCall->getNumArgs() < NumArgs)
2282 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
2283 << 0 << NumArgs << TheCall->getNumArgs()/*function call*/;
2284 if (TheCall->getNumArgs() > NumArgs)
2285 return Diag(TheCall->getArg(NumArgs)->getLocStart(),
2287 << 0 /*function call*/ << NumArgs << TheCall->getNumArgs()
2288 << SourceRange(TheCall->getArg(NumArgs)->getLocStart(),
2289 (*(TheCall->arg_end()-1))->getLocEnd());
2291 Expr *OrigArg = TheCall->getArg(NumArgs-1);
2309 TheCall->setArg(NumArgs-1, CastArg);
2318 ExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
2319 if (TheCall->getNumArgs() < 2)
2320 return ExprError(Diag(TheCall->getLocEnd(),
2322 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
2323 << TheCall->getSourceRange());
2329 QualType resType = TheCall->getArg(0)->getType();
2332 if (!TheCall->getArg(0)->isTypeDependent() &&
2333 !TheCall->getArg(1)->isTypeDependent()) {
2334 QualType LHSType = TheCall->getArg(0)->getType();
2335 QualType RHSType = TheCall->getArg(1)->getType();
2338 return ExprError(Diag(TheCall->getLocStart(),
2340 << SourceRange(TheCall->getArg(0)->getLocStart(),
2341 TheCall->getArg(1)->getLocEnd()));
2344 unsigned numResElements = TheCall->getNumArgs() - 2;
2349 if (TheCall->getNumArgs() == 2) {
2352 return ExprError(Diag(TheCall->getLocStart(),
2354 << SourceRange(TheCall->getArg(1)->getLocStart(),
2355 TheCall->getArg(1)->getLocEnd()));
2357 return ExprError(Diag(TheCall->getLocStart(),
2359 << SourceRange(TheCall->getArg(0)->getLocStart(),
2360 TheCall->getArg(1)->getLocEnd()));
2368 for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
2369 if (TheCall->getArg(i)->isTypeDependent() ||
2370 TheCall->getArg(i)->isValueDependent())
2374 if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
2375 return ExprError(Diag(TheCall->getLocStart(),
2377 << TheCall->getArg(i)->getSourceRange());
2384 return ExprError(Diag(TheCall->getLocStart(),
2386 << TheCall->getArg(i)->getSourceRange());
2391 for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
2392 exprs.push_back(TheCall->getArg(i));
2393 TheCall->setArg(i, nullptr);
2397 TheCall->getCallee()->getLocStart(),
2398 TheCall->getRParenLoc());
2434 bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
2435 unsigned NumArgs = TheCall->getNumArgs();
2438 return Diag(TheCall->getLocEnd(),
2441 << TheCall->getSourceRange();
2446 if (SemaBuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
2455 bool Sema::SemaBuiltinAssume(CallExpr *TheCall) {
2456 Expr *Arg = TheCall->getArg(0);
2462 << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
2469 bool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {
2470 unsigned NumArgs = TheCall->getNumArgs();
2473 return Diag(TheCall->getLocEnd(),
2476 << TheCall->getSourceRange();
2479 Expr *Arg = TheCall->getArg(1);
2484 if (SemaBuiltinConstantArg(TheCall, 1, Result))
2488 return Diag(TheCall->getLocStart(),
2494 ExprResult Arg(TheCall->getArg(2));
2499 TheCall->setArg(2, Arg.get());
2506 /// TheCall is a constant expression.
2507 bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
2509 Expr *Arg = TheCall->getArg(ArgNum);
2510 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
2516 return Diag(TheCall->getLocStart(), diag::err_constant_integer_arg_type)
2523 /// TheCall is a constant expression in the range [Low, High].
2524 bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
2529 Expr *Arg = TheCall->getArg(ArgNum);
2534 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
2538 return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
2547 bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
2549 return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_unsupported)
2550 << SourceRange(TheCall->getLocStart(), TheCall->getLocEnd());
2552 Expr *Arg = TheCall->getArg(1);
2556 if (SemaBuiltinConstantArg(TheCall, 1, Result))
2560 return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val)
2569 bool Sema::SemaBuiltinSetjmp(CallExpr *TheCall) {
2571 return Diag(TheCall->getLocStart(), diag::err_builtin_setjmp_unsupported)
2572 << SourceRange(TheCall->getLocStart(), TheCall->getLocEnd());
6522 void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
6524 unsigned NumArgs = TheCall->getNumArgs();
6526 Expr *CurrA = TheCall->getArg(i);
6531 IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
6533 IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));
