Lines Matching defs:TheCall
132 static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
133 if (checkArgCount(S, TheCall, 2))
137 Expr *ValArg = TheCall->getArg(0);
146 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
154 TheCall->setType(Ty);
158 static bool SemaBuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) {
160 if (TheCall->getNumArgs() < 1) {
161 S.Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
162 << 0 << 1 << TheCall->getNumArgs()
163 << TheCall->getCallee()->getSourceRange();
168 for (Expr *Arg : TheCall->arguments()) {
182 static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall) {
183 if (checkArgCount(S, TheCall, 1))
186 ExprResult Arg(TheCall->getArg(0));
187 QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getBeginLoc());
191 TheCall->setArg(0, Arg.get());
192 TheCall->setType(ResultType);
198 static bool SemaBuiltinPreserveAI(Sema &S, CallExpr *TheCall) {
199 if (checkArgCount(S, TheCall, 1))
202 TheCall->setType(TheCall->getArg(0)->getType());
209 static bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {
210 if (checkArgCount(S, TheCall, 2))
213 clang::Expr *Source = TheCall->getArg(0);
233 clang::Expr *AlignOp = TheCall->getArg(1);
272 TheCall->setArg(0, SrcArg.get());
279 TheCall->setArg(1, AlignArg.get());
283 TheCall->setType(IsBooleanAlignBuiltin ? S.Context.BoolTy : SrcTy);
287 static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall,
289 if (checkArgCount(S, TheCall, 3))
294 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(I));
296 TheCall->setArg(I, Arg.get());
310 ExprResult Arg = S.DefaultFunctionArrayLvalueConversion(TheCall->getArg(2));
312 TheCall->setArg(2, Arg.get());
330 const auto Arg = TheCall->getArg(I);
593 CallExpr *TheCall) {
597 if (TheCall->isValueDependent() || TheCall->isTypeDependent() ||
618 auto *FormatExpr = TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
666 SizeIndex = TheCall->getNumArgs() - 2;
667 ObjectIndex = TheCall->getNumArgs() - 1;
692 SizeIndex = TheCall->getNumArgs() - 1;
706 SizeIndex = TheCall->getNumArgs() - 1;
726 Expr *SizeArg = TheCall->getArg(ObjectIndex);
741 Expr *ObjArg = TheCall->getArg(ObjectIndex);
752 Expr *UsedSizeArg = TheCall->getArg(SizeIndex);
771 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
777 static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
790 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
791 SemaRef.Diag(TheCall->getExprLoc(), DiagID)
847 static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall) {
848 if (checkArgCount(S, TheCall, 2))
851 if (checkOpenCLSubgroupExt(S, TheCall))
855 Expr *NDRangeArg = TheCall->getArg(0);
858 << TheCall->getDirectCallee() << "'ndrange_t'";
862 Expr *BlockArg = TheCall->getArg(1);
865 << TheCall->getDirectCallee() << "block";
874 static bool SemaOpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall) {
875 if (checkArgCount(S, TheCall, 1))
878 Expr *BlockArg = TheCall->getArg(0);
881 << TheCall->getDirectCallee() << "block";
891 static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall,
895 IllegalParams |= checkOpenCLEnqueueIntType(S, TheCall->getArg(I),
902 static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall,
909 unsigned TotalNumArgs = TheCall->getNumArgs();
914 S.Diag(TheCall->getBeginLoc(),
920 return checkOpenCLEnqueueLocalSizeArgs(S, TheCall, NumNonVarArgs,
950 static bool SemaOpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall) {
951 unsigned NumArgs = TheCall->getNumArgs();
954 S.Diag(TheCall->getBeginLoc(),
960 Expr *Arg0 = TheCall->getArg(0);
961 Expr *Arg1 = TheCall->getArg(1);
962 Expr *Arg2 = TheCall->getArg(2);
963 Expr *Arg3 = TheCall->getArg(3);
967 S.Diag(TheCall->getArg(0)->getBeginLoc(),
969 << TheCall->getDirectCallee() << S.Context.OCLQueueTy;
975 S.Diag(TheCall->getArg(1)->getBeginLoc(),
977 << TheCall->getDirectCallee() << "'kernel_enqueue_flags_t' (i.e. uint)";
983 S.Diag(TheCall->getArg(2)->getBeginLoc(),
985 << TheCall->getDirectCallee() << "'ndrange_t'";
995 << TheCall->getDirectCallee() << "block";
1011 checkOpenCLEnqueueVariadicArgs(S, TheCall, Arg3, 4));
1015 Expr *Arg6 = TheCall->getArg(6);
1018 << TheCall->getDirectCallee() << "block";
1026 S.Diag(TheCall->getArg(3)->getBeginLoc(),
1028 << TheCall->getDirectCallee() << "integer";
1032 Expr *Arg4 = TheCall->getArg(4);
1033 Expr *Arg5 = TheCall->getArg(5);
1039 S.Diag(TheCall->getArg(4)->getBeginLoc(),
1041 << TheCall->getDirectCallee()
1051 S.Diag(TheCall->getArg(5)->getBeginLoc(),
1053 << TheCall->getDirectCallee()
1061 return checkOpenCLEnqueueVariadicArgs(S, TheCall, Arg6, 7);
1065 S.Diag(TheCall->getBeginLoc(),
1319 static ExprResult SemaBuiltinLaunder(Sema &S, CallExpr *TheCall) {
1320 if (checkArgCount(S, TheCall, 1))
1329 QualType ArgTy = TheCall->getArg(0)->getType();
1338 TheCall->setType(ParamTy);
1350 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_launder_invalid_arg)
1351 << DiagSelect.getValue() << TheCall->getSourceRange();
1361 if (S.RequireCompleteType(TheCall->getBeginLoc(), ParamTy->getPointeeType(),
1371 S.PerformCopyInitialization(Entity, SourceLocation(), TheCall->getArg(0));
1374 TheCall->setArg(0, Arg.get());
1376 return TheCall;
1382 CheckBuiltinTargetSupport(Sema &S, unsigned BuiltinID, CallExpr *TheCall,
1388 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
1389 << TheCall->getSourceRange();
1397 CallExpr *TheCall) {
1407 return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
1411 return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
1414 return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
1416 return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
1421 return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
1423 return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
1426 return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
1430 return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
1432 return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
1438 CallExpr *TheCall) {
1439 ExprResult TheCallResult(TheCall);
1454 if (SemaBuiltinConstantArg(TheCall, ArgNo, Result))
1461 assert(TheCall->getNumArgs() == 1 &&
1463 if (CheckObjCString(TheCall->getArg(0)))
1469 if (SemaBuiltinVAStart(BuiltinID, TheCall))
1477 if (SemaBuiltinVAStartARMMicrosoft(TheCall))
1481 if (SemaBuiltinVAStart(BuiltinID, TheCall))
1496 *this, BuiltinID, TheCall,
1508 if (CheckBuiltinTargetSupport(*this, BuiltinID, TheCall,
1520 if (SemaBuiltinUnorderedCompare(TheCall))
1524 if (SemaBuiltinFPClassification(TheCall, 6))
1535 if (SemaBuiltinFPClassification(TheCall, 1))
1539 return SemaBuiltinShuffleVector(TheCall);
1540 // TheCall will be freed by the smart pointer here, but that's fine, since
1543 if (SemaBuiltinPrefetch(TheCall))
1547 if (SemaBuiltinAllocaWithAlign(TheCall))
1551 Diag(TheCall->getBeginLoc(), diag::warn_alloca)
1552 << TheCall->getDirectCallee();
1556 if (SemaBuiltinAssume(TheCall))
1560 if (SemaBuiltinAssumeAligned(TheCall))
1565 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
1569 if (SemaBuiltinLongjmp(TheCall))
1573 if (SemaBuiltinSetjmp(TheCall))
1577 if (checkArgCount(*this, TheCall, 1)) return true;
1578 TheCall->setType(Context.IntTy);
1581 if (checkArgCount(*this, TheCall, 1)) return true;
1582 ExprResult Arg = DefaultFunctionArrayLvalueConversion(TheCall->getArg(0));
1584 TheCall->setArg(0, Arg.get());
1585 TheCall->setType(Context.IntTy);
1589 return SemaBuiltinLaunder(*this, TheCall);
1694 Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst)
1695 << TheCall->getCallee()->getSourceRange();
1701 clang::Expr *SizeOp = TheCall->getArg(2);
1708 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
1709 CheckNonNullArgument(*this, TheCall->getArg(1), TheCall->getExprLoc());
1719 if (SemaBuiltinMSVCAnnotation(*this, TheCall))
1723 if (SemaBuiltinAnnotation(*this, TheCall))
1727 if (SemaBuiltinAddressof(*this, TheCall))
1733 if (SemaBuiltinAlignment(*this, TheCall, BuiltinID))
1739 if (SemaBuiltinOverflow(*this, TheCall, BuiltinID))
1753 if (checkArgCount(*this, TheCall, 2))
1756 const Expr *PtrArg = TheCall->getArg(0)->IgnoreParenImpCasts();
1767 const Expr *FnPtrArg = TheCall->getArg(1)->IgnoreImpCasts();
1804 TheCall->setType(Context.IntTy);
1809 if (checkArgCount(*this, TheCall, 3))
1812 const Expr *ProbArg = TheCall->getArg(2);
1838 if (SemaBuiltinPreserveAI(*this, TheCall))
1842 if (SemaBuiltinCallWithStaticChain(*this, TheCall))
1847 if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHExceptScope,
1853 if (SemaBuiltinSEHScopeCheck(*this, TheCall, Scope::SEHFilterScope,
1858 if (checkArgCount(*this, TheCall, 1))
1862 TheCall->getBeginLoc(),
1864 TheCall))
1867 TheCall->setType(Context.VoidPtrTy);
1874 if (SemaBuiltinRWPipe(*this, TheCall))
1881 if (SemaBuiltinReserveRWPipe(*this, TheCall))
1886 if (checkOpenCLSubgroupExt(*this, TheCall) ||
1887 SemaBuiltinReserveRWPipe(*this, TheCall))
1894 if (SemaBuiltinCommitRWPipe(*this, TheCall))
1899 if (checkOpenCLSubgroupExt(*this, TheCall) ||
1900 SemaBuiltinCommitRWPipe(*this, TheCall))
1905 if (SemaBuiltinPipePackets(*this, TheCall))
1911 if (SemaOpenCLBuiltinToAddr(*this, BuiltinID, TheCall))
1916 if (SemaOpenCLBuiltinEnqueueKernel(*this, TheCall))
1921 if (SemaOpenCLBuiltinKernelWorkGroupSize(*this, TheCall))
1926 if (SemaOpenCLBuiltinNDRangeAndBlock(*this, TheCall))
1933 if (SemaBuiltinOSLogFormat(TheCall))
1938 if (SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
1944 if (TheCall->getArg(0)->EvaluateAsInt(Result, getASTContext()) &&
1946 Diag(TheCall->getBeginLoc(), diag::warn_frame_address)
1950 << TheCall->getSourceRange();
1955 return SemaBuiltinMatrixTranspose(TheCall, TheCallResult);
1958 return SemaBuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
1961 return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
1973 Context.BuiltinInfo.getAuxBuiltinID(BuiltinID), TheCall))
1977 TheCall))
2060 bool Sema::CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
2085 Expr *Arg = TheCall->getArg(ArgNum);
2091 if (SemaBuiltinConstantArg(TheCall, ArgNum, Imm))
2095 return Diag(TheCall->getBeginLoc(), ErrDiag) << Arg->getSourceRange();
2101 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
2105 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
2109 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
2113 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
2117 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2122 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
2126 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1,
2131 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2136 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2141 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2146 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2164 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
2168 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
2172 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
2182 unsigned BuiltinID, CallExpr *TheCall) {
2197 unsigned ImmArg = TheCall->getNumArgs()-1;
2199 if (SemaBuiltinConstantArg(TheCall, ImmArg, Result))
2204 return Diag(TheCall->getBeginLoc(), diag::err_invalid_neon_type_code)
2205 << TheCall->getArg(ImmArg)->getSourceRange();
2210 Expr *Arg = TheCall->getArg(PtrArgNum);
2247 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
2250 bool Sema::CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
2259 CallExpr *TheCall) {
2270 return CheckARMCoprocessorImmediate(TI, TheCall->getArg(0), /*WantCDE*/ true);
2299 bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
2315 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
2318 if (checkArgCount(*this, TheCall, IsLdrex ? 1 : 2))
2325 Expr *PointerArg = TheCall->getArg(IsLdrex ? 0 : 1);
2362 TheCall->setArg(IsLdrex ? 0 : 1, PointerArg);
2395 TheCall->setType(ValType);
2400 ExprResult ValArg = TheCall->getArg(0);
2406 TheCall->setArg(0, ValArg.get());
2410 TheCall->setType(Context.IntTy);
2415 CallExpr *TheCall) {
2420 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
2424 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
2425 SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
2430 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3, false);
2436 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
2438 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
2440 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
2442 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
2451 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 32);
2453 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
2455 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
2457 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
2460 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
2465 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15);
2484 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15) ||
2485 CheckARMCoprocessorImmediate(TI, TheCall->getArg(0),
2492 CallExpr *TheCall) {
2497 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
2501 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
2502 SemaBuiltinConstantArgRange(TheCall, 2, 0, 2) ||
2503 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
2504 SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
2509 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
2518 return SemaBuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
2525 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
2532 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
2535 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
2537 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
2540 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
2554 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
2558 CallExpr *TheCall) {
2563 if (checkArgCount(*this, TheCall, 2))
2570 Arg = TheCall->getArg(1);
2577 TheCall->setType(Context.UnsignedIntTy);
2585 Arg = TheCall->getArg(0);
2596 Arg = TheCall->getArg(1);
2604 TheCall->setType(Context.UnsignedIntTy);
2608 bool Sema::CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
2831 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
2836 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max) |
2837 SemaBuiltinConstantArgMultiple(TheCall, A.OpNum, M);
2844 CallExpr *TheCall) {
2845 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
2849 unsigned BuiltinID, CallExpr *TheCall) {
2850 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
2851 CheckMipsBuiltinArgument(BuiltinID, TheCall);
2855 CallExpr *TheCall) {
2860 return Diag(TheCall->getBeginLoc(), diag::err_mips_builtin_requires_dsp);
2866 return Diag(TheCall->getBeginLoc(),
2873 return Diag(TheCall->getBeginLoc(), diag::err_mips_builtin_requires_msa);
2888 bool Sema::CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
3059 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
3061 return SemaBuiltinConstantArgRange(TheCall, i, l, u) ||
3062 SemaBuiltinConstantArgMultiple(TheCall, i, m);
3066 CallExpr *TheCall) {
3078 return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
3079 << TheCall->getSourceRange();
3083 return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_only_on_pwr7)
3084 << TheCall->getSourceRange();
3086 auto SemaVSXCheck = [&](CallExpr *TheCall) -> bool {
3088 return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_only_on_pwr7)
3089 << TheCall->getSourceRange();
3097 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3098 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
3100 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
3108 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
3109 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
3114 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
3117 return SemaBuiltinVSX(TheCall);
3119 return SemaVSXCheck(TheCall) ||
3120 SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
3122 return SemaVSXCheck(TheCall);
3124 return SemaBuiltinConstantArgRange(TheCall, 1, 2, 7);
3126 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 255);
3128 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
3130 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
3132 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
3134 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
3138 CallExpr *TheCall) {
3157 ExprResult Arg = TheCall->getArg(OrderIndex);
3180 Arg = TheCall->getArg(ScopeIndex);
3193 CallExpr *TheCall) {
3195 Expr *Arg = TheCall->getArg(0);
3227 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15) ||
3228 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
3254 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
3261 CallExpr *TheCall) {
3262 Expr *Arg = TheCall->getArg(0);
3266 return S.Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
3273 return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_supports)
3281 static bool SemaBuiltinCpuIs(Sema &S, const TargetInfo &TI, CallExpr *TheCall) {
3282 Expr *Arg = TheCall->getArg(0);
3286 return S.Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
3293 return S.Diag(TheCall->getBeginLoc(), diag::err_invalid_cpu_is)
3299 bool Sema::CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall) {
3481 Expr *Arg = TheCall->getArg(ArgNum);
3486 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
3499 return Diag(TheCall->getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
3505 CallExpr *TheCall) {
3591 Expr *Arg = TheCall->getArg(ArgNum);
3596 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
3602 return Diag(TheCall->getBeginLoc(), diag::err_x86_builtin_invalid_scale)
3608 bool Sema::CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,
3611 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, TileRegLow, TileRegHigh))
3617 bool Sema::CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall, int ArgNum) {
3618 return SemaBuiltinConstantArgRange(TheCall, ArgNum, TileRegLow, TileRegHigh);
3621 bool Sema::CheckX86BuiltinTileDuplicate(CallExpr *TheCall,
3628 SemaBuiltinConstantArg(TheCall, ArgNum, Arg);
3633 return Diag(TheCall->getBeginLoc(),
3635 << TheCall->getArg(ArgNum)->getSourceRange();
3641 bool Sema::CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,
3643 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
3644 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
3647 bool Sema::CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall) {
3655 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
3661 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
3676 CallExpr *TheCall) {
3678 return SemaBuiltinCpuSupports(*this, TI, TheCall);
3681 return SemaBuiltinCpuIs(*this, TI, TheCall);
3686 return Diag(TheCall->getCallee()->getBeginLoc(),
3690 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
3694 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
3698 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
4037 return SemaBuiltinConstantArgRange(TheCall, i, l, u, /*RangeIsError*/ false);
4347 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
4349 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
4351 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
4354 TheCall->getCallee());
4355 Expr** Args = TheCall->getArgs();
4356 unsigned NumArgs = TheCall->getNumArgs();
4368 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
4371 IsMemberFunction, TheCall->getRParenLoc(),
4372 TheCall->getCallee()->getSourceRange(), CallType);
4380 CheckAbsoluteValueFunction(TheCall, FDecl);
4381 CheckMaxUnsignedZero(TheCall, FDecl);
4392 CheckStrlcpycatArguments(TheCall, FnInfo);
4394 CheckStrncatArguments(TheCall, FnInfo);
4396 CheckMemaccessArguments(TheCall, CMId, FnInfo);
4413 bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
4437 llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
4438 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
4439 TheCall->getCallee()->getSourceRange(), CallType);
4446 bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
4448 TheCall->getCallee());
4450 llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs()),
4451 /*IsMemberFunction=*/false, TheCall->getRParenLoc(),
4452 TheCall->getCallee()->getSourceRange(), CallType);
4489 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
4490 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
4491 MultiExprArg Args{TheCall->getArgs(), TheCall->getNumArgs()};
4492 return BuildAtomicExpr({TheCall->getBeginLoc(), TheCall->getEndLoc()},
4493 DRE->getSourceRange(), TheCall->getRParenLoc(), Args,
4995 CallExpr *TheCall = static_cast<CallExpr *>(TheCallResult.get());
4996 Expr *Callee = TheCall->getCallee();
5001 if (TheCall->getNumArgs() < 1) {
5002 Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
5003 << 0 << 1 << TheCall->getNumArgs() << Callee->getSourceRange();
5012 Expr *FirstArg = TheCall->getArg(0);
5017 TheCall->setArg(0, FirstArg);
5277 if (TheCall->getNumArgs() < 1+NumFixed) {
5278 Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
5279 << 0 << 1 + NumFixed << TheCall->getNumArgs()
5284 Diag(TheCall->getEndLoc(), diag::warn_atomic_implicit_seq_cst)
5288 Diag(TheCall->getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
5314 ExprResult Arg = TheCall->getArg(i+1);
5331 TheCall->setArg(i+1, Arg.get());
5345 TheCall->setCallee(PromotedCall.get());
5350 TheCall->setType(ResultType);
5371 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
5373 cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
5383 if (checkArgCount(*this, TheCall, numArgs))
5390 Expr *PointerArg = TheCall->getArg(numArgs - 1);
5397 TheCall->setArg(numArgs - 1, PointerArg);
5420 TheCall->setType(ValType);
5424 ExprResult ValArg = TheCall->getArg(0);
5431 TheCall->setArg(0, ValArg.get());
5432 TheCall->setType(Context.VoidTy);
5571 bool Sema::SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) {
5572 Expr *Fn = TheCall->getCallee();
5577 if (TheCall->getNumArgs() > 2) {
5578 Diag(TheCall->getArg(2)->getBeginLoc(),
5580 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
5582 << SourceRange(TheCall->getArg(2)->getBeginLoc(),
5583 (*(TheCall->arg_end() - 1))->getEndLoc());
5587 if (TheCall->getNumArgs() < 2) {
5588 return Diag(TheCall->getEndLoc(),
5590 << 0 /*function call*/ << 2 << TheCall->getNumArgs();
5594 if (checkBuiltinArgument(*this, TheCall, 0))
5605 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
5625 Diag(TheCall->getArg(1)->getBeginLoc(),
5646 TheCall->setType(Context.VoidTy);
5700 bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
5701 if (TheCall->getNumArgs() < 2)
5702 return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args)
5703 << 0 << 2 << TheCall->getNumArgs() /*function call*/;
5704 if (TheCall->getNumArgs() > 2)
5705 return Diag(TheCall->getArg(2)->getBeginLoc(),
5707 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
5708 << SourceRange(TheCall->getArg(2)->getBeginLoc(),
5709 (*(TheCall->arg_end() - 1))->getEndLoc());
5711 ExprResult OrigArg0 = TheCall->getArg(0);
5712 ExprResult OrigArg1 = TheCall->getArg(1);
5717 OrigArg0, OrigArg1, TheCall->getExprLoc(), ACK_Comparison);
5724 TheCall->setArg(0, OrigArg0.get());
5725 TheCall->setArg(1, OrigArg1.get());
5746 bool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) {
5747 if (TheCall->getNumArgs() < NumArgs)
5748 return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args)
5749 << 0 << NumArgs << TheCall->getNumArgs() /*function call*/;
5750 if (TheCall->getNumArgs() > NumArgs)
5751 return Diag(TheCall->getArg(NumArgs)->getBeginLoc(),
5753 << 0 /*function call*/ << NumArgs << TheCall->getNumArgs()
5754 << SourceRange(TheCall->getArg(NumArgs)->getBeginLoc(),
5755 (*(TheCall->arg_end() - 1))->getEndLoc());
5760 Expr *Arg = TheCall->getArg(i);
5769 TheCall->setArg(i, Res.get());
5772 Expr *OrigArg = TheCall->getArg(NumArgs-1);
5784 TheCall->setArg(NumArgs - 1, OrigArg);
5802 bool Sema::SemaBuiltinVSX(CallExpr *TheCall) {
5804 if (TheCall->getNumArgs() < ExpectedNumArgs)
5805 return Diag(TheCall->getEndLoc(),
5807 << 0 /*function call*/ << ExpectedNumArgs << TheCall->getNumArgs()
5808 << TheCall->getSourceRange();
5810 if (TheCall->getNumArgs() > ExpectedNumArgs)
5811 return Diag(TheCall->getEndLoc(),
5813 << 0 /*function call*/ << ExpectedNumArgs << TheCall->getNumArgs()
5814 << TheCall->getSourceRange();
5818 if(!TheCall->getArg(2)->isIntegerConstantExpr(Value, Context))
5819 return Diag(TheCall->getBeginLoc(),
5821 << 3 /* argument index */ << TheCall->getDirectCallee()
5822 << SourceRange(TheCall->getArg(2)->getBeginLoc(),
5823 TheCall->getArg(2)->getEndLoc());
5825 QualType Arg1Ty = TheCall->getArg(0)->getType();
5826 QualType Arg2Ty = TheCall->getArg(1)->getType();
5829 SourceLocation BuiltinLoc = TheCall->getBeginLoc();
5833 << TheCall->getDirectCallee()
5834 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5835 TheCall->getArg(1)->getEndLoc());
5841 << TheCall->getDirectCallee()
5842 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5843 TheCall->getArg(1)->getEndLoc());
5849 TheCall->setType(Arg1Ty);
5856 ExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
5857 if (TheCall->getNumArgs() < 2)
5858 return ExprError(Diag(TheCall->getEndLoc(),
5860 << 0 /*function call*/ << 2 << TheCall->getNumArgs()
5861 << TheCall->getSourceRange());
5866 QualType resType = TheCall->getArg(0)->getType();
5869 if (!TheCall->getArg(0)->isTypeDependent() &&
5870 !TheCall->getArg(1)->isTypeDependent()) {
5871 QualType LHSType = TheCall->getArg(0)->getType();
5872 QualType RHSType = TheCall->getArg(1)->getType();
5876 Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_non_vector)
5877 << TheCall->getDirectCallee()
5878 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5879 TheCall->getArg(1)->getEndLoc()));
5882 unsigned numResElements = TheCall->getNumArgs() - 2;
5887 if (TheCall->getNumArgs() == 2) {
5890 return ExprError(Diag(TheCall->getBeginLoc(),
5892 << TheCall->getDirectCallee()
5893 << SourceRange(TheCall->getArg(1)->getBeginLoc(),
5894 TheCall->getArg(1)->getEndLoc()));
5896 return ExprError(Diag(TheCall->getBeginLoc(),
5898 << TheCall->getDirectCallee()
5899 << SourceRange(TheCall->getArg(0)->getBeginLoc(),
5900 TheCall->getArg(1)->getEndLoc()));
5908 for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
5909 if (TheCall->getArg(i)->isTypeDependent() ||
5910 TheCall->getArg(i)->isValueDependent())
5914 if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
5915 return ExprError(Diag(TheCall->getBeginLoc(),
5917 << TheCall->getArg(i)->getSourceRange());
5924 return ExprError(Diag(TheCall->getBeginLoc(),
5926 << TheCall->getArg(i)->getSourceRange());
5931 for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
5932 exprs.push_back(TheCall->getArg(i));
5933 TheCall->setArg(i, nullptr);
5937 TheCall->getCallee()->getBeginLoc(),
5938 TheCall->getRParenLoc());
5974 bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
5975 unsigned NumArgs = TheCall->getNumArgs();
5978 return Diag(TheCall->getEndLoc(),
5980 << 0 /*function call*/ << 3 << NumArgs << TheCall->getSourceRange();
5985 if (SemaBuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
5994 bool Sema::SemaBuiltinAssume(CallExpr *TheCall) {
5995 Expr *Arg = TheCall->getArg(0);
6001 << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
6009 bool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {
6011 Expr *Arg = TheCall->getArg(1);
6019 Diag(TheCall->getBeginLoc(), diag::warn_alloca_align_alignof)
6025 return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two)
6029 return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_small)
6033 return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_big)
6042 bool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {
6043 unsigned NumArgs = TheCall->getNumArgs();
6046 return Diag(TheCall->getEndLoc(),
6048 << 0 /*function call*/ << 3 << NumArgs << TheCall->getSourceRange();
6051 Expr *Arg = TheCall->getArg(1);
6056 if (SemaBuiltinConstantArg(TheCall, 1, Result))
6060 return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two)
6064 Diag(TheCall->getBeginLoc(), diag::warn_assume_aligned_too_great)
6069 ExprResult Arg(TheCall->getArg(2));
6074 TheCall->setArg(2, Arg.get());
6080 bool Sema::SemaBuiltinOSLogFormat(CallExpr *TheCall) {
6082 cast<FunctionDecl>(TheCall->getCalleeDecl())->getBuiltinID();
6085 unsigned NumArgs = TheCall->getNumArgs();
6088 return Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args)
6090 << TheCall->getSourceRange();
6093 return Diag(TheCall->getEndLoc(),
6096 << TheCall->getSourceRange();
6102 ExprResult Arg(TheCall->getArg(i));
6108 TheCall->setArg(i, Arg.get());
6115 ExprResult Arg = CheckOSLogFormatStringArg(TheCall->getArg(i));
6118 TheCall->setArg(i, Arg.get());
6126 TheCall->getArg(i), VariadicFunction, nullptr);
6133 << TheCall->getSourceRange();
6135 TheCall->setArg(i, Arg.get());
6143 ArrayRef<const Expr *> Args(TheCall->getArgs(), TheCall->getNumArgs());
6146 VariadicFunction, TheCall->getBeginLoc(), SourceRange(),
6153 TheCall->setType(Context.getSizeType());
6155 TheCall->setType(Context.VoidPtrTy);
6161 /// TheCall is a constant expression.
6162 bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
6164 Expr *Arg = TheCall->getArg(ArgNum);
6165 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
6171 return Diag(TheCall->getBeginLoc(), diag::err_constant_integer_arg_type)
6178 /// TheCall is a constant expression in the range [Low, High].
6179 bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
6186 Expr *Arg = TheCall->getArg(ArgNum);
6191 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
6196 return Diag(TheCall->getBeginLoc(), diag::err_argument_invalid_range)
6201 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
6211 /// TheCall is a constant expression is a multiple of Num..
6212 bool Sema::SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
6217 Expr *Arg = TheCall->getArg(ArgNum);
6222 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
6226 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_multiple)
6232 /// SemaBuiltinConstantArgPower2 - Check if argument ArgNum of TheCall is a
6234 bool Sema::SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum) {
6238 Expr *Arg = TheCall->getArg(ArgNum);
6243 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
6251 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_power_of_2)
6277 /// SemaBuiltinConstantArgShiftedByte - Check if argument ArgNum of TheCall is
6280 bool Sema::SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,
6285 Expr *Arg = TheCall->getArg(ArgNum);
6290 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
6300 return Diag(TheCall->getBeginLoc(), diag::err_argument_not_shifted_byte)
6305 /// TheCall is a constant expression representing either a shifted byte value,
6309 bool Sema::SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall,
6315 Expr *Arg = TheCall->getArg(ArgNum);
6320 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
6332 return Diag(TheCall->getBeginLoc(),
6338 bool Sema::SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall) {
6340 if (checkArgCount(*this, TheCall, 2))
6342 Expr *Arg0 = TheCall->getArg(0);
6343 Expr *Arg1 = TheCall->getArg(1);
6350 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
6352 TheCall->setArg(0, FirstArg.get());
6359 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_must_be_integer)
6363 TheCall->setType(FirstArgType);
6368 if (checkArgCount(*this, TheCall, 2))
6371 Expr *Arg0 = TheCall->getArg(0);
6377 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
6379 TheCall->setArg(0, FirstArg.get());
6382 TheCall->setType(FirstArgType);
6385 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
6389 if (checkArgCount(*this, TheCall, 2))
6391 Expr *Arg0 = TheCall->getArg(0);
6392 Expr *Arg1 = TheCall->getArg(1);
6399 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
6404 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_must_be_integer)
6406 TheCall->setType(Context.IntTy);
6412 if (checkArgCount(*this, TheCall, 1))
6414 Expr *Arg0 = TheCall->getArg(0);
6421 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
6423 TheCall->setArg(0, FirstArg.get());
6427 TheCall->setType(FirstArgType);
6432 Expr *ArgA = TheCall->getArg(0);
6433 Expr *ArgB = TheCall->getArg(1);
6450 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
6454 return Diag(TheCall->getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
6465 return Diag(TheCall->getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
6473 return Diag(TheCall->getBeginLoc(), diag::err_memtag_any2arg_pointer)
6482 TheCall->setArg(0, ArgExprA.get());
6483 TheCall->setArg(1, ArgExprB.get());
6484 TheCall->setType(Context.LongLongTy);
6492 /// TheCall is an ARM/AArch64 special register string literal.
6493 bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
6511 Expr *Arg = TheCall->getArg(ArgNum);
6517 return Diag(TheCall->getBeginLoc(), diag::err_expr_not_string_literal)
6526 return Diag(TheCall->getBeginLoc(), diag::err_arm_invalid_specialreg)
6568 return Diag(TheCall->getBeginLoc(), diag::err_arm_invalid_specialreg)
6577 if (TheCall->getNumArgs() != 2)
6585 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
6594 bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
6596 return Diag(TheCall->getBeginLoc(), diag::err_builtin_longjmp_unsupported)
6597 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
6599 Expr *Arg = TheCall->getArg(1);
6603 if (SemaBuiltinConstantArg(TheCall, 1, Result))
6607 return Diag(TheCall->getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
6615 bool Sema::SemaBuiltinSetjmp(CallExpr *TheCall) {
6617 return Diag(TheCall->getBeginLoc(), diag::err_builtin_setjmp_unsupported)
6618 << SourceRange(TheCall->getBeginLoc(), TheCall->getEndLoc());
11277 static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
11279 unsigned NumArgs = TheCall->getNumArgs();
11281 Expr *CurrA = TheCall->getArg(i);
11286 IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
11288 IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));
15333 ExprResult Sema::SemaBuiltinMatrixTranspose(CallExpr *TheCall,
15335 if (checkArgCount(*this, TheCall, 1))
15338 ExprResult MatrixArg = DefaultLvalueConversion(TheCall->getArg(0));
15355 TheCall->setType(ResultType);
15358 TheCall->setArg(0, Matrix);
15381 ExprResult Sema::SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
15384 Diag(TheCall->getBeginLoc(), diag::err_builtin_matrix_disabled);
15388 if (checkArgCount(*this, TheCall, 4))
15392 Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
15393 Expr *RowsExpr = TheCall->getArg(1);
15394 Expr *ColumnsExpr = TheCall->getArg(2);
15395 Expr *StrideExpr = TheCall->getArg(3);
15405 TheCall->setArg(0, PtrExpr);
15407 TheCall->setType(Context.DependentTy);
15408 return TheCall;
15441 TheCall->setArg(1, RowsExpr);
15448 TheCall->setArg(2, ColumnsExpr);
15456 TheCall->setType(Context.DependentTy);
15474 TheCall->setArg(3, StrideExpr);
15489 TheCall->setType(
15494 ExprResult Sema::SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
15496 if (checkArgCount(*this, TheCall, 3))
15500 Expr *MatrixExpr = TheCall->getArg(0);
15501 Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
15502 Expr *StrideExpr = TheCall->getArg(2);
15511 TheCall->setArg(0, MatrixExpr);
15514 TheCall->setType(Context.DependentTy);
15515 return TheCall;
15529 TheCall->setArg(1, PtrExpr);
15531 TheCall->setType(Context.DependentTy);
15532 return TheCall;
15569 TheCall->setArg(2, StrideExpr);