65#include "llvm/ADT/APFloat.h"
66#include "llvm/ADT/APInt.h"
67#include "llvm/ADT/APSInt.h"
68#include "llvm/ADT/ArrayRef.h"
69#include "llvm/ADT/DenseMap.h"
70#include "llvm/ADT/FoldingSet.h"
71#include "llvm/ADT/STLExtras.h"
72#include "llvm/ADT/SmallBitVector.h"
73#include "llvm/ADT/SmallPtrSet.h"
74#include "llvm/ADT/SmallString.h"
75#include "llvm/ADT/SmallVector.h"
76#include "llvm/ADT/StringExtras.h"
77#include "llvm/ADT/StringRef.h"
78#include "llvm/ADT/StringSet.h"
79#include "llvm/ADT/StringSwitch.h"
80#include "llvm/Support/AtomicOrdering.h"
81#include "llvm/Support/Casting.h"
82#include "llvm/Support/Compiler.h"
83#include "llvm/Support/ConvertUTF.h"
84#include "llvm/Support/ErrorHandling.h"
85#include "llvm/Support/Format.h"
86#include "llvm/Support/Locale.h"
87#include "llvm/Support/MathExtras.h"
88#include "llvm/Support/SaveAndRestore.h"
89#include "llvm/Support/raw_ostream.h"
90#include "llvm/TargetParser/RISCVTargetParser.h"
91#include "llvm/TargetParser/Triple.h"
105using namespace clang;
109 unsigned ByteNo)
const {
123 unsigned MinArgCount) {
124 unsigned ArgCount =
Call->getNumArgs();
125 if (ArgCount >= MinArgCount)
128 return S.
Diag(
Call->getEndLoc(), diag::err_typecheck_call_too_few_args)
129 << 0 << MinArgCount << ArgCount
130 << 0 <<
Call->getSourceRange();
137 unsigned ArgCount =
Call->getNumArgs();
138 if (ArgCount <= MaxArgCount)
141 diag::err_typecheck_call_too_many_args_at_most)
142 << 0 << MaxArgCount << ArgCount
143 << 0 <<
Call->getSourceRange();
150 unsigned MaxArgCount) {
158 unsigned ArgCount =
Call->getNumArgs();
159 if (ArgCount == DesiredArgCount)
164 assert(ArgCount > DesiredArgCount &&
"should have diagnosed this");
168 Call->getArg(ArgCount - 1)->getEndLoc());
170 return S.
Diag(Range.getBegin(), diag::err_typecheck_call_too_many_args)
171 << 0 << DesiredArgCount << ArgCount
172 << 0 <<
Call->getArg(1)->getSourceRange();
176 if (
Value->isTypeDependent())
207 if (!Literal || !Literal->isOrdinary()) {
220 S.
Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
228 auto *Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
229 if (!Literal || !Literal->isWide()) {
230 S.
Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
231 << Arg->getSourceRange();
265 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(
296 bool IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;
298 auto IsValidIntegerType = [](
QualType Ty) {
299 return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
306 if ((!SrcTy->
isPointerType() && !IsValidIntegerType(SrcTy)) ||
310 S.
Diag(Source->
getExprLoc(), diag::err_typecheck_expect_scalar_operand)
316 if (!IsValidIntegerType(AlignOp->
getType())) {
327 llvm::APSInt AlignValue = AlignResult.
Val.
getInt();
328 llvm::APSInt MaxValue(
329 llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
330 if (AlignValue < 1) {
331 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_too_small) << 1;
334 if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
339 if (!AlignValue.isPowerOf2()) {
340 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_not_power_of_two);
343 if (AlignValue == 1) {
344 S.
Diag(AlignOp->
getExprLoc(), diag::warn_alignment_builtin_useless)
345 << IsBooleanAlignBuiltin;
373 std::pair<unsigned, const char *> Builtins[] = {
374 { Builtin::BI__builtin_add_overflow,
"ckd_add" },
375 { Builtin::BI__builtin_sub_overflow,
"ckd_sub" },
376 { Builtin::BI__builtin_mul_overflow,
"ckd_mul" },
379 bool CkdOperation = llvm::any_of(Builtins, [&](
const std::pair<
unsigned,
381 return BuiltinID ==
P.first && TheCall->
getExprLoc().isMacroID() &&
386 auto ValidCkdIntType = [](
QualType QT) {
389 if (
const auto *BT = QT.getCanonicalType()->getAs<
BuiltinType>())
390 return (BT->getKind() >= BuiltinType::Short &&
391 BT->getKind() <= BuiltinType::Int128) || (
392 BT->getKind() >= BuiltinType::UShort &&
393 BT->getKind() <= BuiltinType::UInt128) ||
394 BT->getKind() == BuiltinType::UChar ||
395 BT->getKind() == BuiltinType::SChar;
400 for (
unsigned I = 0; I < 2; ++I) {
406 bool IsValid = CkdOperation ? ValidCkdIntType(Ty) : Ty->
isIntegerType();
425 !PtrTy->getPointeeType()->isIntegerType() ||
426 (!ValidCkdIntType(PtrTy->getPointeeType()) && CkdOperation) ||
427 PtrTy->getPointeeType().isConstQualified()) {
429 diag::err_overflow_builtin_must_be_ptr_int)
437 if (BuiltinID == Builtin::BI__builtin_mul_overflow) {
438 for (
unsigned I = 0; I < 3; ++I) {
439 const auto Arg = TheCall->
getArg(I);
442 if (Ty->isBitIntType() && Ty->isSignedIntegerType() &&
444 return S.
Diag(Arg->getBeginLoc(),
445 diag::err_overflow_builtin_bit_int_max_size)
454struct BuiltinDumpStructGenerator {
463 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
464 Policy(S.Context.getPrintingPolicy()) {
468 Expr *makeOpaqueValueExpr(
Expr *Inner) {
471 Inner->getObjectKind(), Inner);
472 Actions.push_back(OVE);
476 Expr *getStringLiteral(llvm::StringRef Str) {
482 bool callPrintFunction(llvm::StringRef Format,
486 Args.reserve((TheCall->
getNumArgs() - 2) + 1 + Exprs.size());
488 Args.push_back(getStringLiteral(Format));
489 Args.insert(Args.end(), Exprs.begin(), Exprs.end());
505 Actions.push_back(RealCall.
get());
511 Expr *getIndentString(
unsigned Depth) {
517 return getStringLiteral(Indent);
521 return getStringLiteral(
T.getAsString(Policy));
525 llvm::raw_svector_ostream OS(Str);
530 switch (BT->getKind()) {
531 case BuiltinType::Bool:
534 case BuiltinType::Char_U:
535 case BuiltinType::UChar:
538 case BuiltinType::Char_S:
539 case BuiltinType::SChar:
551 analyze_printf::PrintfConversionSpecifier::sArg) {
577 bool dumpUnnamedRecord(
const RecordDecl *RD,
Expr *E,
unsigned Depth) {
578 Expr *IndentLit = getIndentString(Depth);
580 if (IndentLit ? callPrintFunction(
"%s%s", {IndentLit, TypeLit})
581 : callPrintFunction(
"%s", {TypeLit}))
584 return dumpRecordValue(RD, E, IndentLit, Depth);
597 Expr *RecordArg = makeOpaqueValueExpr(E);
600 if (callPrintFunction(
" {\n"))
604 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
605 for (
const auto &
Base : CXXRD->bases()) {
613 dumpUnnamedRecord(
Base.getType()->getAsRecordDecl(), BasePtr.
get(),
619 Expr *FieldIndentArg = getIndentString(Depth + 1);
622 for (
auto *D : RD->
decls()) {
623 auto *IFD = dyn_cast<IndirectFieldDecl>(D);
624 auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
625 if (!FD || FD->isUnnamedBitField() || FD->isAnonymousStructOrUnion())
631 getStringLiteral(FD->getName())};
633 if (FD->isBitField()) {
637 FD->getBitWidthValue(S.
Context));
651 if (
Field.isInvalid())
654 auto *InnerRD = FD->getType()->getAsRecordDecl();
655 auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
656 if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
658 if (callPrintFunction(Format, Args) ||
659 dumpRecordValue(InnerRD,
Field.get(), FieldIndentArg, Depth + 1))
663 if (appendFormatSpecifier(FD->getType(), Format)) {
665 Args.push_back(
Field.get());
675 Args.push_back(FieldAddr.
get());
678 if (callPrintFunction(Format, Args))
683 return RecordIndent ? callPrintFunction(
"%s}\n", RecordIndent)
684 : callPrintFunction(
"}\n");
687 Expr *buildWrapper() {
690 TheCall->
setType(Wrapper->getType());
711 diag::err_expected_struct_pointer_argument)
720 diag::err_incomplete_type))
729 switch (BT ? BT->getKind() : BuiltinType::Void) {
730 case BuiltinType::Dependent:
731 case BuiltinType::Overload:
732 case BuiltinType::BoundMember:
733 case BuiltinType::PseudoObject:
734 case BuiltinType::UnknownAny:
735 case BuiltinType::BuiltinFn:
741 diag::err_expected_callable_argument)
747 BuiltinDumpStructGenerator Generator(S, TheCall);
753 Expr *PtrArg = PtrArgResult.
get();
757 if (Generator.dumpUnnamedRecord(RD, PtrArg, 0))
760 return Generator.buildWrapper();
772 if (
Call->getStmtClass() != Stmt::CallExprClass) {
773 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)
774 <<
Call->getSourceRange();
778 auto CE = cast<CallExpr>(
Call);
779 if (CE->getCallee()->getType()->isBlockPointerType()) {
780 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)
781 <<
Call->getSourceRange();
785 const Decl *TargetDecl = CE->getCalleeDecl();
786 if (
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
787 if (FD->getBuiltinID()) {
788 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)
789 <<
Call->getSourceRange();
793 if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {
794 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)
795 <<
Call->getSourceRange();
803 S.
Diag(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)
817 BuiltinCall->
setType(CE->getType());
821 BuiltinCall->
setArg(1, ChainResult.
get());
828class ScanfDiagnosticFormatHandler
832 using ComputeSizeFunction =
833 llvm::function_ref<std::optional<llvm::APSInt>(
unsigned)>;
837 using DiagnoseFunction =
838 llvm::function_ref<void(
unsigned,
unsigned,
unsigned)>;
840 ComputeSizeFunction ComputeSizeArgument;
841 DiagnoseFunction Diagnose;
844 ScanfDiagnosticFormatHandler(ComputeSizeFunction ComputeSizeArgument,
845 DiagnoseFunction Diagnose)
846 : ComputeSizeArgument(ComputeSizeArgument), Diagnose(Diagnose) {}
849 const char *StartSpecifier,
850 unsigned specifierLen)
override {
851 if (!FS.consumesDataArgument())
854 unsigned NulByte = 0;
855 switch ((FS.getConversionSpecifier().getKind())) {
868 analyze_format_string::OptionalAmount::HowSpecified::Constant)
873 std::optional<llvm::APSInt> DestSizeAPS =
874 ComputeSizeArgument(FS.getArgIndex());
878 unsigned DestSize = DestSizeAPS->getZExtValue();
880 if (DestSize < SourceSize)
881 Diagnose(FS.getArgIndex(), DestSize, SourceSize);
887class EstimateSizeFormatHandler
892 bool IsKernelCompatible =
true;
895 EstimateSizeFormatHandler(StringRef Format)
896 :
Size(
std::
min(Format.find(0), Format.size()) +
900 const char *,
unsigned SpecifierLen,
903 const size_t FieldWidth = computeFieldWidth(FS);
904 const size_t Precision = computePrecision(FS);
907 switch (FS.getConversionSpecifier().getKind()) {
911 Size += std::max(FieldWidth, (
size_t)1);
923 Size += std::max(FieldWidth, Precision);
939 Size += std::max(FieldWidth, 1 +
940 (Precision ? 1 + Precision
950 (Precision ? 1 + Precision : 0) +
960 (Precision ? 1 + Precision : 0) +
975 IsKernelCompatible =
false;
976 Size += std::max(FieldWidth, 2 + Precision);
988 Size += FS.hasPlusPrefix() || FS.hasSpacePrefix();
990 if (FS.hasAlternativeForm()) {
991 switch (FS.getConversionSpecifier().getKind()) {
1020 Size += (Precision ? 0 : 1);
1027 assert(SpecifierLen <= Size &&
"no underflow");
1028 Size -= SpecifierLen;
1032 size_t getSizeLowerBound()
const {
return Size; }
1033 bool isKernelCompatible()
const {
return IsKernelCompatible; }
1038 size_t FieldWidth = 0;
1046 size_t Precision = 0;
1051 switch (FS.getConversionSpecifier().getKind()) {
1093 StringRef &FormatStrRef,
size_t &StrLen,
1095 if (
const auto *Format = dyn_cast<StringLiteral>(FormatExpr);
1096 Format && (Format->isOrdinary() || Format->isUTF8())) {
1097 FormatStrRef = Format->getString();
1100 assert(
T &&
"String literal not of constant array type!");
1101 size_t TypeSize =
T->getZExtSize();
1103 StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, FormatStrRef.find(0));
1109void Sema::checkFortifiedBuiltinMemoryFunction(
FunctionDecl *FD,
1115 bool UseDABAttr =
false;
1118 const auto *DABAttr = FD->
getAttr<DiagnoseAsBuiltinAttr>();
1120 UseDecl = DABAttr->getFunction();
1121 assert(UseDecl &&
"Missing FunctionDecl in DiagnoseAsBuiltin attribute!");
1133 auto TranslateIndex = [&](
unsigned Index) -> std::optional<unsigned> {
1140 unsigned DABIndices = DABAttr->argIndices_size();
1141 unsigned NewIndex = Index < DABIndices
1142 ? DABAttr->argIndices_begin()[Index]
1145 return std::nullopt;
1149 auto ComputeExplicitObjectSizeArgument =
1150 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1151 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1153 return std::nullopt;
1154 unsigned NewIndex = *IndexOptional;
1158 return std::nullopt;
1164 auto ComputeSizeArgument =
1165 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1171 if (Index < FD->getNumParams()) {
1172 if (
const auto *POS =
1174 BOSType = POS->getType();
1177 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1179 return std::nullopt;
1180 unsigned NewIndex = *IndexOptional;
1183 return std::nullopt;
1185 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1188 return std::nullopt;
1191 return llvm::APSInt::getUnsigned(
Result).extOrTrunc(SizeTypeWidth);
1194 auto ComputeStrLenArgument =
1195 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1196 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1198 return std::nullopt;
1199 unsigned NewIndex = *IndexOptional;
1201 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1204 return std::nullopt;
1206 return llvm::APSInt::getUnsigned(
Result + 1).extOrTrunc(SizeTypeWidth);
1209 std::optional<llvm::APSInt> SourceSize;
1210 std::optional<llvm::APSInt> DestinationSize;
1211 unsigned DiagID = 0;
1212 bool IsChkVariant =
false;
1214 auto GetFunctionName = [&]() {
1220 FunctionName = FunctionName.drop_front(std::strlen(
"__builtin___"));
1221 FunctionName = FunctionName.drop_back(std::strlen(
"_chk"));
1223 FunctionName.consume_front(
"__builtin_");
1225 return FunctionName;
1228 switch (BuiltinID) {
1231 case Builtin::BI__builtin_strcpy:
1232 case Builtin::BIstrcpy: {
1233 DiagID = diag::warn_fortify_strlen_overflow;
1234 SourceSize = ComputeStrLenArgument(1);
1235 DestinationSize = ComputeSizeArgument(0);
1239 case Builtin::BI__builtin___strcpy_chk: {
1240 DiagID = diag::warn_fortify_strlen_overflow;
1241 SourceSize = ComputeStrLenArgument(1);
1242 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1243 IsChkVariant =
true;
1247 case Builtin::BIscanf:
1248 case Builtin::BIfscanf:
1249 case Builtin::BIsscanf: {
1250 unsigned FormatIndex = 1;
1251 unsigned DataIndex = 2;
1252 if (BuiltinID == Builtin::BIscanf) {
1257 const auto *FormatExpr =
1260 StringRef FormatStrRef;
1265 auto Diagnose = [&](
unsigned ArgIndex,
unsigned DestSize,
1266 unsigned SourceSize) {
1267 DiagID = diag::warn_fortify_scanf_overflow;
1268 unsigned Index = ArgIndex + DataIndex;
1269 StringRef FunctionName = GetFunctionName();
1271 PDiag(DiagID) << FunctionName << (Index + 1)
1272 << DestSize << SourceSize);
1275 auto ShiftedComputeSizeArgument = [&](
unsigned Index) {
1276 return ComputeSizeArgument(Index + DataIndex);
1278 ScanfDiagnosticFormatHandler H(ShiftedComputeSizeArgument,
Diagnose);
1279 const char *FormatBytes = FormatStrRef.data();
1290 case Builtin::BIsprintf:
1291 case Builtin::BI__builtin___sprintf_chk: {
1292 size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
1295 StringRef FormatStrRef;
1298 EstimateSizeFormatHandler H(FormatStrRef);
1299 const char *FormatBytes = FormatStrRef.data();
1301 H, FormatBytes, FormatBytes + StrLen,
getLangOpts(),
1303 DiagID = H.isKernelCompatible()
1304 ? diag::warn_format_overflow
1305 : diag::warn_format_overflow_non_kprintf;
1306 SourceSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1307 .extOrTrunc(SizeTypeWidth);
1308 if (BuiltinID == Builtin::BI__builtin___sprintf_chk) {
1309 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1310 IsChkVariant =
true;
1312 DestinationSize = ComputeSizeArgument(0);
1319 case Builtin::BI__builtin___memcpy_chk:
1320 case Builtin::BI__builtin___memmove_chk:
1321 case Builtin::BI__builtin___memset_chk:
1322 case Builtin::BI__builtin___strlcat_chk:
1323 case Builtin::BI__builtin___strlcpy_chk:
1324 case Builtin::BI__builtin___strncat_chk:
1325 case Builtin::BI__builtin___strncpy_chk:
1326 case Builtin::BI__builtin___stpncpy_chk:
1327 case Builtin::BI__builtin___memccpy_chk:
1328 case Builtin::BI__builtin___mempcpy_chk: {
1329 DiagID = diag::warn_builtin_chk_overflow;
1330 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 2);
1332 ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1333 IsChkVariant =
true;
1337 case Builtin::BI__builtin___snprintf_chk:
1338 case Builtin::BI__builtin___vsnprintf_chk: {
1339 DiagID = diag::warn_builtin_chk_overflow;
1340 SourceSize = ComputeExplicitObjectSizeArgument(1);
1341 DestinationSize = ComputeExplicitObjectSizeArgument(3);
1342 IsChkVariant =
true;
1346 case Builtin::BIstrncat:
1347 case Builtin::BI__builtin_strncat:
1348 case Builtin::BIstrncpy:
1349 case Builtin::BI__builtin_strncpy:
1350 case Builtin::BIstpncpy:
1351 case Builtin::BI__builtin_stpncpy: {
1357 DiagID = diag::warn_fortify_source_size_mismatch;
1358 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1359 DestinationSize = ComputeSizeArgument(0);
1363 case Builtin::BImemcpy:
1364 case Builtin::BI__builtin_memcpy:
1365 case Builtin::BImemmove:
1366 case Builtin::BI__builtin_memmove:
1367 case Builtin::BImemset:
1368 case Builtin::BI__builtin_memset:
1369 case Builtin::BImempcpy:
1370 case Builtin::BI__builtin_mempcpy: {
1371 DiagID = diag::warn_fortify_source_overflow;
1372 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1373 DestinationSize = ComputeSizeArgument(0);
1376 case Builtin::BIsnprintf:
1377 case Builtin::BI__builtin_snprintf:
1378 case Builtin::BIvsnprintf:
1379 case Builtin::BI__builtin_vsnprintf: {
1380 DiagID = diag::warn_fortify_source_size_mismatch;
1381 SourceSize = ComputeExplicitObjectSizeArgument(1);
1383 StringRef FormatStrRef;
1387 EstimateSizeFormatHandler H(FormatStrRef);
1388 const char *FormatBytes = FormatStrRef.data();
1390 H, FormatBytes, FormatBytes + StrLen,
getLangOpts(),
1392 llvm::APSInt FormatSize =
1393 llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1394 .extOrTrunc(SizeTypeWidth);
1395 if (FormatSize > *SourceSize && *SourceSize != 0) {
1396 unsigned TruncationDiagID =
1397 H.isKernelCompatible() ? diag::warn_format_truncation
1398 : diag::warn_format_truncation_non_kprintf;
1401 SourceSize->toString(SpecifiedSizeStr, 10);
1402 FormatSize.toString(FormatSizeStr, 10);
1404 PDiag(TruncationDiagID)
1405 << GetFunctionName() << SpecifiedSizeStr
1410 DestinationSize = ComputeSizeArgument(0);
1414 if (!SourceSize || !DestinationSize ||
1415 llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)
1418 StringRef FunctionName = GetFunctionName();
1422 DestinationSize->toString(DestinationStr, 10);
1423 SourceSize->toString(SourceStr, 10);
1426 << FunctionName << DestinationStr << SourceStr);
1439 while (S && !S->isSEHExceptScope())
1441 if (!S || !(S->getFlags() & NeededScopeFlags)) {
1444 << DRE->getDecl()->getIdentifier();
1462 unsigned ArgCounter = 0;
1463 bool IllegalParams =
false;
1467 I != E; ++I, ++ArgCounter) {
1468 if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
1469 (*I)->getPointeeType().getQualifiers().getAddressSpace() !=
1475 if (isa<BlockExpr>(BlockArg)) {
1476 BlockDecl *BD = cast<BlockExpr>(BlockArg)->getBlockDecl();
1478 }
else if (isa<DeclRefExpr>(BlockArg)) {
1479 ErrorLoc = cast<DeclRefExpr>(BlockArg)->getBeginLoc();
1482 diag::err_opencl_enqueue_kernel_blocks_non_local_void_args);
1483 IllegalParams =
true;
1487 return IllegalParams;
1497 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_requires_extension)
1498 << 1 <<
Call->getDirectCallee()
1499 <<
"cl_khr_subgroups or __opencl_c_subgroups";
1515 S.
Diag(NDRangeArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1522 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1538 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1550 unsigned Start,
unsigned End) {
1551 bool IllegalParams =
false;
1552 for (
unsigned I = Start; I <= End; ++I)
1555 return IllegalParams;
1562 unsigned NumNonVarArgs) {
1565 unsigned NumBlockParams =
1567 unsigned TotalNumArgs = TheCall->
getNumArgs();
1571 if (TotalNumArgs != NumBlockParams + NumNonVarArgs) {
1573 diag::err_opencl_enqueue_kernel_local_size_args);
1613 diag::err_typecheck_call_too_few_args_at_least)
1614 << 0 << 4 << NumArgs << 0;
1626 diag::err_opencl_builtin_expected_type)
1634 diag::err_opencl_builtin_expected_type)
1635 << TheCall->
getDirectCallee() <<
"'kernel_enqueue_flags_t' (i.e. uint)";
1642 diag::err_opencl_builtin_expected_type)
1661 diag::err_opencl_enqueue_kernel_blocks_no_args);
1685 diag::err_opencl_builtin_expected_type)
1698 diag::err_opencl_builtin_expected_type)
1710 diag::err_opencl_builtin_expected_type)
1724 diag::err_opencl_enqueue_kernel_incorrect_args);
1730 return D->
getAttr<OpenCLAccessAttr>();
1735 const Expr *Arg0 =
Call->getArg(0);
1738 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1742 OpenCLAccessAttr *AccessQual =
1748 switch (
Call->getDirectCallee()->getBuiltinID()) {
1749 case Builtin::BIread_pipe:
1750 case Builtin::BIreserve_read_pipe:
1751 case Builtin::BIcommit_read_pipe:
1752 case Builtin::BIwork_group_reserve_read_pipe:
1753 case Builtin::BIsub_group_reserve_read_pipe:
1754 case Builtin::BIwork_group_commit_read_pipe:
1755 case Builtin::BIsub_group_commit_read_pipe:
1756 if (!(!AccessQual || AccessQual->isReadOnly())) {
1758 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1763 case Builtin::BIwrite_pipe:
1764 case Builtin::BIreserve_write_pipe:
1765 case Builtin::BIcommit_write_pipe:
1766 case Builtin::BIwork_group_reserve_write_pipe:
1767 case Builtin::BIsub_group_reserve_write_pipe:
1768 case Builtin::BIwork_group_commit_write_pipe:
1769 case Builtin::BIsub_group_commit_write_pipe:
1770 if (!(AccessQual && AccessQual->isWriteOnly())) {
1772 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1785 const Expr *Arg0 =
Call->getArg(0);
1786 const Expr *ArgIdx =
Call->getArg(Idx);
1795 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1810 switch (
Call->getNumArgs()) {
1827 if (!
Call->getArg(1)->getType()->isReserveIDT()) {
1828 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1830 <<
Call->getArg(1)->getType() <<
Call->getArg(1)->getSourceRange();
1835 const Expr *Arg2 =
Call->getArg(2);
1838 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1849 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_arg_num)
1850 <<
Call->getDirectCallee() <<
Call->getSourceRange();
1870 if (!
Call->getArg(1)->getType()->isIntegerType() &&
1871 !
Call->getArg(1)->getType()->isUnsignedIntegerType()) {
1872 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1874 <<
Call->getArg(1)->getType() <<
Call->getArg(1)->getSourceRange();
1899 if (!
Call->getArg(1)->getType()->isReserveIDT()) {
1900 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1902 <<
Call->getArg(1)->getType() <<
Call->getArg(1)->getSourceRange();
1918 if (!
Call->getArg(0)->getType()->isPipeType()) {
1919 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1920 <<
Call->getDirectCallee() <<
Call->getArg(0)->getSourceRange();
1937 auto RT =
Call->getArg(0)->getType();
1938 if (!RT->isPointerType() || RT->getPointeeType()
1940 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_to_addr_invalid_arg)
1941 <<
Call->getArg(0) <<
Call->getDirectCallee() <<
Call->getSourceRange();
1946 S.
Diag(
Call->getArg(0)->getBeginLoc(),
1947 diag::warn_opencl_generic_address_space_arg)
1948 <<
Call->getDirectCallee()->getNameInfo().getAsString()
1949 <<
Call->getArg(0)->getSourceRange();
1952 RT = RT->getPointeeType();
1953 auto Qual = RT.getQualifiers();
1954 switch (BuiltinID) {
1955 case Builtin::BIto_global:
1958 case Builtin::BIto_local:
1961 case Builtin::BIto_private:
1965 llvm_unreachable(
"Invalid builtin function");
1968 RT.getUnqualifiedType(), Qual)));
1974enum PointerAuthOpKind {
2019 llvm::raw_svector_ostream Str(
Value);
2028 Result = KeyValue->getZExtValue();
2033 PointerAuthOpKind OpKind) {
2041 auto AllowsPointer = [](PointerAuthOpKind OpKind) {
2042 return OpKind != PAO_BlendInteger;
2044 auto AllowsInteger = [](PointerAuthOpKind OpKind) {
2045 return OpKind == PAO_Discriminator || OpKind == PAO_BlendInteger ||
2046 OpKind == PAO_SignGeneric;
2055 }
else if (AllowsInteger(OpKind) &&
2062 <<
unsigned(OpKind == PAO_Discriminator ? 1
2063 : OpKind == PAO_BlendPointer ? 2
2064 : OpKind == PAO_BlendInteger ? 3
2066 <<
unsigned(AllowsInteger(OpKind) ? (AllowsPointer(OpKind) ? 2 : 1) : 0)
2077 if ((OpKind == PAO_Sign || OpKind == PAO_Auth) &&
2080 ? diag::warn_ptrauth_sign_null_pointer
2081 : diag::warn_ptrauth_auth_null_pointer)
2097 Call->setType(
Call->getArgs()[0]->getType());
2128 PointerAuthOpKind OpKind) {
2138 Call->setType(
Call->getArgs()[0]->getType());
2154 Call->setType(
Call->getArgs()[0]->getType());
2179 auto DiagSelect = [&]() -> std::optional<unsigned> {
2186 return std::optional<unsigned>{};
2201 diag::err_incomplete_type))
2205 "Unhandled non-object pointer case");
2223 llvm::Triple::ObjectFormatType CurObjFormat =
2225 if (llvm::is_contained(UnsupportedObjectFormatTypes, CurObjFormat)) {
2238 llvm::Triple::ArchType CurArch =
2240 if (llvm::is_contained(SupportedArchs, CurArch))
2250bool Sema::CheckTSBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
2257 case llvm::Triple::arm:
2258 case llvm::Triple::armeb:
2259 case llvm::Triple::thumb:
2260 case llvm::Triple::thumbeb:
2261 return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
2262 case llvm::Triple::aarch64:
2263 case llvm::Triple::aarch64_32:
2264 case llvm::Triple::aarch64_be:
2265 return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
2266 case llvm::Triple::bpfeb:
2267 case llvm::Triple::bpfel:
2268 return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
2269 case llvm::Triple::hexagon:
2270 return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
2271 case llvm::Triple::mips:
2272 case llvm::Triple::mipsel:
2273 case llvm::Triple::mips64:
2274 case llvm::Triple::mips64el:
2275 return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
2276 case llvm::Triple::systemz:
2277 return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
2278 case llvm::Triple::x86:
2279 case llvm::Triple::x86_64:
2280 return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
2281 case llvm::Triple::ppc:
2282 case llvm::Triple::ppcle:
2283 case llvm::Triple::ppc64:
2284 case llvm::Triple::ppc64le:
2285 return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
2286 case llvm::Triple::amdgcn:
2287 return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
2288 case llvm::Triple::riscv32:
2289 case llvm::Triple::riscv64:
2290 return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
2291 case llvm::Triple::loongarch32:
2292 case llvm::Triple::loongarch64:
2293 return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
2294 case llvm::Triple::wasm32:
2295 case llvm::Triple::wasm64:
2296 return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
2297 case llvm::Triple::nvptx:
2298 case llvm::Triple::nvptx64:
2299 return CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
2310 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2311 << ArgIndex << 0 << ArgTy;
2321 EltTy = VecTy->getElementType();
2324 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2325 << ArgIndex << 5 << ArgTy;
2335 const TargetInfo *AuxTI,
unsigned BuiltinID) {
2336 assert((BuiltinID == Builtin::BI__builtin_cpu_supports ||
2337 BuiltinID == Builtin::BI__builtin_cpu_is) &&
2338 "Expecting __builtin_cpu_...");
2340 bool IsCPUSupports = BuiltinID == Builtin::BI__builtin_cpu_supports;
2342 auto SupportsBI = [=](
const TargetInfo *TInfo) {
2343 return TInfo && ((IsCPUSupports && TInfo->supportsCpuSupports()) ||
2344 (!IsCPUSupports && TInfo->supportsCpuIs()));
2346 if (!SupportsBI(&TI) && SupportsBI(AuxTI))
2350 return S.
Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
2355 ? diag::err_builtin_aix_os_unsupported
2356 : diag::err_builtin_target_unsupported)
2361 if (!isa<StringLiteral>(Arg))
2362 return S.
Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
2366 StringRef Feature = cast<StringLiteral>(Arg)->getString();
2413 TheCall->
setArg(0, Arg0);
2419 << 1 << 7 << Arg0Ty;
2429 TheCall->
setArg(1, Arg1);
2435 << 2 << 8 << Arg1Ty;
2444Sema::CheckBuiltinFunctionCall(
FunctionDecl *FDecl,
unsigned BuiltinID,
2449 unsigned ICEArguments = 0;
2456 for (
unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
2458 if ((ICEArguments & (1 << ArgNo)) == 0)
continue;
2463 if (ArgNo < TheCall->getNumArgs() &&
2464 BuiltinConstantArg(TheCall, ArgNo,
Result))
2466 ICEArguments &= ~(1 << ArgNo);
2470 switch (BuiltinID) {
2471 case Builtin::BI__builtin_cpu_supports:
2472 case Builtin::BI__builtin_cpu_is:
2477 case Builtin::BI__builtin_cpu_init:
2484 case Builtin::BI__builtin___CFStringMakeConstantString:
2488 *
this, BuiltinID, TheCall,
2489 {llvm::Triple::GOFF, llvm::Triple::XCOFF}))
2492 "Wrong # arguments to builtin CFStringMakeConstantString");
2493 if (CheckObjCString(TheCall->
getArg(0)))
2496 case Builtin::BI__builtin_ms_va_start:
2497 case Builtin::BI__builtin_stdarg_start:
2498 case Builtin::BI__builtin_va_start:
2499 if (BuiltinVAStart(BuiltinID, TheCall))
2502 case Builtin::BI__va_start: {
2504 case llvm::Triple::aarch64:
2505 case llvm::Triple::arm:
2506 case llvm::Triple::thumb:
2507 if (BuiltinVAStartARMMicrosoft(TheCall))
2511 if (BuiltinVAStart(BuiltinID, TheCall))
2519 case Builtin::BI_interlockedbittestandset_acq:
2520 case Builtin::BI_interlockedbittestandset_rel:
2521 case Builtin::BI_interlockedbittestandset_nf:
2522 case Builtin::BI_interlockedbittestandreset_acq:
2523 case Builtin::BI_interlockedbittestandreset_rel:
2524 case Builtin::BI_interlockedbittestandreset_nf:
2526 *
this, BuiltinID, TheCall,
2527 {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
2532 case Builtin::BI_bittest64:
2533 case Builtin::BI_bittestandcomplement64:
2534 case Builtin::BI_bittestandreset64:
2535 case Builtin::BI_bittestandset64:
2536 case Builtin::BI_interlockedbittestandreset64:
2537 case Builtin::BI_interlockedbittestandset64:
2539 {llvm::Triple::x86_64, llvm::Triple::arm,
2540 llvm::Triple::thumb,
2541 llvm::Triple::aarch64}))
2545 case Builtin::BI__builtin_set_flt_rounds:
2547 {llvm::Triple::x86, llvm::Triple::x86_64,
2548 llvm::Triple::arm, llvm::Triple::thumb,
2549 llvm::Triple::aarch64}))
2553 case Builtin::BI__builtin_isgreater:
2554 case Builtin::BI__builtin_isgreaterequal:
2555 case Builtin::BI__builtin_isless:
2556 case Builtin::BI__builtin_islessequal:
2557 case Builtin::BI__builtin_islessgreater:
2558 case Builtin::BI__builtin_isunordered:
2559 if (BuiltinUnorderedCompare(TheCall, BuiltinID))
2562 case Builtin::BI__builtin_fpclassify:
2563 if (BuiltinFPClassification(TheCall, 6, BuiltinID))
2566 case Builtin::BI__builtin_isfpclass:
2567 if (BuiltinFPClassification(TheCall, 2, BuiltinID))
2570 case Builtin::BI__builtin_isfinite:
2571 case Builtin::BI__builtin_isinf:
2572 case Builtin::BI__builtin_isinf_sign:
2573 case Builtin::BI__builtin_isnan:
2574 case Builtin::BI__builtin_issignaling:
2575 case Builtin::BI__builtin_isnormal:
2576 case Builtin::BI__builtin_issubnormal:
2577 case Builtin::BI__builtin_iszero:
2578 case Builtin::BI__builtin_signbit:
2579 case Builtin::BI__builtin_signbitf:
2580 case Builtin::BI__builtin_signbitl:
2581 if (BuiltinFPClassification(TheCall, 1, BuiltinID))
2584 case Builtin::BI__builtin_shufflevector:
2588 case Builtin::BI__builtin_prefetch:
2589 if (BuiltinPrefetch(TheCall))
2592 case Builtin::BI__builtin_alloca_with_align:
2593 case Builtin::BI__builtin_alloca_with_align_uninitialized:
2594 if (BuiltinAllocaWithAlign(TheCall))
2597 case Builtin::BI__builtin_alloca:
2598 case Builtin::BI__builtin_alloca_uninitialized:
2602 case Builtin::BI__arithmetic_fence:
2603 if (BuiltinArithmeticFence(TheCall))
2606 case Builtin::BI__assume:
2607 case Builtin::BI__builtin_assume:
2608 if (BuiltinAssume(TheCall))
2611 case Builtin::BI__builtin_assume_aligned:
2612 if (BuiltinAssumeAligned(TheCall))
2615 case Builtin::BI__builtin_dynamic_object_size:
2616 case Builtin::BI__builtin_object_size:
2617 if (BuiltinConstantArgRange(TheCall, 1, 0, 3))
2620 case Builtin::BI__builtin_longjmp:
2621 if (BuiltinLongjmp(TheCall))
2624 case Builtin::BI__builtin_setjmp:
2625 if (BuiltinSetjmp(TheCall))
2628 case Builtin::BI__builtin_classify_type:
2632 case Builtin::BI__builtin_complex:
2633 if (BuiltinComplex(TheCall))
2636 case Builtin::BI__builtin_constant_p: {
2644 case Builtin::BI__builtin_launder:
2646 case Builtin::BI__sync_fetch_and_add:
2647 case Builtin::BI__sync_fetch_and_add_1:
2648 case Builtin::BI__sync_fetch_and_add_2:
2649 case Builtin::BI__sync_fetch_and_add_4:
2650 case Builtin::BI__sync_fetch_and_add_8:
2651 case Builtin::BI__sync_fetch_and_add_16:
2652 case Builtin::BI__sync_fetch_and_sub:
2653 case Builtin::BI__sync_fetch_and_sub_1:
2654 case Builtin::BI__sync_fetch_and_sub_2:
2655 case Builtin::BI__sync_fetch_and_sub_4:
2656 case Builtin::BI__sync_fetch_and_sub_8:
2657 case Builtin::BI__sync_fetch_and_sub_16:
2658 case Builtin::BI__sync_fetch_and_or:
2659 case Builtin::BI__sync_fetch_and_or_1:
2660 case Builtin::BI__sync_fetch_and_or_2:
2661 case Builtin::BI__sync_fetch_and_or_4:
2662 case Builtin::BI__sync_fetch_and_or_8:
2663 case Builtin::BI__sync_fetch_and_or_16:
2664 case Builtin::BI__sync_fetch_and_and:
2665 case Builtin::BI__sync_fetch_and_and_1:
2666 case Builtin::BI__sync_fetch_and_and_2:
2667 case Builtin::BI__sync_fetch_and_and_4:
2668 case Builtin::BI__sync_fetch_and_and_8:
2669 case Builtin::BI__sync_fetch_and_and_16:
2670 case Builtin::BI__sync_fetch_and_xor:
2671 case Builtin::BI__sync_fetch_and_xor_1:
2672 case Builtin::BI__sync_fetch_and_xor_2:
2673 case Builtin::BI__sync_fetch_and_xor_4:
2674 case Builtin::BI__sync_fetch_and_xor_8:
2675 case Builtin::BI__sync_fetch_and_xor_16:
2676 case Builtin::BI__sync_fetch_and_nand:
2677 case Builtin::BI__sync_fetch_and_nand_1:
2678 case Builtin::BI__sync_fetch_and_nand_2:
2679 case Builtin::BI__sync_fetch_and_nand_4:
2680 case Builtin::BI__sync_fetch_and_nand_8:
2681 case Builtin::BI__sync_fetch_and_nand_16:
2682 case Builtin::BI__sync_add_and_fetch:
2683 case Builtin::BI__sync_add_and_fetch_1:
2684 case Builtin::BI__sync_add_and_fetch_2:
2685 case Builtin::BI__sync_add_and_fetch_4:
2686 case Builtin::BI__sync_add_and_fetch_8:
2687 case Builtin::BI__sync_add_and_fetch_16:
2688 case Builtin::BI__sync_sub_and_fetch:
2689 case Builtin::BI__sync_sub_and_fetch_1:
2690 case Builtin::BI__sync_sub_and_fetch_2:
2691 case Builtin::BI__sync_sub_and_fetch_4:
2692 case Builtin::BI__sync_sub_and_fetch_8:
2693 case Builtin::BI__sync_sub_and_fetch_16:
2694 case Builtin::BI__sync_and_and_fetch:
2695 case Builtin::BI__sync_and_and_fetch_1:
2696 case Builtin::BI__sync_and_and_fetch_2:
2697 case Builtin::BI__sync_and_and_fetch_4:
2698 case Builtin::BI__sync_and_and_fetch_8:
2699 case Builtin::BI__sync_and_and_fetch_16:
2700 case Builtin::BI__sync_or_and_fetch:
2701 case Builtin::BI__sync_or_and_fetch_1:
2702 case Builtin::BI__sync_or_and_fetch_2:
2703 case Builtin::BI__sync_or_and_fetch_4:
2704 case Builtin::BI__sync_or_and_fetch_8:
2705 case Builtin::BI__sync_or_and_fetch_16:
2706 case Builtin::BI__sync_xor_and_fetch:
2707 case Builtin::BI__sync_xor_and_fetch_1:
2708 case Builtin::BI__sync_xor_and_fetch_2:
2709 case Builtin::BI__sync_xor_and_fetch_4:
2710 case Builtin::BI__sync_xor_and_fetch_8:
2711 case Builtin::BI__sync_xor_and_fetch_16:
2712 case Builtin::BI__sync_nand_and_fetch:
2713 case Builtin::BI__sync_nand_and_fetch_1:
2714 case Builtin::BI__sync_nand_and_fetch_2:
2715 case Builtin::BI__sync_nand_and_fetch_4:
2716 case Builtin::BI__sync_nand_and_fetch_8:
2717 case Builtin::BI__sync_nand_and_fetch_16:
2718 case Builtin::BI__sync_val_compare_and_swap:
2719 case Builtin::BI__sync_val_compare_and_swap_1:
2720 case Builtin::BI__sync_val_compare_and_swap_2:
2721 case Builtin::BI__sync_val_compare_and_swap_4:
2722 case Builtin::BI__sync_val_compare_and_swap_8:
2723 case Builtin::BI__sync_val_compare_and_swap_16:
2724 case Builtin::BI__sync_bool_compare_and_swap:
2725 case Builtin::BI__sync_bool_compare_and_swap_1:
2726 case Builtin::BI__sync_bool_compare_and_swap_2:
2727 case Builtin::BI__sync_bool_compare_and_swap_4:
2728 case Builtin::BI__sync_bool_compare_and_swap_8:
2729 case Builtin::BI__sync_bool_compare_and_swap_16:
2730 case Builtin::BI__sync_lock_test_and_set:
2731 case Builtin::BI__sync_lock_test_and_set_1:
2732 case Builtin::BI__sync_lock_test_and_set_2:
2733 case Builtin::BI__sync_lock_test_and_set_4:
2734 case Builtin::BI__sync_lock_test_and_set_8:
2735 case Builtin::BI__sync_lock_test_and_set_16:
2736 case Builtin::BI__sync_lock_release:
2737 case Builtin::BI__sync_lock_release_1:
2738 case Builtin::BI__sync_lock_release_2:
2739 case Builtin::BI__sync_lock_release_4:
2740 case Builtin::BI__sync_lock_release_8:
2741 case Builtin::BI__sync_lock_release_16:
2742 case Builtin::BI__sync_swap:
2743 case Builtin::BI__sync_swap_1:
2744 case Builtin::BI__sync_swap_2:
2745 case Builtin::BI__sync_swap_4:
2746 case Builtin::BI__sync_swap_8:
2747 case Builtin::BI__sync_swap_16:
2748 return BuiltinAtomicOverloaded(TheCallResult);
2749 case Builtin::BI__sync_synchronize:
2753 case Builtin::BI__builtin_nontemporal_load:
2754 case Builtin::BI__builtin_nontemporal_store:
2755 return BuiltinNontemporalOverloaded(TheCallResult);
2756 case Builtin::BI__builtin_memcpy_inline: {
2769 case Builtin::BI__builtin_memset_inline: {
2780#define BUILTIN(ID, TYPE, ATTRS)
2781#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
2782 case Builtin::BI##ID: \
2783 return AtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
2784#include "clang/Basic/Builtins.inc"
2785 case Builtin::BI__annotation:
2789 case Builtin::BI__builtin_annotation:
2793 case Builtin::BI__builtin_addressof:
2797 case Builtin::BI__builtin_function_start:
2801 case Builtin::BI__builtin_is_aligned:
2802 case Builtin::BI__builtin_align_up:
2803 case Builtin::BI__builtin_align_down:
2807 case Builtin::BI__builtin_add_overflow:
2808 case Builtin::BI__builtin_sub_overflow:
2809 case Builtin::BI__builtin_mul_overflow:
2813 case Builtin::BI__builtin_operator_new:
2814 case Builtin::BI__builtin_operator_delete: {
2815 bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
2817 BuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
2822 case Builtin::BI__builtin_dump_struct:
2824 case Builtin::BI__builtin_expect_with_probability: {
2835 Diag(ProbArg->
getBeginLoc(), diag::err_probability_not_constant_float)
2842 bool LoseInfo =
false;
2843 Probability.convert(llvm::APFloat::IEEEdouble(),
2844 llvm::RoundingMode::Dynamic, &LoseInfo);
2845 if (!(Probability >= llvm::APFloat(0.0) &&
2846 Probability <= llvm::APFloat(1.0))) {
2853 case Builtin::BI__builtin_preserve_access_index:
2857 case Builtin::BI__builtin_call_with_static_chain:
2861 case Builtin::BI__exception_code:
2862 case Builtin::BI_exception_code:
2864 diag::err_seh___except_block))
2867 case Builtin::BI__exception_info:
2868 case Builtin::BI_exception_info:
2870 diag::err_seh___except_filter))
2873 case Builtin::BI__GetExceptionInfo:
2885 case Builtin::BIaddressof:
2886 case Builtin::BI__addressof:
2887 case Builtin::BIforward:
2888 case Builtin::BIforward_like:
2889 case Builtin::BImove:
2890 case Builtin::BImove_if_noexcept:
2891 case Builtin::BIas_const: {
2899 bool ReturnsPointer = BuiltinID == Builtin::BIaddressof ||
2900 BuiltinID == Builtin::BI__addressof;
2902 (ReturnsPointer ?
Result->isAnyPointerType()
2903 :
Result->isReferenceType()) &&
2905 Result->getPointeeType()))) {
2906 Diag(TheCall->
getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2912 case Builtin::BI__builtin_ptrauth_strip:
2914 case Builtin::BI__builtin_ptrauth_blend_discriminator:
2916 case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
2918 case Builtin::BI__builtin_ptrauth_auth:
2920 case Builtin::BI__builtin_ptrauth_sign_generic_data:
2922 case Builtin::BI__builtin_ptrauth_auth_and_resign:
2925 case Builtin::BIread_pipe:
2926 case Builtin::BIwrite_pipe:
2932 case Builtin::BIreserve_read_pipe:
2933 case Builtin::BIreserve_write_pipe:
2934 case Builtin::BIwork_group_reserve_read_pipe:
2935 case Builtin::BIwork_group_reserve_write_pipe:
2939 case Builtin::BIsub_group_reserve_read_pipe:
2940 case Builtin::BIsub_group_reserve_write_pipe:
2945 case Builtin::BIcommit_read_pipe:
2946 case Builtin::BIcommit_write_pipe:
2947 case Builtin::BIwork_group_commit_read_pipe:
2948 case Builtin::BIwork_group_commit_write_pipe:
2952 case Builtin::BIsub_group_commit_read_pipe:
2953 case Builtin::BIsub_group_commit_write_pipe:
2958 case Builtin::BIget_pipe_num_packets:
2959 case Builtin::BIget_pipe_max_packets:
2963 case Builtin::BIto_global:
2964 case Builtin::BIto_local:
2965 case Builtin::BIto_private:
2970 case Builtin::BIenqueue_kernel:
2974 case Builtin::BIget_kernel_work_group_size:
2975 case Builtin::BIget_kernel_preferred_work_group_size_multiple:
2979 case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
2980 case Builtin::BIget_kernel_sub_group_count_for_ndrange:
2984 case Builtin::BI__builtin_os_log_format:
2987 case Builtin::BI__builtin_os_log_format_buffer_size:
2988 if (BuiltinOSLogFormat(TheCall))
2991 case Builtin::BI__builtin_frame_address:
2992 case Builtin::BI__builtin_return_address: {
2993 if (BuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
3001 Result.Val.getInt() != 0)
3003 << ((BuiltinID == Builtin::BI__builtin_return_address)
3004 ?
"__builtin_return_address"
3005 :
"__builtin_frame_address")
3010 case Builtin::BI__builtin_nondeterministic_value: {
3011 if (BuiltinNonDeterministicValue(TheCall))
3018 case Builtin::BI__builtin_elementwise_abs: {
3019 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3026 EltTy = VecTy->getElementType();
3029 diag::err_builtin_invalid_arg_type)
3038 case Builtin::BI__builtin_elementwise_ceil:
3039 case Builtin::BI__builtin_elementwise_cos:
3040 case Builtin::BI__builtin_elementwise_exp:
3041 case Builtin::BI__builtin_elementwise_exp2:
3042 case Builtin::BI__builtin_elementwise_floor:
3043 case Builtin::BI__builtin_elementwise_log:
3044 case Builtin::BI__builtin_elementwise_log2:
3045 case Builtin::BI__builtin_elementwise_log10:
3046 case Builtin::BI__builtin_elementwise_roundeven:
3047 case Builtin::BI__builtin_elementwise_round:
3048 case Builtin::BI__builtin_elementwise_rint:
3049 case Builtin::BI__builtin_elementwise_nearbyint:
3050 case Builtin::BI__builtin_elementwise_sin:
3051 case Builtin::BI__builtin_elementwise_sqrt:
3052 case Builtin::BI__builtin_elementwise_trunc:
3053 case Builtin::BI__builtin_elementwise_canonicalize: {
3054 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3063 case Builtin::BI__builtin_elementwise_fma: {
3064 if (BuiltinElementwiseTernaryMath(TheCall))
3071 case Builtin::BI__builtin_elementwise_pow: {
3072 if (BuiltinElementwiseMath(TheCall))
3086 case Builtin::BI__builtin_elementwise_add_sat:
3087 case Builtin::BI__builtin_elementwise_sub_sat: {
3088 if (BuiltinElementwiseMath(TheCall))
3096 EltTy = VecTy->getElementType();
3106 case Builtin::BI__builtin_elementwise_min:
3107 case Builtin::BI__builtin_elementwise_max:
3108 if (BuiltinElementwiseMath(TheCall))
3112 case Builtin::BI__builtin_elementwise_bitreverse: {
3113 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3121 EltTy = VecTy->getElementType();
3131 case Builtin::BI__builtin_elementwise_copysign: {
3151 diag::err_typecheck_call_different_arg_types)
3152 << MagnitudeTy << SignTy;
3160 case Builtin::BI__builtin_reduce_max:
3161 case Builtin::BI__builtin_reduce_min: {
3162 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3173 TheCall->
setType(TyA->getElementType());
3179 case Builtin::BI__builtin_reduce_add:
3180 case Builtin::BI__builtin_reduce_mul:
3181 case Builtin::BI__builtin_reduce_xor:
3182 case Builtin::BI__builtin_reduce_or:
3183 case Builtin::BI__builtin_reduce_and: {
3184 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3189 if (!TyA || !TyA->getElementType()->isIntegerType()) {
3194 TheCall->
setType(TyA->getElementType());
3198 case Builtin::BI__builtin_matrix_transpose:
3199 return BuiltinMatrixTranspose(TheCall, TheCallResult);
3201 case Builtin::BI__builtin_matrix_column_major_load:
3202 return BuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
3204 case Builtin::BI__builtin_matrix_column_major_store:
3205 return BuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
3207 case Builtin::BI__builtin_get_device_side_mangled_name: {
3208 auto Check = [](
CallExpr *TheCall) {
3214 auto *D = DRE->getDecl();
3215 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
3217 return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
3218 D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
3220 if (!Check(TheCall)) {
3222 diag::err_hip_invalid_args_builtin_mangled_name);
3227 case Builtin::BI__builtin_popcountg:
3231 case Builtin::BI__builtin_clzg:
3232 case Builtin::BI__builtin_ctzg:
3237 case Builtin::BI__builtin_allow_runtime_check: {
3257 "Aux Target Builtin, but not an aux target?");
3259 if (CheckTSBuiltinFunctionCall(
3270 return TheCallResult;
3274static unsigned RFT(
unsigned t,
bool shift =
false,
bool ForceQuad =
false) {
3276 int IsQuad = ForceQuad ?
true :
Type.isQuad();
3277 switch (
Type.getEltType()) {
3280 return shift ? 7 : (8 << IsQuad) - 1;
3283 return shift ? 15 : (4 << IsQuad) - 1;
3285 return shift ? 31 : (2 << IsQuad) - 1;
3288 return shift ? 63 : (1 << IsQuad) - 1;
3290 return shift ? 127 : (1 << IsQuad) - 1;
3292 assert(!shift &&
"cannot shift float types!");
3293 return (4 << IsQuad) - 1;
3295 assert(!shift &&
"cannot shift float types!");
3296 return (2 << IsQuad) - 1;
3298 assert(!shift &&
"cannot shift float types!");
3299 return (1 << IsQuad) - 1;
3301 assert(!shift &&
"cannot shift float types!");
3302 return (4 << IsQuad) - 1;
3304 llvm_unreachable(
"Invalid NeonTypeFlag!");
3311 bool IsPolyUnsigned,
bool IsInt64Long) {
3345 llvm_unreachable(
"Invalid NeonTypeFlag!");
3369bool Sema::ParseSVEImmChecks(
3372 bool HasError =
false;
3373 for (
auto &I : ImmChecks) {
3374 int ArgNum, CheckTy, ElementSizeInBits;
3375 std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;
3381 auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
3382 int ErrDiag) ->
bool {
3390 if (BuiltinConstantArg(TheCall, ArgNum, Imm))
3393 if (!CheckImm(Imm.getSExtValue()))
3399 case SVETypeFlags::ImmCheck0_31:
3400 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
3403 case SVETypeFlags::ImmCheck0_13:
3404 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
3407 case SVETypeFlags::ImmCheck1_16:
3408 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
3411 case SVETypeFlags::ImmCheck0_7:
3412 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
3415 case SVETypeFlags::ImmCheck1_1:
3416 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 1))
3419 case SVETypeFlags::ImmCheck1_3:
3420 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 3))
3423 case SVETypeFlags::ImmCheck1_7:
3424 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 7))
3427 case SVETypeFlags::ImmCheckExtract:
3428 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3429 (2048 / ElementSizeInBits) - 1))
3432 case SVETypeFlags::ImmCheckShiftRight:
3433 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
3436 case SVETypeFlags::ImmCheckShiftRightNarrow:
3437 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits / 2))
3440 case SVETypeFlags::ImmCheckShiftLeft:
3441 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, ElementSizeInBits - 1))
3444 case SVETypeFlags::ImmCheckLaneIndex:
3445 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3446 (128 / (1 * ElementSizeInBits)) - 1))
3449 case SVETypeFlags::ImmCheckLaneIndexCompRotate:
3450 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3451 (128 / (2 * ElementSizeInBits)) - 1))
3454 case SVETypeFlags::ImmCheckLaneIndexDot:
3455 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3456 (128 / (4 * ElementSizeInBits)) - 1))
3459 case SVETypeFlags::ImmCheckComplexRot90_270:
3460 if (CheckImmediateInSet([](
int64_t V) {
return V == 90 ||
V == 270; },
3461 diag::err_rotation_argument_to_cadd))
3464 case SVETypeFlags::ImmCheckComplexRotAll90:
3465 if (CheckImmediateInSet(
3467 return V == 0 ||
V == 90 ||
V == 180 ||
V == 270;
3469 diag::err_rotation_argument_to_cmla))
3472 case SVETypeFlags::ImmCheck0_1:
3473 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
3476 case SVETypeFlags::ImmCheck0_2:
3477 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
3480 case SVETypeFlags::ImmCheck0_3:
3481 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
3484 case SVETypeFlags::ImmCheck0_0:
3485 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 0))
3488 case SVETypeFlags::ImmCheck0_15:
3489 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 15))
3492 case SVETypeFlags::ImmCheck0_255:
3493 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 255))
3496 case SVETypeFlags::ImmCheck2_4_Mul2:
3497 if (BuiltinConstantArgRange(TheCall, ArgNum, 2, 4) ||
3498 BuiltinConstantArgMultiple(TheCall, ArgNum, 2))
3508 if (FD->
hasAttr<ArmLocallyStreamingAttr>())
3512 if (FPT->getAArch64SMEAttributes() &
3515 if (FPT->getAArch64SMEAttributes() &
3529 llvm::StringMap<bool> CallerFeatureMap;
3538 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3544 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3550 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3559 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZA());
3566 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZT0());
3570 switch (BuiltinID) {
3573#define GET_SME_BUILTIN_GET_STATE
3574#include "clang/Basic/arm_sme_builtins_za_state.inc"
3575#undef GET_SME_BUILTIN_GET_STATE
3579bool Sema::CheckSMEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3583 switch (BuiltinID) {
3584#define GET_SME_STREAMING_ATTRS
3585#include "clang/Basic/arm_sme_streaming_attrs.inc"
3586#undef GET_SME_STREAMING_ATTRS
3594 diag::warn_attribute_arm_za_builtin_no_za_state)
3599 diag::warn_attribute_arm_zt0_builtin_no_zt0_state)
3606 switch (BuiltinID) {
3609#define GET_SME_IMMEDIATE_CHECK
3610#include "clang/Basic/arm_sme_sema_rangechecks.inc"
3611#undef GET_SME_IMMEDIATE_CHECK
3614 return ParseSVEImmChecks(TheCall, ImmChecks);
3617bool Sema::CheckSVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3621 switch (BuiltinID) {
3622#define GET_SVE_STREAMING_ATTRS
3623#include "clang/Basic/arm_sve_streaming_attrs.inc"
3624#undef GET_SVE_STREAMING_ATTRS
3632 switch (BuiltinID) {
3635#define GET_SVE_IMMEDIATE_CHECK
3636#include "clang/Basic/arm_sve_sema_rangechecks.inc"
3637#undef GET_SVE_IMMEDIATE_CHECK
3640 return ParseSVEImmChecks(TheCall, ImmChecks);
3643bool Sema::CheckNeonBuiltinFunctionCall(
const TargetInfo &TI,
3644 unsigned BuiltinID,
CallExpr *TheCall) {
3647 switch (BuiltinID) {
3650#define GET_NEON_BUILTINS
3651#define TARGET_BUILTIN(id, ...) case NEON::BI##id:
3652#define BUILTIN(id, ...) case NEON::BI##id:
3653#include "clang/Basic/arm_neon.inc"
3656#undef TARGET_BUILTIN
3658#undef GET_NEON_BUILTINS
3666 bool HasConstPtr =
false;
3667 switch (BuiltinID) {
3668#define GET_NEON_OVERLOAD_CHECK
3669#include "clang/Basic/arm_neon.inc"
3670#include "clang/Basic/arm_fp16.inc"
3671#undef GET_NEON_OVERLOAD_CHECK
3678 if (BuiltinConstantArg(TheCall, ImmArg,
Result))
3681 TV =
Result.getLimitedValue(64);
3682 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3687 if (PtrArgNum >= 0) {
3691 Arg = ICE->getSubExpr();
3695 llvm::Triple::ArchType Arch = TI.
getTriple().getArch();
3696 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3697 Arch == llvm::Triple::aarch64_32 ||
3698 Arch == llvm::Triple::aarch64_be;
3716 unsigned i = 0, l = 0, u = 0;
3717 switch (BuiltinID) {
3720 #define GET_NEON_IMMEDIATE_CHECK
3721 #include "clang/Basic/arm_neon.inc"
3722 #include "clang/Basic/arm_fp16.inc"
3723 #undef GET_NEON_IMMEDIATE_CHECK
3726 return BuiltinConstantArgRange(TheCall, i, l, u + l);
3729bool Sema::CheckMVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3730 switch (BuiltinID) {
3733 #include "clang/Basic/arm_mve_builtin_sema.inc"
3737bool Sema::CheckCDEBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3740 switch (BuiltinID) {
3743#include "clang/Basic/arm_cde_builtin_sema.inc"
3749 return CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
true);
3752bool Sema::CheckARMCoprocessorImmediate(
const TargetInfo &TI,
3753 const Expr *CoprocArg,
bool WantCDE) {
3762 int64_t CoprocNo = CoprocNoAP.getExtValue();
3763 assert(CoprocNo >= 0 &&
"Coprocessor immediate must be non-negative");
3766 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3768 if (IsCDECoproc != WantCDE)
3775bool Sema::CheckARMBuiltinExclusiveCall(
unsigned BuiltinID,
CallExpr *TheCall,
3776 unsigned MaxWidth) {
3777 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3778 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3779 BuiltinID == ARM::BI__builtin_arm_strex ||
3780 BuiltinID == ARM::BI__builtin_arm_stlex ||
3781 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3782 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3783 BuiltinID == AArch64::BI__builtin_arm_strex ||
3784 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3785 "unexpected ARM builtin");
3786 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3787 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3788 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3789 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3801 Expr *PointerArg = TheCall->
getArg(IsLdrex ? 0 : 1);
3805 PointerArg = PointerArgRes.
get();
3825 CastNeeded = CK_BitCast;
3826 Diag(DRE->
getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3836 PointerArg = PointerArgRes.
get();
3838 TheCall->
setArg(IsLdrex ? 0 : 1, PointerArg);
3843 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3850 assert(MaxWidth == 64 &&
"Diagnostic unexpectedly inaccurate");
3851 Diag(DRE->
getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3890bool Sema::CheckARMBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3892 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3893 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3894 BuiltinID == ARM::BI__builtin_arm_strex ||
3895 BuiltinID == ARM::BI__builtin_arm_stlex) {
3896 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3899 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3900 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3901 BuiltinConstantArgRange(TheCall, 2, 0, 1);
3904 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3905 BuiltinID == ARM::BI__builtin_arm_wsr64)
3906 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3,
false);
3908 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3909 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3910 BuiltinID == ARM::BI__builtin_arm_wsr ||
3911 BuiltinID == ARM::BI__builtin_arm_wsrp)
3912 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3914 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3916 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3918 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3924 switch (BuiltinID) {
3925 default:
return false;
3926 case ARM::BI__builtin_arm_ssat:
3927 return BuiltinConstantArgRange(TheCall, 1, 1, 32);
3928 case ARM::BI__builtin_arm_usat:
3929 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
3930 case ARM::BI__builtin_arm_ssat16:
3931 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
3932 case ARM::BI__builtin_arm_usat16:
3933 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
3934 case ARM::BI__builtin_arm_vcvtr_f:
3935 case ARM::BI__builtin_arm_vcvtr_d:
3936 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
3937 case ARM::BI__builtin_arm_dmb:
3938 case ARM::BI__builtin_arm_dsb:
3939 case ARM::BI__builtin_arm_isb:
3940 case ARM::BI__builtin_arm_dbg:
3941 return BuiltinConstantArgRange(TheCall, 0, 0, 15);
3942 case ARM::BI__builtin_arm_cdp:
3943 case ARM::BI__builtin_arm_cdp2:
3944 case ARM::BI__builtin_arm_mcr:
3945 case ARM::BI__builtin_arm_mcr2:
3946 case ARM::BI__builtin_arm_mrc:
3947 case ARM::BI__builtin_arm_mrc2:
3948 case ARM::BI__builtin_arm_mcrr:
3949 case ARM::BI__builtin_arm_mcrr2:
3950 case ARM::BI__builtin_arm_mrrc:
3951 case ARM::BI__builtin_arm_mrrc2:
3952 case ARM::BI__builtin_arm_ldc:
3953 case ARM::BI__builtin_arm_ldcl:
3954 case ARM::BI__builtin_arm_ldc2:
3955 case ARM::BI__builtin_arm_ldc2l:
3956 case ARM::BI__builtin_arm_stc:
3957 case ARM::BI__builtin_arm_stcl:
3958 case ARM::BI__builtin_arm_stc2:
3959 case ARM::BI__builtin_arm_stc2l:
3960 return BuiltinConstantArgRange(TheCall, 0, 0, 15) ||
3961 CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
3966bool Sema::CheckAArch64BuiltinFunctionCall(
const TargetInfo &TI,
3969 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3970 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3971 BuiltinID == AArch64::BI__builtin_arm_strex ||
3972 BuiltinID == AArch64::BI__builtin_arm_stlex) {
3973 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
3976 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
3977 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3978 BuiltinConstantArgRange(TheCall, 2, 0, 3) ||
3979 BuiltinConstantArgRange(TheCall, 3, 0, 1) ||
3980 BuiltinConstantArgRange(TheCall, 4, 0, 1);
3983 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
3984 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
3985 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
3986 BuiltinID == AArch64::BI__builtin_arm_wsr128)
3987 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3990 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
3991 BuiltinID == AArch64::BI__builtin_arm_addg ||
3992 BuiltinID == AArch64::BI__builtin_arm_gmi ||
3993 BuiltinID == AArch64::BI__builtin_arm_ldg ||
3994 BuiltinID == AArch64::BI__builtin_arm_stg ||
3995 BuiltinID == AArch64::BI__builtin_arm_subp) {
3996 return BuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
3999 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
4000 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
4001 BuiltinID == AArch64::BI__builtin_arm_wsr ||
4002 BuiltinID == AArch64::BI__builtin_arm_wsrp)
4003 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
4008 if (BuiltinID == AArch64::BI_ReadStatusReg ||
4009 BuiltinID == AArch64::BI_WriteStatusReg)
4010 return BuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
4012 if (BuiltinID == AArch64::BI__getReg)
4013 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
4015 if (BuiltinID == AArch64::BI__break)
4016 return BuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
4018 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
4021 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
4024 if (CheckSMEBuiltinFunctionCall(BuiltinID, TheCall))
4029 unsigned i = 0, l = 0, u = 0;
4030 switch (BuiltinID) {
4031 default:
return false;
4032 case AArch64::BI__builtin_arm_dmb:
4033 case AArch64::BI__builtin_arm_dsb:
4034 case AArch64::BI__builtin_arm_isb: l = 0; u = 15;
break;
4035 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535;
break;
4038 return BuiltinConstantArgRange(TheCall, i, l, u + l);
4075 if (!RT->getDecl()->getDeclName().isEmpty())
4078 if (!ET->getDecl()->getDeclName().isEmpty())
4094 const auto *UO = dyn_cast<UnaryOperator>(Arg->
IgnoreParens());
4098 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
4101 if (CE->getCastKind() != CK_IntegralToPointer &&
4102 CE->getCastKind() != CK_NullToPointer)
4106 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
4111 dyn_cast<EnumConstantDecl>(DR->getDecl());
4122 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
4125bool Sema::CheckBPFBuiltinFunctionCall(
unsigned BuiltinID,
4127 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
4128 BuiltinID == BPF::BI__builtin_btf_type_id ||
4129 BuiltinID == BPF::BI__builtin_preserve_type_info ||
4130 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
4131 "unexpected BPF builtin");
4141 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
4142 kind = diag::err_preserve_field_info_not_const;
4143 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
4144 kind = diag::err_btf_type_id_not_const;
4145 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
4146 kind = diag::err_preserve_type_info_not_const;
4148 kind = diag::err_preserve_enum_value_not_const;
4154 Arg = TheCall->
getArg(0);
4155 bool InvalidArg =
false;
4156 bool ReturnUnsignedInt =
true;
4157 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
4160 kind = diag::err_preserve_field_info_not_field;
4162 }
else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
4165 kind = diag::err_preserve_type_info_invalid;
4167 }
else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
4170 kind = diag::err_preserve_enum_value_invalid;
4172 ReturnUnsignedInt =
false;
4173 }
else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
4174 ReturnUnsignedInt =
false;
4182 if (ReturnUnsignedInt)
4189bool Sema::CheckHexagonBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4202 { Hexagon::BI__builtin_circ_ldd, {{ 3,
true, 4, 3 }} },
4203 { Hexagon::BI__builtin_circ_ldw, {{ 3,
true, 4, 2 }} },
4204 { Hexagon::BI__builtin_circ_ldh, {{ 3,
true, 4, 1 }} },
4205 { Hexagon::BI__builtin_circ_lduh, {{ 3,
true, 4, 1 }} },
4206 { Hexagon::BI__builtin_circ_ldb, {{ 3,
true, 4, 0 }} },
4207 { Hexagon::BI__builtin_circ_ldub, {{ 3,
true, 4, 0 }} },
4208 { Hexagon::BI__builtin_circ_std, {{ 3,
true, 4, 3 }} },
4209 { Hexagon::BI__builtin_circ_stw, {{ 3,
true, 4, 2 }} },
4210 { Hexagon::BI__builtin_circ_sth, {{ 3,
true, 4, 1 }} },
4211 { Hexagon::BI__builtin_circ_sthhi, {{ 3,
true, 4, 1 }} },
4212 { Hexagon::BI__builtin_circ_stb, {{ 3,
true, 4, 0 }} },
4214 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1,
true, 4, 0 }} },
4215 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1,
true, 4, 0 }} },
4216 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1,
true, 4, 1 }} },
4217 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1,
true, 4, 1 }} },
4218 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1,
true, 4, 2 }} },
4219 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1,
true, 4, 3 }} },
4220 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1,
true, 4, 0 }} },
4221 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1,
true, 4, 1 }} },
4222 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1,
true, 4, 1 }} },
4223 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1,
true, 4, 2 }} },
4224 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1,
true, 4, 3 }} },
4226 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1,
true, 8, 0 }} },
4227 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1,
false, 16, 0 }} },
4228 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1,
false, 16, 0 }} },
4229 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0,
true, 8, 0 }} },
4230 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1,
false, 5, 0 }} },
4231 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1,
false, 8, 0 }} },
4232 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1,
true, 8, 0 }} },
4233 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1,
false, 5, 0 }} },
4234 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1,
false, 5, 0 }} },
4235 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1,
false, 5, 0 }} },
4236 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1,
false, 8, 0 }} },
4237 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1,
true, 8, 0 }} },
4238 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1,
false, 7, 0 }} },
4239 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1,
true, 8, 0 }} },
4240 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1,
true, 8, 0 }} },
4241 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1,
false, 7, 0 }} },
4242 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1,
true, 8, 0 }} },
4243 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1,
true, 8, 0 }} },
4244 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1,
false, 7, 0 }} },
4245 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1,
false, 6, 0 }} },
4246 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2,
true, 8, 0 }} },
4247 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1,
false, 6, 0 }} },
4248 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1,
false, 5, 0 }} },
4249 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0,
false, 10, 0 }} },
4250 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0,
false, 10, 0 }} },
4251 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1,
false, 5, 0 }} },
4252 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0,
false, 10, 0 }} },
4253 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0,
false, 10, 0 }} },
4254 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2,
false, 6, 0 }} },
4255 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1,
false, 6, 2 }} },
4256 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2,
false, 3, 0 }} },
4257 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2,
false, 6, 0 }} },
4258 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2,
false, 6, 0 }} },
4259 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1,
false, 6, 0 }} },
4260 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2,
false, 6, 0 }} },
4261 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2,
false, 6, 0 }} },
4262 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2,
false, 6, 0 }} },
4263 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2,
false, 5, 0 }} },
4264 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2,
false, 5, 0 }} },
4265 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1,
false, 5, 0 }} },
4266 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2,
false, 5, 0 }} },
4267 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2,
false, 5, 0 }} },
4268 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1,
false, 5, 0 }} },
4269 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2,
false, 5, 0 }} },
4270 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1,
false, 4, 0 }} },
4271 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1,
false, 5, 0 }} },
4272 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2,
false, 6, 0 }} },
4273 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2,
false, 6, 0 }} },
4274 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1,
false, 6, 0 }} },
4275 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2,
false, 6, 0 }} },
4276 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2,
false, 6, 0 }} },
4277 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
4278 {{ 1,
false, 6, 0 }} },
4279 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1,
false, 6, 0 }} },
4280 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2,
false, 5, 0 }} },
4281 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2,
false, 5, 0 }} },
4282 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1,
false, 5, 0 }} },
4283 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2,
false, 5, 0 }} },
4284 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2,
false, 5, 0 }} },
4285 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
4286 {{ 1,
false, 5, 0 }} },
4287 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1,
false, 5, 0 }} },
4288 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1,
false, 5, 0 }} },
4289 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1,
false, 4, 0 }} },
4290 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1,
false, 5, 0 }} },
4291 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1,
false, 5, 0 }} },
4292 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1,
false, 5, 0 },
4293 { 2,
false, 5, 0 }} },
4294 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1,
false, 6, 0 },
4295 { 2,
false, 6, 0 }} },
4296 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2,
false, 5, 0 },
4297 { 3,
false, 5, 0 }} },
4298 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2,
false, 6, 0 },
4299 { 3,
false, 6, 0 }} },
4300 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2,
false, 6, 0 }} },
4301 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2,
false, 6, 0 }} },
4302 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1,
false, 6, 0 }} },
4303 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2,
false, 6, 0 }} },
4304 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2,
false, 6, 0 }} },
4305 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2,
false, 6, 0 }} },
4306 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2,
false, 5, 0 }} },
4307 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2,
false, 5, 0 }} },
4308 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1,
false, 5, 0 }} },
4309 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2,
false, 5, 0 }} },
4310 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2,
false, 5, 0 }} },
4311 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2,
false, 5, 0 }} },
4312 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1,
false, 4, 0 }} },
4313 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1,
false, 5, 0 }} },
4314 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1,
false, 5, 0 }} },
4315 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
4316 {{ 2,
false, 4, 0 },
4317 { 3,
false, 5, 0 }} },
4318 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
4319 {{ 2,
false, 4, 0 },
4320 { 3,
false, 5, 0 }} },
4321 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
4322 {{ 2,
false, 4, 0 },
4323 { 3,
false, 5, 0 }} },
4324 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
4325 {{ 2,
false, 4, 0 },
4326 { 3,
false, 5, 0 }} },
4327 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1,
false, 5, 0 }} },
4328 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1,
false, 5, 0 }} },
4329 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2,
false, 3, 0 }} },
4330 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2,
false, 3, 0 }} },
4331 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2,
false, 5, 0 }} },
4332 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2,
false, 5, 0 }} },
4333 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2,
false, 5, 0 }} },
4334 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2,
false, 5, 0 }} },
4335 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1,
true , 6, 0 }} },
4336 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1,
true, 6, 0 }} },
4337 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1,
false, 5, 0 },
4338 { 2,
false, 5, 0 }} },
4339 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1,
false, 6, 0 },
4340 { 2,
false, 6, 0 }} },
4341 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0,
true, 6, 0 }} },
4342 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1,
false, 5, 0 }} },
4343 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2,
false, 5, 0 }} },
4344 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2,
false, 5, 0 }} },
4345 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2,
false, 5, 0 }} },
4346 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2,
false, 5, 0 }} },
4347 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3,
false, 2, 0 }} },
4348 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2,
false, 2, 0 }} },
4349 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
4350 {{ 1,
false, 4, 0 }} },
4351 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1,
false, 4, 0 }} },
4352 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
4353 {{ 1,
false, 4, 0 }} },
4354 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1,
false, 6, 0 }} },
4355 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2,
false, 6, 0 }} },
4356 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2,
false, 6, 0 }} },
4357 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2,
false, 6, 0 }} },
4358 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2,
false, 6, 0 }} },
4359 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2,
false, 6, 0 }} },
4360 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1,
false, 5, 0 }} },
4361 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2,
false, 5, 0 }} },
4362 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2,
false, 5, 0 }} },
4363 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2,
false, 5, 0 }} },
4364 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2,
false, 5, 0 }} },
4365 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2,
false, 5, 0 }} },
4366 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2,
false, 3, 0 }} },
4367 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2,
false, 3, 0 }} },
4368 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2,
false, 3, 0 }} },
4369 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2,
false, 3, 0 }} },
4370 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2,
false, 1, 0 }} },
4371 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2,
false, 1, 0 }} },
4372 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3,
false, 1, 0 }} },
4373 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
4374 {{ 3,
false, 1, 0 }} },
4375 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2,
false, 1, 0 }} },
4376 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2,
false, 1, 0 }} },
4377 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3,
false, 1, 0 }} },
4378 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
4379 {{ 3,
false, 1, 0 }} },
4380 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2,
false, 1, 0 }} },
4381 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2,
false, 1, 0 }} },
4382 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3,
false, 1, 0 }} },
4383 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
4384 {{ 3,
false, 1, 0 }} },
4386 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2,
false, 2, 0 }} },
4387 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
4388 {{ 2,
false, 2, 0 }} },
4389 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
4390 {{ 3,
false, 2, 0 }} },
4391 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
4392 {{ 3,
false, 2, 0 }} },
4393 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2,
false, 2, 0 }} },
4394 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
4395 {{ 2,
false, 2, 0 }} },
4396 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
4397 {{ 3,
false, 2, 0 }} },
4398 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
4399 {{ 3,
false, 2, 0 }} },
4400 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2,
false, 3, 0 }} },
4401 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2,
false, 3, 0 }} },
4402 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3,
false, 3, 0 }} },
4403 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
4404 {{ 3,
false, 3, 0 }} },
4405 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2,
false, 3, 0 }} },
4406 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2,
false, 3, 0 }} },
4407 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3,
false, 3, 0 }} },
4408 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
4409 {{ 3,
false, 3, 0 }} },
4414 static const bool SortOnce =
4417 return LHS.BuiltinID < RHS.BuiltinID;
4423 Infos, [=](
const BuiltinInfo &BI) {
return BI.BuiltinID < BuiltinID; });
4424 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
4429 for (
const ArgInfo &A : F->Infos) {
4431 if (A.BitWidth == 0)
4434 int32_t
Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
4435 int32_t
Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
4437 Error |= BuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4439 unsigned M = 1 << A.Align;
4442 Error |= BuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4443 Error |= BuiltinConstantArgMultiple(TheCall, A.OpNum, M);
4449bool Sema::CheckHexagonBuiltinFunctionCall(
unsigned BuiltinID,
4451 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
4454bool Sema::CheckLoongArchBuiltinFunctionCall(
const TargetInfo &TI,
4457 switch (BuiltinID) {
4461 case LoongArch::BI__builtin_loongarch_cacop_d:
4462 case LoongArch::BI__builtin_loongarch_cacop_w: {
4463 BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
4464 BuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12), llvm::maxIntN(12));
4467 case LoongArch::BI__builtin_loongarch_break:
4468 case LoongArch::BI__builtin_loongarch_dbar:
4469 case LoongArch::BI__builtin_loongarch_ibar:
4470 case LoongArch::BI__builtin_loongarch_syscall:
4472 return BuiltinConstantArgRange(TheCall, 0, 0, 32767);
4473 case LoongArch::BI__builtin_loongarch_csrrd_w:
4474 case LoongArch::BI__builtin_loongarch_csrrd_d:
4475 return BuiltinConstantArgRange(TheCall, 0, 0, 16383);
4476 case LoongArch::BI__builtin_loongarch_csrwr_w:
4477 case LoongArch::BI__builtin_loongarch_csrwr_d:
4478 return BuiltinConstantArgRange(TheCall, 1, 0, 16383);
4479 case LoongArch::BI__builtin_loongarch_csrxchg_w:
4480 case LoongArch::BI__builtin_loongarch_csrxchg_d:
4481 return BuiltinConstantArgRange(TheCall, 2, 0, 16383);
4482 case LoongArch::BI__builtin_loongarch_lddir_d:
4483 case LoongArch::BI__builtin_loongarch_ldpte_d:
4484 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4485 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
4486 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
4487 return BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
4490 case LoongArch::BI__builtin_lsx_vbitclri_b:
4491 case LoongArch::BI__builtin_lsx_vbitrevi_b:
4492 case LoongArch::BI__builtin_lsx_vbitseti_b:
4493 case LoongArch::BI__builtin_lsx_vsat_b:
4494 case LoongArch::BI__builtin_lsx_vsat_bu:
4495 case LoongArch::BI__builtin_lsx_vslli_b:
4496 case LoongArch::BI__builtin_lsx_vsrai_b:
4497 case LoongArch::BI__builtin_lsx_vsrari_b:
4498 case LoongArch::BI__builtin_lsx_vsrli_b:
4499 case LoongArch::BI__builtin_lsx_vsllwil_h_b:
4500 case LoongArch::BI__builtin_lsx_vsllwil_hu_bu:
4501 case LoongArch::BI__builtin_lsx_vrotri_b:
4502 case LoongArch::BI__builtin_lsx_vsrlri_b:
4503 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4504 case LoongArch::BI__builtin_lsx_vbitclri_h:
4505 case LoongArch::BI__builtin_lsx_vbitrevi_h:
4506 case LoongArch::BI__builtin_lsx_vbitseti_h:
4507 case LoongArch::BI__builtin_lsx_vsat_h:
4508 case LoongArch::BI__builtin_lsx_vsat_hu:
4509 case LoongArch::BI__builtin_lsx_vslli_h:
4510 case LoongArch::BI__builtin_lsx_vsrai_h:
4511 case LoongArch::BI__builtin_lsx_vsrari_h:
4512 case LoongArch::BI__builtin_lsx_vsrli_h:
4513 case LoongArch::BI__builtin_lsx_vsllwil_w_h:
4514 case LoongArch::BI__builtin_lsx_vsllwil_wu_hu:
4515 case LoongArch::BI__builtin_lsx_vrotri_h:
4516 case LoongArch::BI__builtin_lsx_vsrlri_h:
4517 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4518 case LoongArch::BI__builtin_lsx_vssrarni_b_h:
4519 case LoongArch::BI__builtin_lsx_vssrarni_bu_h:
4520 case LoongArch::BI__builtin_lsx_vssrani_b_h:
4521 case LoongArch::BI__builtin_lsx_vssrani_bu_h:
4522 case LoongArch::BI__builtin_lsx_vsrarni_b_h:
4523 case LoongArch::BI__builtin_lsx_vsrlni_b_h:
4524 case LoongArch::BI__builtin_lsx_vsrlrni_b_h:
4525 case LoongArch::BI__builtin_lsx_vssrlni_b_h:
4526 case LoongArch::BI__builtin_lsx_vssrlni_bu_h:
4527 case LoongArch::BI__builtin_lsx_vssrlrni_b_h:
4528 case LoongArch::BI__builtin_lsx_vssrlrni_bu_h:
4529 case LoongArch::BI__builtin_lsx_vsrani_b_h:
4530 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4531 case LoongArch::BI__builtin_lsx_vslei_bu:
4532 case LoongArch::BI__builtin_lsx_vslei_hu:
4533 case LoongArch::BI__builtin_lsx_vslei_wu:
4534 case LoongArch::BI__builtin_lsx_vslei_du:
4535 case LoongArch::BI__builtin_lsx_vslti_bu:
4536 case LoongArch::BI__builtin_lsx_vslti_hu:
4537 case LoongArch::BI__builtin_lsx_vslti_wu:
4538 case LoongArch::BI__builtin_lsx_vslti_du:
4539 case LoongArch::BI__builtin_lsx_vmaxi_bu:
4540 case LoongArch::BI__builtin_lsx_vmaxi_hu:
4541 case LoongArch::BI__builtin_lsx_vmaxi_wu:
4542 case LoongArch::BI__builtin_lsx_vmaxi_du:
4543 case LoongArch::BI__builtin_lsx_vmini_bu:
4544 case LoongArch::BI__builtin_lsx_vmini_hu:
4545 case LoongArch::BI__builtin_lsx_vmini_wu:
4546 case LoongArch::BI__builtin_lsx_vmini_du:
4547 case LoongArch::BI__builtin_lsx_vaddi_bu:
4548 case LoongArch::BI__builtin_lsx_vaddi_hu:
4549 case LoongArch::BI__builtin_lsx_vaddi_wu:
4550 case LoongArch::BI__builtin_lsx_vaddi_du:
4551 case LoongArch::BI__builtin_lsx_vbitclri_w:
4552 case LoongArch::BI__builtin_lsx_vbitrevi_w:
4553 case LoongArch::BI__builtin_lsx_vbitseti_w:
4554 case LoongArch::BI__builtin_lsx_vsat_w:
4555 case LoongArch::BI__builtin_lsx_vsat_wu:
4556 case LoongArch::BI__builtin_lsx_vslli_w:
4557 case LoongArch::BI__builtin_lsx_vsrai_w:
4558 case LoongArch::BI__builtin_lsx_vsrari_w:
4559 case LoongArch::BI__builtin_lsx_vsrli_w:
4560 case LoongArch::BI__builtin_lsx_vsllwil_d_w:
4561 case LoongArch::BI__builtin_lsx_vsllwil_du_wu:
4562 case LoongArch::BI__builtin_lsx_vsrlri_w:
4563 case LoongArch::BI__builtin_lsx_vrotri_w:
4564 case LoongArch::BI__builtin_lsx_vsubi_bu:
4565 case LoongArch::BI__builtin_lsx_vsubi_hu:
4566 case LoongArch::BI__builtin_lsx_vbsrl_v:
4567 case LoongArch::BI__builtin_lsx_vbsll_v:
4568 case LoongArch::BI__builtin_lsx_vsubi_wu:
4569 case LoongArch::BI__builtin_lsx_vsubi_du:
4570 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4571 case LoongArch::BI__builtin_lsx_vssrarni_h_w:
4572 case LoongArch::BI__builtin_lsx_vssrarni_hu_w:
4573 case LoongArch::BI__builtin_lsx_vssrani_h_w:
4574 case LoongArch::BI__builtin_lsx_vssrani_hu_w:
4575 case LoongArch::BI__builtin_lsx_vsrarni_h_w:
4576 case LoongArch::BI__builtin_lsx_vsrani_h_w:
4577 case LoongArch::BI__builtin_lsx_vfrstpi_b:
4578 case LoongArch::BI__builtin_lsx_vfrstpi_h:
4579 case LoongArch::BI__builtin_lsx_vsrlni_h_w:
4580 case LoongArch::BI__builtin_lsx_vsrlrni_h_w:
4581 case LoongArch::BI__builtin_lsx_vssrlni_h_w:
4582 case LoongArch::BI__builtin_lsx_vssrlni_hu_w:
4583 case LoongArch::BI__builtin_lsx_vssrlrni_h_w:
4584 case LoongArch::BI__builtin_lsx_vssrlrni_hu_w:
4585 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4586 case LoongArch::BI__builtin_lsx_vbitclri_d:
4587 case LoongArch::BI__builtin_lsx_vbitrevi_d:
4588 case LoongArch::BI__builtin_lsx_vbitseti_d:
4589 case LoongArch::BI__builtin_lsx_vsat_d:
4590 case LoongArch::BI__builtin_lsx_vsat_du:
4591 case LoongArch::BI__builtin_lsx_vslli_d:
4592 case LoongArch::BI__builtin_lsx_vsrai_d:
4593 case LoongArch::BI__builtin_lsx_vsrli_d:
4594 case LoongArch::BI__builtin_lsx_vsrari_d:
4595 case LoongArch::BI__builtin_lsx_vrotri_d:
4596 case LoongArch::BI__builtin_lsx_vsrlri_d:
4597 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4598 case LoongArch::BI__builtin_lsx_vssrarni_w_d:
4599 case LoongArch::BI__builtin_lsx_vssrarni_wu_d:
4600 case LoongArch::BI__builtin_lsx_vssrani_w_d:
4601 case LoongArch::BI__builtin_lsx_vssrani_wu_d:
4602 case LoongArch::BI__builtin_lsx_vsrarni_w_d:
4603 case LoongArch::BI__builtin_lsx_vsrlni_w_d:
4604 case LoongArch::BI__builtin_lsx_vsrlrni_w_d:
4605 case LoongArch::BI__builtin_lsx_vssrlni_w_d:
4606 case LoongArch::BI__builtin_lsx_vssrlni_wu_d:
4607 case LoongArch::BI__builtin_lsx_vssrlrni_w_d:
4608 case LoongArch::BI__builtin_lsx_vssrlrni_wu_d:
4609 case LoongArch::BI__builtin_lsx_vsrani_w_d:
4610 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4611 case LoongArch::BI__builtin_lsx_vssrarni_d_q:
4612 case LoongArch::BI__builtin_lsx_vssrarni_du_q:
4613 case LoongArch::BI__builtin_lsx_vssrani_d_q:
4614 case LoongArch::BI__builtin_lsx_vssrani_du_q:
4615 case LoongArch::BI__builtin_lsx_vsrarni_d_q:
4616 case LoongArch::BI__builtin_lsx_vssrlni_d_q:
4617 case LoongArch::BI__builtin_lsx_vssrlni_du_q:
4618 case LoongArch::BI__builtin_lsx_vssrlrni_d_q:
4619 case LoongArch::BI__builtin_lsx_vssrlrni_du_q:
4620 case LoongArch::BI__builtin_lsx_vsrani_d_q:
4621 case LoongArch::BI__builtin_lsx_vsrlrni_d_q:
4622 case LoongArch::BI__builtin_lsx_vsrlni_d_q:
4623 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4624 case LoongArch::BI__builtin_lsx_vseqi_b:
4625 case LoongArch::BI__builtin_lsx_vseqi_h:
4626 case LoongArch::BI__builtin_lsx_vseqi_w:
4627 case LoongArch::BI__builtin_lsx_vseqi_d:
4628 case LoongArch::BI__builtin_lsx_vslti_b:
4629 case LoongArch::BI__builtin_lsx_vslti_h:
4630 case LoongArch::BI__builtin_lsx_vslti_w:
4631 case LoongArch::BI__builtin_lsx_vslti_d:
4632 case LoongArch::BI__builtin_lsx_vslei_b:
4633 case LoongArch::BI__builtin_lsx_vslei_h:
4634 case LoongArch::BI__builtin_lsx_vslei_w:
4635 case LoongArch::BI__builtin_lsx_vslei_d:
4636 case LoongArch::BI__builtin_lsx_vmaxi_b:
4637 case LoongArch::BI__builtin_lsx_vmaxi_h:
4638 case LoongArch::BI__builtin_lsx_vmaxi_w:
4639 case LoongArch::BI__builtin_lsx_vmaxi_d:
4640 case LoongArch::BI__builtin_lsx_vmini_b:
4641 case LoongArch::BI__builtin_lsx_vmini_h:
4642 case LoongArch::BI__builtin_lsx_vmini_w:
4643 case LoongArch::BI__builtin_lsx_vmini_d:
4644 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4645 case LoongArch::BI__builtin_lsx_vandi_b:
4646 case LoongArch::BI__builtin_lsx_vnori_b:
4647 case LoongArch::BI__builtin_lsx_vori_b:
4648 case LoongArch::BI__builtin_lsx_vshuf4i_b:
4649 case LoongArch::BI__builtin_lsx_vshuf4i_h:
4650 case LoongArch::BI__builtin_lsx_vshuf4i_w:
4651 case LoongArch::BI__builtin_lsx_vxori_b:
4652 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4653 case LoongArch::BI__builtin_lsx_vbitseli_b:
4654 case LoongArch::BI__builtin_lsx_vshuf4i_d:
4655 case LoongArch::BI__builtin_lsx_vextrins_b:
4656 case LoongArch::BI__builtin_lsx_vextrins_h:
4657 case LoongArch::BI__builtin_lsx_vextrins_w:
4658 case LoongArch::BI__builtin_lsx_vextrins_d:
4659 case LoongArch::BI__builtin_lsx_vpermi_w:
4660 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4661 case LoongArch::BI__builtin_lsx_vpickve2gr_b:
4662 case LoongArch::BI__builtin_lsx_vpickve2gr_bu:
4663 case LoongArch::BI__builtin_lsx_vreplvei_b:
4664 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4665 case LoongArch::BI__builtin_lsx_vinsgr2vr_b:
4666 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4667 case LoongArch::BI__builtin_lsx_vpickve2gr_h:
4668 case LoongArch::BI__builtin_lsx_vpickve2gr_hu:
4669 case LoongArch::BI__builtin_lsx_vreplvei_h:
4670 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4671 case LoongArch::BI__builtin_lsx_vinsgr2vr_h:
4672 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4673 case LoongArch::BI__builtin_lsx_vpickve2gr_w:
4674 case LoongArch::BI__builtin_lsx_vpickve2gr_wu:
4675 case LoongArch::BI__builtin_lsx_vreplvei_w:
4676 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4677 case LoongArch::BI__builtin_lsx_vinsgr2vr_w:
4678 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4679 case LoongArch::BI__builtin_lsx_vpickve2gr_d:
4680 case LoongArch::BI__builtin_lsx_vpickve2gr_du:
4681 case LoongArch::BI__builtin_lsx_vreplvei_d:
4682 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4683 case LoongArch::BI__builtin_lsx_vinsgr2vr_d:
4684 return BuiltinConstantArgRange(TheCall, 2, 0, 1);
4685 case LoongArch::BI__builtin_lsx_vstelm_b:
4686 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4687 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4688 case LoongArch::BI__builtin_lsx_vstelm_h:
4689 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4690 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4691 case LoongArch::BI__builtin_lsx_vstelm_w:
4692 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4693 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4694 case LoongArch::BI__builtin_lsx_vstelm_d:
4695 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4696 BuiltinConstantArgRange(TheCall, 3, 0, 1);
4697 case LoongArch::BI__builtin_lsx_vldrepl_b:
4698 case LoongArch::BI__builtin_lsx_vld:
4699 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4700 case LoongArch::BI__builtin_lsx_vldrepl_h:
4701 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4702 case LoongArch::BI__builtin_lsx_vldrepl_w:
4703 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4704 case LoongArch::BI__builtin_lsx_vldrepl_d:
4705 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4706 case LoongArch::BI__builtin_lsx_vst:
4707 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4708 case LoongArch::BI__builtin_lsx_vldi:
4709 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4710 case LoongArch::BI__builtin_lsx_vrepli_b:
4711 case LoongArch::BI__builtin_lsx_vrepli_h:
4712 case LoongArch::BI__builtin_lsx_vrepli_w:
4713 case LoongArch::BI__builtin_lsx_vrepli_d:
4714 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4717 case LoongArch::BI__builtin_lasx_xvbitclri_b:
4718 case LoongArch::BI__builtin_lasx_xvbitrevi_b:
4719 case LoongArch::BI__builtin_lasx_xvbitseti_b:
4720 case LoongArch::BI__builtin_lasx_xvsat_b:
4721 case LoongArch::BI__builtin_lasx_xvsat_bu:
4722 case LoongArch::BI__builtin_lasx_xvslli_b:
4723 case LoongArch::BI__builtin_lasx_xvsrai_b:
4724 case LoongArch::BI__builtin_lasx_xvsrari_b:
4725 case LoongArch::BI__builtin_lasx_xvsrli_b:
4726 case LoongArch::BI__builtin_lasx_xvsllwil_h_b:
4727 case LoongArch::BI__builtin_lasx_xvsllwil_hu_bu:
4728 case LoongArch::BI__builtin_lasx_xvrotri_b:
4729 case LoongArch::BI__builtin_lasx_xvsrlri_b:
4730 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4731 case LoongArch::BI__builtin_lasx_xvbitclri_h:
4732 case LoongArch::BI__builtin_lasx_xvbitrevi_h:
4733 case LoongArch::BI__builtin_lasx_xvbitseti_h:
4734 case LoongArch::BI__builtin_lasx_xvsat_h:
4735 case LoongArch::BI__builtin_lasx_xvsat_hu:
4736 case LoongArch::BI__builtin_lasx_xvslli_h:
4737 case LoongArch::BI__builtin_lasx_xvsrai_h:
4738 case LoongArch::BI__builtin_lasx_xvsrari_h:
4739 case LoongArch::BI__builtin_lasx_xvsrli_h:
4740 case LoongArch::BI__builtin_lasx_xvsllwil_w_h:
4741 case LoongArch::BI__builtin_lasx_xvsllwil_wu_hu:
4742 case LoongArch::BI__builtin_lasx_xvrotri_h:
4743 case LoongArch::BI__builtin_lasx_xvsrlri_h:
4744 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4745 case LoongArch::BI__builtin_lasx_xvssrarni_b_h:
4746 case LoongArch::BI__builtin_lasx_xvssrarni_bu_h:
4747 case LoongArch::BI__builtin_lasx_xvssrani_b_h:
4748 case LoongArch::BI__builtin_lasx_xvssrani_bu_h:
4749 case LoongArch::BI__builtin_lasx_xvsrarni_b_h:
4750 case LoongArch::BI__builtin_lasx_xvsrlni_b_h:
4751 case LoongArch::BI__builtin_lasx_xvsrlrni_b_h:
4752 case LoongArch::BI__builtin_lasx_xvssrlni_b_h:
4753 case LoongArch::BI__builtin_lasx_xvssrlni_bu_h:
4754 case LoongArch::BI__builtin_lasx_xvssrlrni_b_h:
4755 case LoongArch::BI__builtin_lasx_xvssrlrni_bu_h:
4756 case LoongArch::BI__builtin_lasx_xvsrani_b_h:
4757 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4758 case LoongArch::BI__builtin_lasx_xvslei_bu:
4759 case LoongArch::BI__builtin_lasx_xvslei_hu:
4760 case LoongArch::BI__builtin_lasx_xvslei_wu:
4761 case LoongArch::BI__builtin_lasx_xvslei_du:
4762 case LoongArch::BI__builtin_lasx_xvslti_bu:
4763 case LoongArch::BI__builtin_lasx_xvslti_hu:
4764 case LoongArch::BI__builtin_lasx_xvslti_wu:
4765 case LoongArch::BI__builtin_lasx_xvslti_du:
4766 case LoongArch::BI__builtin_lasx_xvmaxi_bu:
4767 case LoongArch::BI__builtin_lasx_xvmaxi_hu:
4768 case LoongArch::BI__builtin_lasx_xvmaxi_wu:
4769 case LoongArch::BI__builtin_lasx_xvmaxi_du:
4770 case LoongArch::BI__builtin_lasx_xvmini_bu:
4771 case LoongArch::BI__builtin_lasx_xvmini_hu:
4772 case LoongArch::BI__builtin_lasx_xvmini_wu:
4773 case LoongArch::BI__builtin_lasx_xvmini_du:
4774 case LoongArch::BI__builtin_lasx_xvaddi_bu:
4775 case LoongArch::BI__builtin_lasx_xvaddi_hu:
4776 case LoongArch::BI__builtin_lasx_xvaddi_wu:
4777 case LoongArch::BI__builtin_lasx_xvaddi_du:
4778 case LoongArch::BI__builtin_lasx_xvbitclri_w:
4779 case LoongArch::BI__builtin_lasx_xvbitrevi_w:
4780 case LoongArch::BI__builtin_lasx_xvbitseti_w:
4781 case LoongArch::BI__builtin_lasx_xvsat_w:
4782 case LoongArch::BI__builtin_lasx_xvsat_wu:
4783 case LoongArch::BI__builtin_lasx_xvslli_w:
4784 case LoongArch::BI__builtin_lasx_xvsrai_w:
4785 case LoongArch::BI__builtin_lasx_xvsrari_w:
4786 case LoongArch::BI__builtin_lasx_xvsrli_w:
4787 case LoongArch::BI__builtin_lasx_xvsllwil_d_w:
4788 case LoongArch::BI__builtin_lasx_xvsllwil_du_wu:
4789 case LoongArch::BI__builtin_lasx_xvsrlri_w:
4790 case LoongArch::BI__builtin_lasx_xvrotri_w:
4791 case LoongArch::BI__builtin_lasx_xvsubi_bu:
4792 case LoongArch::BI__builtin_lasx_xvsubi_hu:
4793 case LoongArch::BI__builtin_lasx_xvsubi_wu:
4794 case LoongArch::BI__builtin_lasx_xvsubi_du:
4795 case LoongArch::BI__builtin_lasx_xvbsrl_v:
4796 case LoongArch::BI__builtin_lasx_xvbsll_v:
4797 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4798 case LoongArch::BI__builtin_lasx_xvssrarni_h_w:
4799 case LoongArch::BI__builtin_lasx_xvssrarni_hu_w:
4800 case LoongArch::BI__builtin_lasx_xvssrani_h_w:
4801 case LoongArch::BI__builtin_lasx_xvssrani_hu_w:
4802 case LoongArch::BI__builtin_lasx_xvsrarni_h_w:
4803 case LoongArch::BI__builtin_lasx_xvsrani_h_w:
4804 case LoongArch::BI__builtin_lasx_xvfrstpi_b:
4805 case LoongArch::BI__builtin_lasx_xvfrstpi_h:
4806 case LoongArch::BI__builtin_lasx_xvsrlni_h_w:
4807 case LoongArch::BI__builtin_lasx_xvsrlrni_h_w:
4808 case LoongArch::BI__builtin_lasx_xvssrlni_h_w:
4809 case LoongArch::BI__builtin_lasx_xvssrlni_hu_w:
4810 case LoongArch::BI__builtin_lasx_xvssrlrni_h_w:
4811 case LoongArch::BI__builtin_lasx_xvssrlrni_hu_w:
4812 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4813 case LoongArch::BI__builtin_lasx_xvbitclri_d:
4814 case LoongArch::BI__builtin_lasx_xvbitrevi_d:
4815 case LoongArch::BI__builtin_lasx_xvbitseti_d:
4816 case LoongArch::BI__builtin_lasx_xvsat_d:
4817 case LoongArch::BI__builtin_lasx_xvsat_du:
4818 case LoongArch::BI__builtin_lasx_xvslli_d:
4819 case LoongArch::BI__builtin_lasx_xvsrai_d:
4820 case LoongArch::BI__builtin_lasx_xvsrli_d:
4821 case LoongArch::BI__builtin_lasx_xvsrari_d:
4822 case LoongArch::BI__builtin_lasx_xvrotri_d:
4823 case LoongArch::BI__builtin_lasx_xvsrlri_d:
4824 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4825 case LoongArch::BI__builtin_lasx_xvssrarni_w_d:
4826 case LoongArch::BI__builtin_lasx_xvssrarni_wu_d:
4827 case LoongArch::BI__builtin_lasx_xvssrani_w_d:
4828 case LoongArch::BI__builtin_lasx_xvssrani_wu_d:
4829 case LoongArch::BI__builtin_lasx_xvsrarni_w_d:
4830 case LoongArch::BI__builtin_lasx_xvsrlni_w_d:
4831 case LoongArch::BI__builtin_lasx_xvsrlrni_w_d:
4832 case LoongArch::BI__builtin_lasx_xvssrlni_w_d:
4833 case LoongArch::BI__builtin_lasx_xvssrlni_wu_d:
4834 case LoongArch::BI__builtin_lasx_xvssrlrni_w_d:
4835 case LoongArch::BI__builtin_lasx_xvssrlrni_wu_d:
4836 case LoongArch::BI__builtin_lasx_xvsrani_w_d:
4837 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4838 case LoongArch::BI__builtin_lasx_xvssrarni_d_q:
4839 case LoongArch::BI__builtin_lasx_xvssrarni_du_q:
4840 case LoongArch::BI__builtin_lasx_xvssrani_d_q:
4841 case LoongArch::BI__builtin_lasx_xvssrani_du_q:
4842 case LoongArch::BI__builtin_lasx_xvsrarni_d_q:
4843 case LoongArch::BI__builtin_lasx_xvssrlni_d_q:
4844 case LoongArch::BI__builtin_lasx_xvssrlni_du_q:
4845 case LoongArch::BI__builtin_lasx_xvssrlrni_d_q:
4846 case LoongArch::BI__builtin_lasx_xvssrlrni_du_q:
4847 case LoongArch::BI__builtin_lasx_xvsrani_d_q:
4848 case LoongArch::BI__builtin_lasx_xvsrlni_d_q:
4849 case LoongArch::BI__builtin_lasx_xvsrlrni_d_q:
4850 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4851 case LoongArch::BI__builtin_lasx_xvseqi_b:
4852 case LoongArch::BI__builtin_lasx_xvseqi_h:
4853 case LoongArch::BI__builtin_lasx_xvseqi_w:
4854 case LoongArch::BI__builtin_lasx_xvseqi_d:
4855 case LoongArch::BI__builtin_lasx_xvslti_b:
4856 case LoongArch::BI__builtin_lasx_xvslti_h:
4857 case LoongArch::BI__builtin_lasx_xvslti_w:
4858 case LoongArch::BI__builtin_lasx_xvslti_d:
4859 case LoongArch::BI__builtin_lasx_xvslei_b:
4860 case LoongArch::BI__builtin_lasx_xvslei_h:
4861 case LoongArch::BI__builtin_lasx_xvslei_w:
4862 case LoongArch::BI__builtin_lasx_xvslei_d:
4863 case LoongArch::BI__builtin_lasx_xvmaxi_b:
4864 case LoongArch::BI__builtin_lasx_xvmaxi_h:
4865 case LoongArch::BI__builtin_lasx_xvmaxi_w:
4866 case LoongArch::BI__builtin_lasx_xvmaxi_d:
4867 case LoongArch::BI__builtin_lasx_xvmini_b:
4868 case LoongArch::BI__builtin_lasx_xvmini_h:
4869 case LoongArch::BI__builtin_lasx_xvmini_w:
4870 case LoongArch::BI__builtin_lasx_xvmini_d:
4871 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4872 case LoongArch::BI__builtin_lasx_xvandi_b:
4873 case LoongArch::BI__builtin_lasx_xvnori_b:
4874 case LoongArch::BI__builtin_lasx_xvori_b:
4875 case LoongArch::BI__builtin_lasx_xvshuf4i_b:
4876 case LoongArch::BI__builtin_lasx_xvshuf4i_h:
4877 case LoongArch::BI__builtin_lasx_xvshuf4i_w:
4878 case LoongArch::BI__builtin_lasx_xvxori_b:
4879 case LoongArch::BI__builtin_lasx_xvpermi_d:
4880 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4881 case LoongArch::BI__builtin_lasx_xvbitseli_b:
4882 case LoongArch::BI__builtin_lasx_xvshuf4i_d:
4883 case LoongArch::BI__builtin_lasx_xvextrins_b:
4884 case LoongArch::BI__builtin_lasx_xvextrins_h:
4885 case LoongArch::BI__builtin_lasx_xvextrins_w:
4886 case LoongArch::BI__builtin_lasx_xvextrins_d:
4887 case LoongArch::BI__builtin_lasx_xvpermi_q:
4888 case LoongArch::BI__builtin_lasx_xvpermi_w:
4889 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4890 case LoongArch::BI__builtin_lasx_xvrepl128vei_b:
4891 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4892 case LoongArch::BI__builtin_lasx_xvrepl128vei_h:
4893 case LoongArch::BI__builtin_lasx_xvpickve2gr_w:
4894 case LoongArch::BI__builtin_lasx_xvpickve2gr_wu:
4895 case LoongArch::BI__builtin_lasx_xvpickve_w_f:
4896 case LoongArch::BI__builtin_lasx_xvpickve_w:
4897 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4898 case LoongArch::BI__builtin_lasx_xvinsgr2vr_w:
4899 case LoongArch::BI__builtin_lasx_xvinsve0_w:
4900 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4901 case LoongArch::BI__builtin_lasx_xvrepl128vei_w:
4902 case LoongArch::BI__builtin_lasx_xvpickve2gr_d:
4903 case LoongArch::BI__builtin_lasx_xvpickve2gr_du:
4904 case LoongArch::BI__builtin_lasx_xvpickve_d_f:
4905 case LoongArch::BI__builtin_lasx_xvpickve_d:
4906 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4907 case LoongArch::BI__builtin_lasx_xvinsve0_d:
4908 case LoongArch::BI__builtin_lasx_xvinsgr2vr_d:
4909 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4910 case LoongArch::BI__builtin_lasx_xvstelm_b:
4911 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4912 BuiltinConstantArgRange(TheCall, 3, 0, 31);
4913 case LoongArch::BI__builtin_lasx_xvstelm_h:
4914 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4915 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4916 case LoongArch::BI__builtin_lasx_xvstelm_w:
4917 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4918 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4919 case LoongArch::BI__builtin_lasx_xvstelm_d:
4920 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4921 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4922 case LoongArch::BI__builtin_lasx_xvrepl128vei_d:
4923 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4924 case LoongArch::BI__builtin_lasx_xvldrepl_b:
4925 case LoongArch::BI__builtin_lasx_xvld:
4926 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4927 case LoongArch::BI__builtin_lasx_xvldrepl_h:
4928 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4929 case LoongArch::BI__builtin_lasx_xvldrepl_w:
4930 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4931 case LoongArch::BI__builtin_lasx_xvldrepl_d:
4932 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4933 case LoongArch::BI__builtin_lasx_xvst:
4934 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4935 case LoongArch::BI__builtin_lasx_xvldi:
4936 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4937 case LoongArch::BI__builtin_lasx_xvrepli_b:
4938 case LoongArch::BI__builtin_lasx_xvrepli_h:
4939 case LoongArch::BI__builtin_lasx_xvrepli_w:
4940 case LoongArch::BI__builtin_lasx_xvrepli_d:
4941 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4946bool Sema::CheckMipsBuiltinFunctionCall(
const TargetInfo &TI,
4947 unsigned BuiltinID,
CallExpr *TheCall) {
4948 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
4949 CheckMipsBuiltinArgument(BuiltinID, TheCall);
4952bool Sema::CheckMipsBuiltinCpu(
const TargetInfo &TI,
unsigned BuiltinID,
4955 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
4956 BuiltinID <= Mips::BI__builtin_mips_lwx) {
4958 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_dsp);
4961 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
4962 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
4965 diag::err_mips_builtin_requires_dspr2);
4968 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
4969 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
4971 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_msa);
4986bool Sema::CheckMipsBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4987 unsigned i = 0, l = 0, u = 0, m = 0;
4988 switch (BuiltinID) {
4989 default:
return false;
4990 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63;
break;
4991 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63;
break;
4992 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31;
break;
4993 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3;
break;
4994 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31;
break;
4995 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31;
break;
4996 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31;
break;
5000 case Mips::BI__builtin_msa_bclri_b:
5001 case Mips::BI__builtin_msa_bnegi_b:
5002 case Mips::BI__builtin_msa_bseti_b:
5003 case Mips::BI__builtin_msa_sat_s_b:
5004 case Mips::BI__builtin_msa_sat_u_b:
5005 case Mips::BI__builtin_msa_slli_b:
5006 case Mips::BI__builtin_msa_srai_b:
5007 case Mips::BI__builtin_msa_srari_b:
5008 case Mips::BI__builtin_msa_srli_b:
5009 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7;
break;
5010 case Mips::BI__builtin_msa_binsli_b:
5011 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7;
break;
5013 case Mips::BI__builtin_msa_bclri_h:
5014 case Mips::BI__builtin_msa_bnegi_h:
5015 case Mips::BI__builtin_msa_bseti_h:
5016 case Mips::BI__builtin_msa_sat_s_h:
5017 case Mips::BI__builtin_msa_sat_u_h:
5018 case Mips::BI__builtin_msa_slli_h:
5019 case Mips::BI__builtin_msa_srai_h:
5020 case Mips::BI__builtin_msa_srari_h:
5021 case Mips::BI__builtin_msa_srli_h:
5022 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15;
break;
5023 case Mips::BI__builtin_msa_binsli_h:
5024 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15;
break;
5028 case Mips::BI__builtin_msa_cfcmsa:
5029 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31;
break;
5030 case Mips::BI__builtin_msa_clei_u_b:
5031 case Mips::BI__builtin_msa_clei_u_h:
5032 case Mips::BI__builtin_msa_clei_u_w:
5033 case Mips::BI__builtin_msa_clei_u_d:
5034 case Mips::BI__builtin_msa_clti_u_b:
5035 case Mips::BI__builtin_msa_clti_u_h:
5036 case Mips::BI__builtin_msa_clti_u_w:
5037 case Mips::BI__builtin_msa_clti_u_d:
5038 case Mips::BI__builtin_msa_maxi_u_b:
5039 case Mips::BI__builtin_msa_maxi_u_h:
5040 case Mips::BI__builtin_msa_maxi_u_w:
5041 case Mips::BI__builtin_msa_maxi_u_d:
5042 case Mips::BI__builtin_msa_mini_u_b:
5043 case Mips::BI__builtin_msa_mini_u_h:
5044 case Mips::BI__builtin_msa_mini_u_w:
5045 case Mips::BI__builtin_msa_mini_u_d:
5046 case Mips::BI__builtin_msa_addvi_b:
5047 case Mips::BI__builtin_msa_addvi_h:
5048 case Mips::BI__builtin_msa_addvi_w:
5049 case Mips::BI__builtin_msa_addvi_d:
5050 case Mips::BI__builtin_msa_bclri_w:
5051 case Mips::BI__builtin_msa_bnegi_w:
5052 case Mips::BI__builtin_msa_bseti_w:
5053 case Mips::BI__builtin_msa_sat_s_w:
5054 case Mips::BI__builtin_msa_sat_u_w:
5055 case Mips::BI__builtin_msa_slli_w:
5056 case Mips::BI__builtin_msa_srai_w:
5057 case Mips::BI__builtin_msa_srari_w:
5058 case Mips::BI__builtin_msa_srli_w:
5059 case Mips::BI__builtin_msa_srlri_w:
5060 case Mips::BI__builtin_msa_subvi_b:
5061 case Mips::BI__builtin_msa_subvi_h:
5062 case Mips::BI__builtin_msa_subvi_w:
5063 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31;
break;
5064 case Mips::BI__builtin_msa_binsli_w:
5065 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31;
break;
5067 case Mips::BI__builtin_msa_bclri_d:
5068 case Mips::BI__builtin_msa_bnegi_d:
5069 case Mips::BI__builtin_msa_bseti_d:
5070 case Mips::BI__builtin_msa_sat_s_d:
5071 case Mips::BI__builtin_msa_sat_u_d:
5072 case Mips::BI__builtin_msa_slli_d:
5073 case Mips::BI__builtin_msa_srai_d:
5074 case Mips::BI__builtin_msa_srari_d:
5075 case Mips::BI__builtin_msa_srli_d:
5076 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63;
break;
5077 case Mips::BI__builtin_msa_binsli_d:
5078 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63;
break;
5080 case Mips::BI__builtin_msa_ceqi_b:
5081 case Mips::BI__builtin_msa_ceqi_h:
5082 case Mips::BI__builtin_msa_ceqi_w:
5083 case Mips::BI__builtin_msa_ceqi_d:
5084 case Mips::BI__builtin_msa_clti_s_b:
5085 case Mips::BI__builtin_msa_clti_s_h:
5086 case Mips::BI__builtin_msa_clti_s_w:
5087 case Mips::BI__builtin_msa_clti_s_d:
5088 case Mips::BI__builtin_msa_clei_s_b:
5089 case Mips::BI__builtin_msa_clei_s_h:
5090 case Mips::BI__builtin_msa_clei_s_w:
5091 case Mips::BI__builtin_msa_clei_s_d:
5092 case Mips::BI__builtin_msa_maxi_s_b:
5093 case Mips::BI__builtin_msa_maxi_s_h:
5094 case Mips::BI__builtin_msa_maxi_s_w:
5095 case Mips::BI__builtin_msa_maxi_s_d:
5096 case Mips::BI__builtin_msa_mini_s_b:
5097 case Mips::BI__builtin_msa_mini_s_h:
5098 case Mips::BI__builtin_msa_mini_s_w:
5099 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15;
break;
5101 case Mips::BI__builtin_msa_andi_b:
5102 case Mips::BI__builtin_msa_nori_b:
5103 case Mips::BI__builtin_msa_ori_b:
5104 case Mips::BI__builtin_msa_shf_b:
5105 case Mips::BI__builtin_msa_shf_h:
5106 case Mips::BI__builtin_msa_shf_w:
5107 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255;
break;
5108 case Mips::BI__builtin_msa_bseli_b:
5109 case Mips::BI__builtin_msa_bmnzi_b:
5110 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255;
break;
5113 case Mips::BI__builtin_msa_copy_s_b:
5114 case Mips::BI__builtin_msa_copy_u_b:
5115 case Mips::BI__builtin_msa_insve_b:
5116 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15;
break;
5117 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15;
break;
5119 case Mips::BI__builtin_msa_copy_s_h:
5120 case Mips::BI__builtin_msa_copy_u_h:
5121 case Mips::BI__builtin_msa_insve_h:
5122 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7;
break;
5123 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7;
break;
5125 case Mips::BI__builtin_msa_copy_s_w:
5126 case Mips::BI__builtin_msa_copy_u_w:
5127 case Mips::BI__builtin_msa_insve_w:
5128 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3;
break;
5129 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3;
break;
5131 case Mips::BI__builtin_msa_copy_s_d:
5132 case Mips::BI__builtin_msa_copy_u_d:
5133 case Mips::BI__builtin_msa_insve_d:
5134 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1;
break;
5135 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1;
break;
5138 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255;
break;
5139 case Mips::BI__builtin_msa_ldi_h:
5140 case Mips::BI__builtin_msa_ldi_w:
5141 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511;
break;
5142 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1;
break;
5143 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2;
break;
5144 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5145 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5146 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5147 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5148 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1;
break;
5149 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2;
break;
5150 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5151 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5152 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5153 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5157 return BuiltinConstantArgRange(TheCall, i, l, u);
5159 return BuiltinConstantArgRange(TheCall, i, l, u) ||
5160 BuiltinConstantArgMultiple(TheCall, i, m);
5171 bool RequireICE =
false;
5179 unsigned size = strtoul(Str, &End, 10);
5180 assert(End != Str &&
"Missing constant parameter constraint");
5183 return Context.
IntTy;
5187 unsigned size = strtoul(Str, &End, 10);
5188 assert(End != Str &&
"Missing PowerPC MMA type size");
5192 #define PPC_VECTOR_TYPE(typeName, Id, size) \
5193 case size: Type = Context.Id##Ty; break;
5194 #include "clang/Basic/PPCTypes.def"
5195 default: llvm_unreachable(
"Invalid PowerPC MMA vector type");
5197 bool CheckVectorArgs =
false;
5198 while (!CheckVectorArgs) {
5207 CheckVectorArgs =
true;
5215 return Context.
DecodeTypeStr(--Str, Context, Error, RequireICE,
true);
5221 switch (BuiltinID) {
5222 case PPC::BI__builtin_divde:
5223 case PPC::BI__builtin_divdeu:
5224 case PPC::BI__builtin_bpermd:
5225 case PPC::BI__builtin_pdepd:
5226 case PPC::BI__builtin_pextd:
5227 case PPC::BI__builtin_ppc_ldarx:
5228 case PPC::BI__builtin_ppc_stdcx:
5229 case PPC::BI__builtin_ppc_tdw:
5230 case PPC::BI__builtin_ppc_trapd:
5231 case PPC::BI__builtin_ppc_cmpeqb:
5232 case PPC::BI__builtin_ppc_setb:
5233 case PPC::BI__builtin_ppc_mulhd:
5234 case PPC::BI__builtin_ppc_mulhdu:
5235 case PPC::BI__builtin_ppc_maddhd:
5236 case PPC::BI__builtin_ppc_maddhdu:
5237 case PPC::BI__builtin_ppc_maddld:
5238 case PPC::BI__builtin_ppc_load8r:
5239 case PPC::BI__builtin_ppc_store8r:
5240 case PPC::BI__builtin_ppc_insert_exp:
5241 case PPC::BI__builtin_ppc_extract_sig:
5242 case PPC::BI__builtin_ppc_addex:
5243 case PPC::BI__builtin_darn:
5244 case PPC::BI__builtin_darn_raw:
5245 case PPC::BI__builtin_ppc_compare_and_swaplp:
5246 case PPC::BI__builtin_ppc_fetch_and_addlp:
5247 case PPC::BI__builtin_ppc_fetch_and_andlp:
5248 case PPC::BI__builtin_ppc_fetch_and_orlp:
5249 case PPC::BI__builtin_ppc_fetch_and_swaplp:
5259bool Sema::ValueIsRunOfOnes(
CallExpr *TheCall,
unsigned ArgNum) {
5267 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
5271 if (
Result.isShiftedMask() || (~
Result).isShiftedMask())
5275 diag::err_argument_not_contiguous_bit_field)
5279bool Sema::CheckPPCBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
5281 unsigned i = 0, l = 0, u = 0;
5286 return Diag(TheCall->
getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
5289 switch (BuiltinID) {
5290 default:
return false;
5291 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
5292 case PPC::BI__builtin_altivec_crypto_vshasigmad:
5293 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
5294 BuiltinConstantArgRange(TheCall, 2, 0, 15);
5295 case PPC::BI__builtin_altivec_dss:
5296 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
5297 case PPC::BI__builtin_tbegin:
5298 case PPC::BI__builtin_tend:
5299 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5300 case PPC::BI__builtin_tsr:
5301 return BuiltinConstantArgRange(TheCall, 0, 0, 7);
5302 case PPC::BI__builtin_tabortwc:
5303 case PPC::BI__builtin_tabortdc:
5304 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5305 case PPC::BI__builtin_tabortwci:
5306 case PPC::BI__builtin_tabortdci:
5307 return BuiltinConstantArgRange(TheCall, 0, 0, 31) ||
5308 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5312 case PPC::BI__builtin_unpack_longdouble:
5313 if (BuiltinConstantArgRange(TheCall, 1, 0, 1))
5316 case PPC::BI__builtin_pack_longdouble:
5318 return Diag(TheCall->
getBeginLoc(), diag::err_ppc_builtin_requires_abi)
5321 case PPC::BI__builtin_altivec_dst:
5322 case PPC::BI__builtin_altivec_dstt:
5323 case PPC::BI__builtin_altivec_dstst:
5324 case PPC::BI__builtin_altivec_dststt:
5325 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
5326 case PPC::BI__builtin_vsx_xxpermdi:
5327 case PPC::BI__builtin_vsx_xxsldwi:
5328 return BuiltinVSX(TheCall);
5329 case PPC::BI__builtin_unpack_vector_int128:
5330 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5331 case PPC::BI__builtin_altivec_vgnb:
5332 return BuiltinConstantArgRange(TheCall, 1, 2, 7);
5333 case PPC::BI__builtin_vsx_xxeval:
5334 return BuiltinConstantArgRange(TheCall, 3, 0, 255);
5335 case PPC::BI__builtin_altivec_vsldbi:
5336 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5337 case PPC::BI__builtin_altivec_vsrdbi:
5338 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5339 case PPC::BI__builtin_vsx_xxpermx:
5340 return BuiltinConstantArgRange(TheCall, 3, 0, 7);
5341 case PPC::BI__builtin_ppc_tw:
5342 case PPC::BI__builtin_ppc_tdw:
5343 return BuiltinConstantArgRange(TheCall, 2, 1, 31);
5344 case PPC::BI__builtin_ppc_cmprb:
5345 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5348 case PPC::BI__builtin_ppc_rlwnm:
5349 return ValueIsRunOfOnes(TheCall, 2);
5350 case PPC::BI__builtin_ppc_rlwimi:
5351 return BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5352 ValueIsRunOfOnes(TheCall, 3);
5353 case PPC::BI__builtin_ppc_rldimi:
5354 return BuiltinConstantArgRange(TheCall, 2, 0, 63) ||
5355 ValueIsRunOfOnes(TheCall, 3);
5356 case PPC::BI__builtin_ppc_addex: {
5357 if (BuiltinConstantArgRange(TheCall, 2, 0, 3))
5367 case PPC::BI__builtin_ppc_mtfsb0:
5368 case PPC::BI__builtin_ppc_mtfsb1:
5369 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5370 case PPC::BI__builtin_ppc_mtfsf:
5371 return BuiltinConstantArgRange(TheCall, 0, 0, 255);
5372 case PPC::BI__builtin_ppc_mtfsfi:
5373 return BuiltinConstantArgRange(TheCall, 0, 0, 7) ||
5374 BuiltinConstantArgRange(TheCall, 1, 0, 15);
5375 case PPC::BI__builtin_ppc_alignx:
5376 return BuiltinConstantArgPower2(TheCall, 0);
5377 case PPC::BI__builtin_ppc_rdlam:
5378 return ValueIsRunOfOnes(TheCall, 2);
5379 case PPC::BI__builtin_vsx_ldrmb:
5380 case PPC::BI__builtin_vsx_strmb:
5381 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
5382 case PPC::BI__builtin_altivec_vcntmbb:
5383 case PPC::BI__builtin_altivec_vcntmbh:
5384 case PPC::BI__builtin_altivec_vcntmbw:
5385 case PPC::BI__builtin_altivec_vcntmbd:
5386 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5387 case PPC::BI__builtin_vsx_xxgenpcvbm:
5388 case PPC::BI__builtin_vsx_xxgenpcvhm:
5389 case PPC::BI__builtin_vsx_xxgenpcvwm:
5390 case PPC::BI__builtin_vsx_xxgenpcvdm:
5391 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
5392 case PPC::BI__builtin_ppc_test_data_class: {
5400 diag::err_ppc_invalid_test_data_class_type);
5401 return BuiltinConstantArgRange(TheCall, 1, 0, 127);
5403 case PPC::BI__builtin_ppc_maxfe:
5404 case PPC::BI__builtin_ppc_minfe:
5405 case PPC::BI__builtin_ppc_maxfl:
5406 case PPC::BI__builtin_ppc_minfl:
5407 case PPC::BI__builtin_ppc_maxfs:
5408 case PPC::BI__builtin_ppc_minfs: {
5410 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
5411 BuiltinID == PPC::BI__builtin_ppc_minfe))
5412 return Diag(TheCall->
getBeginLoc(), diag::err_target_unsupported_type)
5417 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
5418 BuiltinID == PPC::BI__builtin_ppc_minfl)
5420 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
5421 BuiltinID == PPC::BI__builtin_ppc_minfs)
5423 for (
unsigned I = 0, E = TheCall->
getNumArgs(); I < E; ++I)
5426 diag::err_typecheck_convert_incompatible)
5430#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
5431 case PPC::BI__builtin_##Name: \
5432 return BuiltinPPCMMACall(TheCall, BuiltinID, Types);
5433#include "clang/Basic/BuiltinsPPC.def"
5435 return BuiltinConstantArgRange(TheCall, i, l, u);
5444 QualType CoreType =
Type.getCanonicalType().getUnqualifiedType();
5445#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
5447#include
"clang/Basic/PPCTypes.def"
5449 Diag(
TypeLoc, diag::err_ppc_invalid_use_mma_type);
5465 for (
unsigned i = 1; i < TheCall->
getNumArgs(); ++i) {
5469 if (VecTyA ==
nullptr && VecTyB ==
nullptr)
5472 if (VecTyA && VecTyB) {
5473 bool retValue =
false;
5474 if (VecTyA->getElementType() != VecTyB->getElementType()) {
5478 diag::err_vec_builtin_incompatible_vector)
5483 if (VecTyA->getNumElements() != VecTyB->getNumElements()) {
5487 S->
Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
5499 S->
Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
5509 for (
unsigned i = 0; i < TheCall->
getNumArgs(); ++i) {
5511 if (Check(PassedType)) {
5514 ExpectedType, VecTyA->getNumElements(), VecTyA->getVectorKind());
5516 diag::err_typecheck_convert_incompatible)
5526 return !PassedType->hasFloatingRepresentation();
5529 checkAllFloatTypes);
5546 if (
const auto *VecTy = PassedType->getAs<
VectorType>())
5547 return VecTy->getElementType()->isDoubleType();
5556 return !PassedType->hasUnsignedIntegerRepresentation();
5559 checkAllUnsignedTypes);
5574 switch (BuiltinID) {
5575 case Builtin::BI__builtin_hlsl_elementwise_all:
5576 case Builtin::BI__builtin_hlsl_elementwise_any: {
5581 case Builtin::BI__builtin_hlsl_elementwise_clamp: {
5586 if (BuiltinElementwiseTernaryMath(
5592 case Builtin::BI__builtin_hlsl_dot: {
5603 case Builtin::BI__builtin_hlsl_elementwise_rcp: {
5606 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5610 case Builtin::BI__builtin_hlsl_elementwise_rsqrt:
5611 case Builtin::BI__builtin_hlsl_elementwise_frac: {
5614 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5618 case Builtin::BI__builtin_hlsl_elementwise_isinf: {
5621 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5626 case Builtin::BI__builtin_hlsl_lerp: {
5631 if (BuiltinElementwiseTernaryMath(TheCall))
5637 case Builtin::BI__builtin_hlsl_mad: {
5642 if (BuiltinElementwiseTernaryMath(
5650 case Builtin::BI__builtin_elementwise_bitreverse: {
5655 case Builtin::BI__builtin_elementwise_ceil:
5656 case Builtin::BI__builtin_elementwise_cos:
5657 case Builtin::BI__builtin_elementwise_exp:
5658 case Builtin::BI__builtin_elementwise_exp2:
5659 case Builtin::BI__builtin_elementwise_floor:
5660 case Builtin::BI__builtin_elementwise_log:
5661 case Builtin::BI__builtin_elementwise_log2:
5662 case Builtin::BI__builtin_elementwise_log10:
5663 case Builtin::BI__builtin_elementwise_pow:
5664 case Builtin::BI__builtin_elementwise_roundeven:
5665 case Builtin::BI__builtin_elementwise_sin:
5666 case Builtin::BI__builtin_elementwise_sqrt:
5667 case Builtin::BI__builtin_elementwise_trunc: {
5676bool Sema::CheckAMDGCNBuiltinFunctionCall(
unsigned BuiltinID,
5679 unsigned OrderIndex, ScopeIndex;
5680 switch (BuiltinID) {
5681 case AMDGPU::BI__builtin_amdgcn_get_fpenv:
5682 case AMDGPU::BI__builtin_amdgcn_set_fpenv:
5684 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
5685 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
5686 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
5687 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
5691 case AMDGPU::BI__builtin_amdgcn_fence:
5700 auto ArgExpr = Arg.
get();
5703 if (!ArgExpr->EvaluateAsInt(ArgResult,
Context))
5704 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
5705 << ArgExpr->getType();
5706 auto Ord = ArgResult.
Val.
getInt().getZExtValue();
5710 if (!llvm::isValidAtomicOrderingCABI(Ord))
5711 return Diag(ArgExpr->getBeginLoc(),
5712 diag::warn_atomic_op_has_invalid_memory_order)
5713 << 0 << ArgExpr->getSourceRange();
5714 switch (
static_cast<llvm::AtomicOrderingCABI
>(Ord)) {
5715 case llvm::AtomicOrderingCABI::relaxed:
5716 case llvm::AtomicOrderingCABI::consume:
5717 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
5718 return Diag(ArgExpr->getBeginLoc(),
5719 diag::warn_atomic_op_has_invalid_memory_order)
5720 << 0 << ArgExpr->getSourceRange();
5722 case llvm::AtomicOrderingCABI::acquire:
5723 case llvm::AtomicOrderingCABI::release:
5724 case llvm::AtomicOrderingCABI::acq_rel:
5725 case llvm::AtomicOrderingCABI::seq_cst:
5729 Arg = TheCall->
getArg(ScopeIndex);
5730 ArgExpr = Arg.
get();
5733 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1,
Context))
5734 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
5735 << ArgExpr->getType();
5740bool Sema::CheckRISCVLMUL(
CallExpr *TheCall,
unsigned ArgNum) {
5749 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
5753 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
5756 return Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
5762 assert((EGW == 128 || EGW == 256) &&
"EGW can only be 128 or 256 bits");
5768 unsigned MinElemCount = Info.
EC.getKnownMinValue();
5770 unsigned EGS = EGW / ElemSize;
5773 if (EGS <= MinElemCount)
5777 assert(EGS % MinElemCount == 0);
5778 unsigned VScaleFactor = EGS / MinElemCount;
5780 unsigned MinRequiredVLEN = VScaleFactor * llvm::RISCV::RVVBitsPerBlock;
5781 std::string RequiredExt =
"zvl" + std::to_string(MinRequiredVLEN) +
"b";
5784 diag::err_riscv_type_requires_extension) <<
Type << RequiredExt;
5789bool Sema::CheckRISCVBuiltinFunctionCall(
const TargetInfo &TI,
5794 switch (BuiltinID) {
5797 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
5798 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
5799 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
5800 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
5801 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
5802 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
5803 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
5804 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
5805 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
5806 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
5807 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
5808 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
5809 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
5810 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
5811 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
5812 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
5813 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
5814 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
5815 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
5816 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
5817 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
5818 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
5819 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
5820 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
5821 case RISCVVector::BI__builtin_rvv_vmulh_vv:
5822 case RISCVVector::BI__builtin_rvv_vmulh_vx:
5823 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
5824 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
5825 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
5826 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
5827 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
5828 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
5829 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
5830 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
5831 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
5832 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
5833 case RISCVVector::BI__builtin_rvv_vsmul_vv:
5834 case RISCVVector::BI__builtin_rvv_vsmul_vx:
5835 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
5836 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
5837 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
5838 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
5839 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
5840 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
5841 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
5842 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
5843 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
5844 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
5850 diag::err_riscv_builtin_requires_extension)
5857 switch (BuiltinID) {
5858 case RISCVVector::BI__builtin_rvv_vsetvli:
5859 return BuiltinConstantArgRange(TheCall, 1, 0, 3) ||
5860 CheckRISCVLMUL(TheCall, 2);
5861 case RISCVVector::BI__builtin_rvv_vsetvlimax:
5862 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5863 CheckRISCVLMUL(TheCall, 1);
5864 case RISCVVector::BI__builtin_rvv_vget_v: {
5875 MaxIndex = (VecInfo.
EC.getKnownMinValue() * VecInfo.
NumVectors) /
5876 (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors);
5877 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5879 case RISCVVector::BI__builtin_rvv_vset_v: {
5890 MaxIndex = (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors) /
5892 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5895 case RISCVVector::BI__builtin_rvv_vaeskf1_vi_tu:
5896 case RISCVVector::BI__builtin_rvv_vaeskf2_vi_tu:
5897 case RISCVVector::BI__builtin_rvv_vaeskf2_vi:
5898 case RISCVVector::BI__builtin_rvv_vsm4k_vi_tu: {
5903 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5905 case RISCVVector::BI__builtin_rvv_vsm3c_vi_tu:
5906 case RISCVVector::BI__builtin_rvv_vsm3c_vi: {
5909 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5911 case RISCVVector::BI__builtin_rvv_vaeskf1_vi:
5912 case RISCVVector::BI__builtin_rvv_vsm4k_vi: {
5915 BuiltinConstantArgRange(TheCall, 1, 0, 31);
5917 case RISCVVector::BI__builtin_rvv_vaesdf_vv:
5918 case RISCVVector::BI__builtin_rvv_vaesdf_vs:
5919 case RISCVVector::BI__builtin_rvv_vaesdm_vv:
5920 case RISCVVector::BI__builtin_rvv_vaesdm_vs:
5921 case RISCVVector::BI__builtin_rvv_vaesef_vv:
5922 case RISCVVector::BI__builtin_rvv_vaesef_vs:
5923 case RISCVVector::BI__builtin_rvv_vaesem_vv:
5924 case RISCVVector::BI__builtin_rvv_vaesem_vs:
5925 case RISCVVector::BI__builtin_rvv_vaesz_vs:
5926 case RISCVVector::BI__builtin_rvv_vsm4r_vv:
5927 case RISCVVector::BI__builtin_rvv_vsm4r_vs:
5928 case RISCVVector::BI__builtin_rvv_vaesdf_vv_tu:
5929 case RISCVVector::BI__builtin_rvv_vaesdf_vs_tu:
5930 case RISCVVector::BI__builtin_rvv_vaesdm_vv_tu:
5931 case RISCVVector::BI__builtin_rvv_vaesdm_vs_tu:
5932 case RISCVVector::BI__builtin_rvv_vaesef_vv_tu:
5933 case RISCVVector::BI__builtin_rvv_vaesef_vs_tu:
5934 case RISCVVector::BI__builtin_rvv_vaesem_vv_tu:
5935 case RISCVVector::BI__builtin_rvv_vaesem_vs_tu:
5936 case RISCVVector::BI__builtin_rvv_vaesz_vs_tu:
5937 case RISCVVector::BI__builtin_rvv_vsm4r_vv_tu:
5938 case RISCVVector::BI__builtin_rvv_vsm4r_vs_tu: {
5944 case RISCVVector::BI__builtin_rvv_vsha2ch_vv:
5945 case RISCVVector::BI__builtin_rvv_vsha2cl_vv:
5946 case RISCVVector::BI__builtin_rvv_vsha2ms_vv:
5947 case RISCVVector::BI__builtin_rvv_vsha2ch_vv_tu:
5948 case RISCVVector::BI__builtin_rvv_vsha2cl_vv_tu:
5949 case RISCVVector::BI__builtin_rvv_vsha2ms_vv_tu: {
5956 if (ElemSize == 64 && !TI.
hasFeature(
"zvknhb"))
5958 diag::err_riscv_builtin_requires_extension)
5966 case RISCVVector::BI__builtin_rvv_sf_vc_i_se:
5968 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5969 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5970 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5971 BuiltinConstantArgRange(TheCall, 3, -16, 15) ||
5972 CheckRISCVLMUL(TheCall, 5);
5973 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
5975 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5976 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5977 BuiltinConstantArgRange(TheCall, 3, -16, 15);
5978 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
5979 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
5981 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5982 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5983 BuiltinConstantArgRange(TheCall, 2, -16, 15);
5984 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
5985 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
5987 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5988 BuiltinConstantArgRange(TheCall, 2, -16, 15);
5989 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
5990 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
5991 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
5992 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
5993 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
5994 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
5996 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5997 BuiltinConstantArgRange(TheCall, 3, -16, 15);
5998 case RISCVVector::BI__builtin_rvv_sf_vc_x_se:
6000 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6001 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
6002 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
6003 CheckRISCVLMUL(TheCall, 5);
6004 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
6005 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
6007 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
6008 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
6010 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6011 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6012 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
6013 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
6014 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
6015 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
6017 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
6018 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
6019 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
6020 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
6022 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
6023 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
6024 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
6025 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
6026 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
6027 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
6028 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
6029 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
6031 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
6032 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
6034 return BuiltinConstantArgRange(TheCall, 0, 0, 1) ||
6035 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6036 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
6037 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
6038 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
6039 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
6040 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
6041 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
6043 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
6044 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
6046 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
6048 case RISCV::BI__builtin_riscv_aes32dsi:
6049 case RISCV::BI__builtin_riscv_aes32dsmi:
6050 case RISCV::BI__builtin_riscv_aes32esi:
6051 case RISCV::BI__builtin_riscv_aes32esmi:
6052 case RISCV::BI__builtin_riscv_sm4ks:
6053 case RISCV::BI__builtin_riscv_sm4ed:
6054 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6056 case RISCV::BI__builtin_riscv_aes64ks1i:
6057 return BuiltinConstantArgRange(TheCall, 1, 0, 10);
6059 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
6060 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
6061 case RISCVVector::BI__builtin_rvv_vaadd_vv:
6062 case RISCVVector::BI__builtin_rvv_vaadd_vx:
6063 case RISCVVector::BI__builtin_rvv_vasubu_vv:
6064 case RISCVVector::BI__builtin_rvv_vasubu_vx:
6065 case RISCVVector::BI__builtin_rvv_vasub_vv:
6066 case RISCVVector::BI__builtin_rvv_vasub_vx:
6067 case RISCVVector::BI__builtin_rvv_vsmul_vv:
6068 case RISCVVector::BI__builtin_rvv_vsmul_vx:
6069 case RISCVVector::BI__builtin_rvv_vssra_vv:
6070 case RISCVVector::BI__builtin_rvv_vssra_vx:
6071 case RISCVVector::BI__builtin_rvv_vssrl_vv:
6072 case RISCVVector::BI__builtin_rvv_vssrl_vx:
6073 case RISCVVector::BI__builtin_rvv_vnclip_wv:
6074 case RISCVVector::BI__builtin_rvv_vnclip_wx:
6075 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
6076 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
6077 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6078 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
6079 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
6080 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
6081 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
6082 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
6083 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
6084 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
6085 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
6086 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
6087 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
6088 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
6089 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
6090 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
6091 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
6092 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
6093 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
6094 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
6095 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
6096 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
6097 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
6098 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
6099 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
6100 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
6101 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
6102 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
6103 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
6104 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
6105 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
6106 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
6107 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
6108 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
6109 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
6110 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
6111 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
6112 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
6113 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
6114 return BuiltinConstantArgRange(TheCall, 3, 0, 3);
6115 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
6116 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
6117 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
6118 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
6119 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
6120 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
6121 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
6122 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
6123 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
6124 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
6125 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
6126 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
6127 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
6128 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
6129 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
6130 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
6131 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
6132 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
6133 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
6134 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
6135 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
6136 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
6137 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
6138 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
6139 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
6140 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
6141 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
6142 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
6143 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
6144 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
6145 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
6146 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
6147 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
6148 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
6149 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
6150 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
6151 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
6152 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
6153 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
6154 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
6155 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
6156 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
6157 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
6158 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
6159 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
6160 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
6161 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
6162 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
6163 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
6164 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
6165 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
6166 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
6167 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
6168 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
6169 return BuiltinConstantArgRange(TheCall, 4, 0, 3);
6170 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
6171 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
6172 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
6173 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
6174 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
6175 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
6176 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
6177 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
6178 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
6179 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
6180 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
6181 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
6182 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
6183 return BuiltinConstantArgRange(TheCall, 1, 0, 4);
6184 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
6185 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
6186 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
6187 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
6188 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
6189 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
6190 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
6191 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
6192 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
6193 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
6194 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
6195 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
6196 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
6197 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
6198 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
6199 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
6200 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
6201 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
6202 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
6203 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
6204 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
6205 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
6206 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
6207 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
6208 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
6209 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
6210 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
6211 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
6212 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
6213 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
6214 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
6215 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
6216 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
6217 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
6218 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
6219 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
6220 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
6221 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
6222 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
6223 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
6224 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
6225 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
6226 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
6227 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
6228 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
6229 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
6230 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
6231 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
6232 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
6233 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
6234 return BuiltinConstantArgRange(TheCall, 2, 0, 4);
6235 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
6236 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
6237 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
6238 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
6239 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
6240 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
6241 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
6242 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
6243 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
6244 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
6245 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
6246 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
6247 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
6248 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
6249 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
6250 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
6251 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
6252 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
6253 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
6254 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
6255 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
6256 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
6257 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
6258 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
6259 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
6260 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
6261 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
6262 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
6263 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
6264 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
6265 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
6266 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
6267 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
6268 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
6269 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
6270 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
6271 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
6272 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
6273 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
6274 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
6275 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
6276 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
6277 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
6278 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
6279 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
6280 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
6281 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
6282 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
6283 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
6284 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
6285 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
6286 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
6287 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
6288 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
6289 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
6290 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
6291 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
6292 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
6293 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
6294 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
6295 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
6296 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
6297 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
6298 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
6299 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
6300 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
6301 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
6302 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
6303 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
6304 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
6305 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
6306 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
6307 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
6308 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
6309 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
6310 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
6311 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
6312 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
6313 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
6314 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
6315 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
6316 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
6317 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
6318 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
6319 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
6320 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
6321 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
6322 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
6323 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
6324 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
6325 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
6326 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
6327 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
6328 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
6329 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
6330 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
6331 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
6332 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
6333 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
6334 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
6335 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
6336 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
6337 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
6338 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
6339 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
6340 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
6341 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
6342 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
6343 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
6344 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
6345 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
6346 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
6347 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
6348 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
6349 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
6350 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
6351 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
6352 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
6353 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
6354 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
6355 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
6356 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
6357 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
6358 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
6359 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
6360 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
6361 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
6362 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
6363 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
6364 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
6365 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
6366 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
6367 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
6368 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
6369 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
6370 return BuiltinConstantArgRange(TheCall, 3, 0, 4);
6371 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
6372 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
6373 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
6374 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
6375 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
6376 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
6377 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
6378 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
6379 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
6380 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
6381 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
6382 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
6383 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
6384 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
6385 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
6386 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
6387 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
6388 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
6389 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
6390 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
6391 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
6392 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
6393 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
6394 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
6395 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
6396 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
6397 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
6398 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
6399 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
6400 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
6401 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
6402 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
6403 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
6404 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
6405 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
6406 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
6407 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
6408 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
6409 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
6410 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
6411 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
6412 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
6413 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
6414 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
6415 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
6416 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
6417 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
6418 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
6419 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
6420 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
6421 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
6422 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
6423 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
6424 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
6425 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
6426 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
6427 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
6428 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
6429 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
6430 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
6431 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
6432 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
6433 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
6434 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
6435 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
6436 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
6437 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
6438 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
6439 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
6440 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
6441 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
6442 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
6443 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
6444 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
6445 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
6446 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
6447 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
6448 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
6449 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
6450 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
6451 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
6452 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
6453 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
6454 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
6455 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
6456 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
6457 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
6458 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
6459 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
6460 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
6461 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
6462 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
6463 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
6464 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
6465 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
6466 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
6467 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
6468 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
6469 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
6470 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
6471 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
6472 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
6473 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
6474 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
6475 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
6476 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
6477 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
6478 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
6479 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
6480 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
6481 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
6482 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
6483 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
6484 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
6485 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
6486 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
6487 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
6488 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
6489 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
6490 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
6491 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
6492 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
6493 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
6494 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
6495 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
6496 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
6497 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
6498 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
6499 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
6500 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
6501 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
6502 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
6503 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
6504 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
6505 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
6506 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
6507 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
6508 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
6509 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
6510 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
6511 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
6512 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
6513 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
6514 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
6515 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
6516 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
6517 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
6518 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
6519 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
6520 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
6521 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
6522 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
6523 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
6524 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
6525 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
6526 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
6527 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
6528 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
6529 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
6530 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
6531 return BuiltinConstantArgRange(TheCall, 4, 0, 4);
6532 case RISCV::BI__builtin_riscv_ntl_load:
6533 case RISCV::BI__builtin_riscv_ntl_store:
6536 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
6537 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
6538 "Unexpected RISC-V nontemporal load/store builtin!");
6539 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
6540 unsigned NumArgs = IsStore ? 3 : 2;
6551 BuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
6560 PointerArg = PointerArgResult.
get();
6564 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
6575 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
6600bool Sema::CheckSystemZBuiltinFunctionCall(
unsigned BuiltinID,
6602 if (BuiltinID == SystemZ::BI__builtin_tabort) {
6604 if (std::optional<llvm::APSInt> AbortCode =
6606 if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
6607 return Diag(Arg->
getBeginLoc(), diag::err_systemz_invalid_tabort_code)
6613 unsigned i = 0, l = 0, u = 0;
6614 switch (BuiltinID) {
6615 default:
return false;
6616 case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15;
break;
6617 case SystemZ::BI__builtin_s390_verimb:
6618 case SystemZ::BI__builtin_s390_verimh:
6619 case SystemZ::BI__builtin_s390_verimf:
6620 case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255;
break;
6621 case SystemZ::BI__builtin_s390_vfaeb:
6622 case SystemZ::BI__builtin_s390_vfaeh:
6623 case SystemZ::BI__builtin_s390_vfaef:
6624 case SystemZ::BI__builtin_s390_vfaebs:
6625 case SystemZ::BI__builtin_s390_vfaehs:
6626 case SystemZ::BI__builtin_s390_vfaefs:
6627 case SystemZ::BI__builtin_s390_vfaezb:
6628 case SystemZ::BI__builtin_s390_vfaezh:
6629 case SystemZ::BI__builtin_s390_vfaezf:
6630 case SystemZ::BI__builtin_s390_vfaezbs:
6631 case SystemZ::BI__builtin_s390_vfaezhs:
6632 case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15;
break;
6633 case SystemZ::BI__builtin_s390_vfisb:
6634 case SystemZ::BI__builtin_s390_vfidb:
6635 return BuiltinConstantArgRange(TheCall, 1, 0, 15) ||
6636 BuiltinConstantArgRange(TheCall, 2, 0, 15);
6637 case SystemZ::BI__builtin_s390_vftcisb:
6638 case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095;
break;
6639 case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15;
break;
6640 case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15;
break;
6641 case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15;
break;
6642 case SystemZ::BI__builtin_s390_vstrcb:
6643 case SystemZ::BI__builtin_s390_vstrch:
6644 case SystemZ::BI__builtin_s390_vstrcf:
6645 case SystemZ::BI__builtin_s390_vstrczb:
6646 case SystemZ::BI__builtin_s390_vstrczh:
6647 case SystemZ::BI__builtin_s390_vstrczf:
6648 case SystemZ::BI__builtin_s390_vstrcbs:
6649 case SystemZ::BI__builtin_s390_vstrchs:
6650 case SystemZ::BI__builtin_s390_vstrcfs:
6651 case SystemZ::BI__builtin_s390_vstrczbs:
6652 case SystemZ::BI__builtin_s390_vstrczhs:
6653 case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15;
break;
6654 case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15;
break;
6655 case SystemZ::BI__builtin_s390_vfminsb:
6656 case SystemZ::BI__builtin_s390_vfmaxsb:
6657 case SystemZ::BI__builtin_s390_vfmindb:
6658 case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15;
break;
6659 case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7;
break;
6660 case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7;
break;
6661 case SystemZ::BI__builtin_s390_vclfnhs:
6662 case SystemZ::BI__builtin_s390_vclfnls:
6663 case SystemZ::BI__builtin_s390_vcfn:
6664 case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15;
break;
6665 case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15;
break;
6667 return BuiltinConstantArgRange(TheCall, i, l, u);
6670bool Sema::CheckWebAssemblyBuiltinFunctionCall(
const TargetInfo &TI,
6673 switch (BuiltinID) {
6674 case WebAssembly::BI__builtin_wasm_ref_null_extern:
6675 return BuiltinWasmRefNullExtern(TheCall);
6676 case WebAssembly::BI__builtin_wasm_ref_null_func:
6677 return BuiltinWasmRefNullFunc(TheCall);
6678 case WebAssembly::BI__builtin_wasm_table_get:
6679 return BuiltinWasmTableGet(TheCall);
6680 case WebAssembly::BI__builtin_wasm_table_set:
6681 return BuiltinWasmTableSet(TheCall);
6682 case WebAssembly::BI__builtin_wasm_table_size:
6683 return BuiltinWasmTableSize(TheCall);
6684 case WebAssembly::BI__builtin_wasm_table_grow:
6685 return BuiltinWasmTableGrow(TheCall);
6686 case WebAssembly::BI__builtin_wasm_table_fill:
6687 return BuiltinWasmTableFill(TheCall);
6688 case WebAssembly::BI__builtin_wasm_table_copy:
6689 return BuiltinWasmTableCopy(TheCall);
6696 const llvm::StringMap<bool> &FeatureMap) {
6700 unsigned MinElts = Info.
EC.getKnownMinValue();
6703 !FeatureMap.lookup(
"zve64d"))
6704 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64d";
6709 !FeatureMap.lookup(
"zve64x"))
6710 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64x";
6712 !FeatureMap.lookup(
"zvfhmin"))
6713 Diag(Loc, diag::err_riscv_type_requires_extension, D)
6714 << Ty <<
"zvfh or zvfhmin";
6716 !FeatureMap.lookup(
"experimental-zvfbfmin"))
6717 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zvfbfmin";
6719 !FeatureMap.lookup(
"zve32f"))
6720 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32f";
6723 else if (!FeatureMap.lookup(
"zve32x"))
6724 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32x";
6727bool Sema::CheckNVPTXBuiltinFunctionCall(
const TargetInfo &TI,
6730 switch (BuiltinID) {
6731 case NVPTX::BI__nvvm_cp_async_ca_shared_global_4:
6732 case NVPTX::BI__nvvm_cp_async_ca_shared_global_8:
6733 case NVPTX::BI__nvvm_cp_async_ca_shared_global_16:
6734 case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
6742bool Sema::CheckX86BuiltinRoundingOrSAE(
unsigned BuiltinID,
CallExpr *TheCall) {
6746 unsigned ArgNum = 0;
6747 switch (BuiltinID) {
6750 case X86::BI__builtin_ia32_vcvttsd2si32:
6751 case X86::BI__builtin_ia32_vcvttsd2si64:
6752 case X86::BI__builtin_ia32_vcvttsd2usi32:
6753 case X86::BI__builtin_ia32_vcvttsd2usi64:
6754 case X86::BI__builtin_ia32_vcvttss2si32:
6755 case X86::BI__builtin_ia32_vcvttss2si64:
6756 case X86::BI__builtin_ia32_vcvttss2usi32:
6757 case X86::BI__builtin_ia32_vcvttss2usi64:
6758 case X86::BI__builtin_ia32_vcvttsh2si32:
6759 case X86::BI__builtin_ia32_vcvttsh2si64:
6760 case X86::BI__builtin_ia32_vcvttsh2usi32:
6761 case X86::BI__builtin_ia32_vcvttsh2usi64:
6764 case X86::BI__builtin_ia32_maxpd512:
6765 case X86::BI__builtin_ia32_maxps512:
6766 case X86::BI__builtin_ia32_minpd512:
6767 case X86::BI__builtin_ia32_minps512:
6768 case X86::BI__builtin_ia32_maxph512:
6769 case X86::BI__builtin_ia32_minph512:
6772 case X86::BI__builtin_ia32_vcvtph2pd512_mask:
6773 case X86::BI__builtin_ia32_vcvtph2psx512_mask:
6774 case X86::BI__builtin_ia32_cvtps2pd512_mask:
6775 case X86::BI__builtin_ia32_cvttpd2dq512_mask:
6776 case X86::BI__builtin_ia32_cvttpd2qq512_mask:
6777 case X86::BI__builtin_ia32_cvttpd2udq512_mask:
6778 case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
6779 case X86::BI__builtin_ia32_cvttps2dq512_mask:
6780 case X86::BI__builtin_ia32_cvttps2qq512_mask:
6781 case X86::BI__builtin_ia32_cvttps2udq512_mask:
6782 case X86::BI__builtin_ia32_cvttps2uqq512_mask:
6783 case X86::BI__builtin_ia32_vcvttph2w512_mask:
6784 case X86::BI__builtin_ia32_vcvttph2uw512_mask:
6785 case X86::BI__builtin_ia32_vcvttph2dq512_mask:
6786 case X86::BI__builtin_ia32_vcvttph2udq512_mask:
6787 case X86::BI__builtin_ia32_vcvttph2qq512_mask:
6788 case X86::BI__builtin_ia32_vcvttph2uqq512_mask:
6789 case X86::BI__builtin_ia32_exp2pd_mask:
6790 case X86::BI__builtin_ia32_exp2ps_mask:
6791 case X86::BI__builtin_ia32_getexppd512_mask:
6792 case X86::BI__builtin_ia32_getexpps512_mask:
6793 case X86::BI__builtin_ia32_getexpph512_mask:
6794 case X86::BI__builtin_ia32_rcp28pd_mask:
6795 case X86::BI__builtin_ia32_rcp28ps_mask:
6796 case X86::BI__builtin_ia32_rsqrt28pd_mask:
6797 case X86::BI__builtin_ia32_rsqrt28ps_mask:
6798 case X86::BI__builtin_ia32_vcomisd:
6799 case X86::BI__builtin_ia32_vcomiss:
6800 case X86::BI__builtin_ia32_vcomish:
6801 case X86::BI__builtin_ia32_vcvtph2ps512_mask:
6804 case X86::BI__builtin_ia32_cmppd512_mask:
6805 case X86::BI__builtin_ia32_cmpps512_mask:
6806 case X86::BI__builtin_ia32_cmpsd_mask:
6807 case X86::BI__builtin_ia32_cmpss_mask:
6808 case X86::BI__builtin_ia32_cmpsh_mask:
6809 case X86::BI__builtin_ia32_vcvtsh2sd_round_mask:
6810 case X86::BI__builtin_ia32_vcvtsh2ss_round_mask:
6811 case X86::BI__builtin_ia32_cvtss2sd_round_mask:
6812 case X86::BI__builtin_ia32_getexpsd128_round_mask:
6813 case X86::BI__builtin_ia32_getexpss128_round_mask:
6814 case X86::BI__builtin_ia32_getexpsh128_round_mask:
6815 case X86::BI__builtin_ia32_getmantpd512_mask:
6816 case X86::BI__builtin_ia32_getmantps512_mask:
6817 case X86::BI__builtin_ia32_getmantph512_mask:
6818 case X86::BI__builtin_ia32_maxsd_round_mask:
6819 case X86::BI__builtin_ia32_maxss_round_mask:
6820 case X86::BI__builtin_ia32_maxsh_round_mask:
6821 case X86::BI__builtin_ia32_minsd_round_mask:
6822 case X86::BI__builtin_ia32_minss_round_mask:
6823 case X86::BI__builtin_ia32_minsh_round_mask:
6824 case X86::BI__builtin_ia32_rcp28sd_round_mask:
6825 case X86::BI__builtin_ia32_rcp28ss_round_mask:
6826 case X86::BI__builtin_ia32_reducepd512_mask:
6827 case X86::BI__builtin_ia32_reduceps512_mask:
6828 case X86::BI__builtin_ia32_reduceph512_mask:
6829 case X86::BI__builtin_ia32_rndscalepd_mask:
6830 case X86::BI__builtin_ia32_rndscaleps_mask:
6831 case X86::BI__builtin_ia32_rndscaleph_mask:
6832 case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
6833 case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
6836 case X86::BI__builtin_ia32_fixupimmpd512_mask:
6837 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
6838 case X86::BI__builtin_ia32_fixupimmps512_mask:
6839 case X86::BI__builtin_ia32_fixupimmps512_maskz:
6840 case X86::BI__builtin_ia32_fixupimmsd_mask:
6841 case X86::BI__builtin_ia32_fixupimmsd_maskz:
6842 case X86::BI__builtin_ia32_fixupimmss_mask:
6843 case X86::BI__builtin_ia32_fixupimmss_maskz:
6844 case X86::BI__builtin_ia32_getmantsd_round_mask:
6845 case X86::BI__builtin_ia32_getmantss_round_mask:
6846 case X86::BI__builtin_ia32_getmantsh_round_mask:
6847 case X86::BI__builtin_ia32_rangepd512_mask:
6848 case X86::BI__builtin_ia32_rangeps512_mask:
6849 case X86::BI__builtin_ia32_rangesd128_round_mask:
6850 case X86::BI__builtin_ia32_rangess128_round_mask:
6851 case X86::BI__builtin_ia32_reducesd_mask:
6852 case X86::BI__builtin_ia32_reducess_mask:
6853 case X86::BI__builtin_ia32_reducesh_mask:
6854 case X86::BI__builtin_ia32_rndscalesd_round_mask:
6855 case X86::BI__builtin_ia32_rndscaless_round_mask:
6856 case X86::BI__builtin_ia32_rndscalesh_round_mask:
6859 case X86::BI__builtin_ia32_vcvtsd2si64:
6860 case X86::BI__builtin_ia32_vcvtsd2si32:
6861 case X86::BI__builtin_ia32_vcvtsd2usi32:
6862 case X86::BI__builtin_ia32_vcvtsd2usi64:
6863 case X86::BI__builtin_ia32_vcvtss2si32:
6864 case X86::BI__builtin_ia32_vcvtss2si64:
6865 case X86::BI__builtin_ia32_vcvtss2usi32:
6866 case X86::BI__builtin_ia32_vcvtss2usi64:
6867 case X86::BI__builtin_ia32_vcvtsh2si32:
6868 case X86::BI__builtin_ia32_vcvtsh2si64:
6869 case X86::BI__builtin_ia32_vcvtsh2usi32:
6870 case X86::BI__builtin_ia32_vcvtsh2usi64:
6871 case X86::BI__builtin_ia32_sqrtpd512:
6872 case X86::BI__builtin_ia32_sqrtps512:
6873 case X86::BI__builtin_ia32_sqrtph512:
6877 case X86::BI__builtin_ia32_addph512:
6878 case X86::BI__builtin_ia32_divph512:
6879 case X86::BI__builtin_ia32_mulph512:
6880 case X86::BI__builtin_ia32_subph512:
6881 case X86::BI__builtin_ia32_addpd512:
6882 case X86::BI__builtin_ia32_addps512:
6883 case X86::BI__builtin_ia32_divpd512:
6884 case X86::BI__builtin_ia32_divps512:
6885 case X86::BI__builtin_ia32_mulpd512:
6886 case X86::BI__builtin_ia32_mulps512:
6887 case X86::BI__builtin_ia32_subpd512:
6888 case X86::BI__builtin_ia32_subps512:
6889 case X86::BI__builtin_ia32_cvtsi2sd64:
6890 case X86::BI__builtin_ia32_cvtsi2ss32:
6891 case X86::BI__builtin_ia32_cvtsi2ss64:
6892 case X86::BI__builtin_ia32_cvtusi2sd64:
6893 case X86::BI__builtin_ia32_cvtusi2ss32:
6894 case X86::BI__builtin_ia32_cvtusi2ss64:
6895 case X86::BI__builtin_ia32_vcvtusi2sh:
6896 case X86::BI__builtin_ia32_vcvtusi642sh:
6897 case X86::BI__builtin_ia32_vcvtsi2sh:
6898 case X86::BI__builtin_ia32_vcvtsi642sh:
6902 case X86::BI__builtin_ia32_cvtdq2ps512_mask:
6903 case X86::BI__builtin_ia32_cvtudq2ps512_mask:
6904 case X86::BI__builtin_ia32_vcvtpd2ph512_mask:
6905 case X86::BI__builtin_ia32_vcvtps2phx512_mask:
6906 case X86::BI__builtin_ia32_cvtpd2ps512_mask:
6907 case X86::BI__builtin_ia32_cvtpd2dq512_mask:
6908 case X86::BI__builtin_ia32_cvtpd2qq512_mask:
6909 case X86::BI__builtin_ia32_cvtpd2udq512_mask:
6910 case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
6911 case X86::BI__builtin_ia32_cvtps2dq512_mask:
6912 case X86::BI__builtin_ia32_cvtps2qq512_mask:
6913 case X86::BI__builtin_ia32_cvtps2udq512_mask:
6914 case X86::BI__builtin_ia32_cvtps2uqq512_mask:
6915 case X86::BI__builtin_ia32_cvtqq2pd512_mask:
6916 case X86::BI__builtin_ia32_cvtqq2ps512_mask:
6917 case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
6918 case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
6919 case X86::BI__builtin_ia32_vcvtdq2ph512_mask:
6920 case X86::BI__builtin_ia32_vcvtudq2ph512_mask:
6921 case X86::BI__builtin_ia32_vcvtw2ph512_mask:
6922 case X86::BI__builtin_ia32_vcvtuw2ph512_mask:
6923 case X86::BI__builtin_ia32_vcvtph2w512_mask:
6924 case X86::BI__builtin_ia32_vcvtph2uw512_mask:
6925 case X86::BI__builtin_ia32_vcvtph2dq512_mask:
6926 case X86::BI__builtin_ia32_vcvtph2udq512_mask:
6927 case X86::BI__builtin_ia32_vcvtph2qq512_mask:
6928 case X86::BI__builtin_ia32_vcvtph2uqq512_mask:
6929 case X86::BI__builtin_ia32_vcvtqq2ph512_mask:
6930 case X86::BI__builtin_ia32_vcvtuqq2ph512_mask:
6934 case X86::BI__builtin_ia32_addsh_round_mask:
6935 case X86::BI__builtin_ia32_addss_round_mask:
6936 case X86::BI__builtin_ia32_addsd_round_mask:
6937 case X86::BI__builtin_ia32_divsh_round_mask:
6938 case X86::BI__builtin_ia32_divss_round_mask:
6939 case X86::BI__builtin_ia32_divsd_round_mask:
6940 case X86::BI__builtin_ia32_mulsh_round_mask:
6941 case X86::BI__builtin_ia32_mulss_round_mask:
6942 case X86::BI__builtin_ia32_mulsd_round_mask:
6943 case X86::BI__builtin_ia32_subsh_round_mask:
6944 case X86::BI__builtin_ia32_subss_round_mask:
6945 case X86::BI__builtin_ia32_subsd_round_mask:
6946 case X86::BI__builtin_ia32_scalefph512_mask:
6947 case X86::BI__builtin_ia32_scalefpd512_mask:
6948 case X86::BI__builtin_ia32_scalefps512_mask:
6949 case X86::BI__builtin_ia32_scalefsd_round_mask:
6950 case X86::BI__builtin_ia32_scalefss_round_mask:
6951 case X86::BI__builtin_ia32_scalefsh_round_mask:
6952 case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
6953 case X86::BI__builtin_ia32_vcvtss2sh_round_mask:
6954 case X86::BI__builtin_ia32_vcvtsd2sh_round_mask:
6955 case X86::BI__builtin_ia32_sqrtsd_round_mask:
6956 case X86::BI__builtin_ia32_sqrtss_round_mask:
6957 case X86::BI__builtin_ia32_sqrtsh_round_mask:
6958 case X86::BI__builtin_ia32_vfmaddsd3_mask:
6959 case X86::BI__builtin_ia32_vfmaddsd3_maskz:
6960 case X86::BI__builtin_ia32_vfmaddsd3_mask3:
6961 case X86::BI__builtin_ia32_vfmaddss3_mask:
6962 case X86::BI__builtin_ia32_vfmaddss3_maskz:
6963 case X86::BI__builtin_ia32_vfmaddss3_mask3:
6964 case X86::BI__builtin_ia32_vfmaddsh3_mask:
6965 case X86::BI__builtin_ia32_vfmaddsh3_maskz:
6966 case X86::BI__builtin_ia32_vfmaddsh3_mask3:
6967 case X86::BI__builtin_ia32_vfmaddpd512_mask:
6968 case X86::BI__builtin_ia32_vfmaddpd512_maskz:
6969 case X86::BI__builtin_ia32_vfmaddpd512_mask3:
6970 case X86::BI__builtin_ia32_vfmsubpd512_mask3:
6971 case X86::BI__builtin_ia32_vfmaddps512_mask:
6972 case X86::BI__builtin_ia32_vfmaddps512_maskz:
6973 case X86::BI__builtin_ia32_vfmaddps512_mask3:
6974 case X86::BI__builtin_ia32_vfmsubps512_mask3:
6975 case X86::BI__builtin_ia32_vfmaddph512_mask:
6976 case X86::BI__builtin_ia32_vfmaddph512_maskz:
6977 case X86::BI__builtin_ia32_vfmaddph512_mask3:
6978 case X86::BI__builtin_ia32_vfmsubph512_mask3:
6979 case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
6980 case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
6981 case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
6982 case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
6983 case X86::BI__builtin_ia32_vfmaddsubps512_mask:
6984 case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
6985 case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
6986 case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
6987 case X86::BI__builtin_ia32_vfmaddsubph512_mask:
6988 case X86::BI__builtin_ia32_vfmaddsubph512_maskz:
6989 case X86::BI__builtin_ia32_vfmaddsubph512_mask3:
6990 case X86::BI__builtin_ia32_vfmsubaddph512_mask3:
6991 case X86::BI__builtin_ia32_vfmaddcsh_mask:
6992 case X86::BI__builtin_ia32_vfmaddcsh_round_mask:
6993 case X86::BI__builtin_ia32_vfmaddcsh_round_mask3:
6994 case X86::BI__builtin_ia32_vfmaddcph512_mask:
6995 case X86::BI__builtin_ia32_vfmaddcph512_maskz:
6996 case X86::BI__builtin_ia32_vfmaddcph512_mask3:
6997 case X86::BI__builtin_ia32_vfcmaddcsh_mask:
6998 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask:
6999 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask3:
7000 case X86::BI__builtin_ia32_vfcmaddcph512_mask:
7001 case X86::BI__builtin_ia32_vfcmaddcph512_maskz:
7002 case X86::BI__builtin_ia32_vfcmaddcph512_mask3:
7003 case X86::BI__builtin_ia32_vfmulcsh_mask:
7004 case X86::BI__builtin_ia32_vfmulcph512_mask:
7005 case X86::BI__builtin_ia32_vfcmulcsh_mask:
7006 case X86::BI__builtin_ia32_vfcmulcph512_mask:
7020 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7029 (!HasRC &&
Result == 12) ||
7030 (HasRC &&
Result.getZExtValue() >= 8 &&
Result.getZExtValue() <= 11))
7033 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
7038bool Sema::CheckX86BuiltinGatherScatterScale(
unsigned BuiltinID,
7040 unsigned ArgNum = 0;
7041 switch (BuiltinID) {
7044 case X86::BI__builtin_ia32_gatherpfdpd:
7045 case X86::BI__builtin_ia32_gatherpfdps:
7046 case X86::BI__builtin_ia32_gatherpfqpd:
7047 case X86::BI__builtin_ia32_gatherpfqps:
7048 case X86::BI__builtin_ia32_scatterpfdpd:
7049 case X86::BI__builtin_ia32_scatterpfdps:
7050 case X86::BI__builtin_ia32_scatterpfqpd:
7051 case X86::BI__builtin_ia32_scatterpfqps:
7054 case X86::BI__builtin_ia32_gatherd_pd:
7055 case X86::BI__builtin_ia32_gatherd_pd256:
7056 case X86::BI__builtin_ia32_gatherq_pd:
7057 case X86::BI__builtin_ia32_gatherq_pd256:
7058 case X86::BI__builtin_ia32_gatherd_ps:
7059 case X86::BI__builtin_ia32_gatherd_ps256:
7060 case X86::BI__builtin_ia32_gatherq_ps:
7061 case X86::BI__builtin_ia32_gatherq_ps256:
7062 case X86::BI__builtin_ia32_gatherd_q:
7063 case X86::BI__builtin_ia32_gatherd_q256:
7064 case X86::BI__builtin_ia32_gatherq_q:
7065 case X86::BI__builtin_ia32_gatherq_q256:
7066 case X86::BI__builtin_ia32_gatherd_d:
7067 case X86::BI__builtin_ia32_gatherd_d256:
7068 case X86::BI__builtin_ia32_gatherq_d:
7069 case X86::BI__builtin_ia32_gatherq_d256:
7070 case X86::BI__builtin_ia32_gather3div2df:
7071 case X86::BI__builtin_ia32_gather3div2di:
7072 case X86::BI__builtin_ia32_gather3div4df:
7073 case X86::BI__builtin_ia32_gather3div4di:
7074 case X86::BI__builtin_ia32_gather3div4sf:
7075 case X86::BI__builtin_ia32_gather3div4si:
7076 case X86::BI__builtin_ia32_gather3div8sf:
7077 case X86::BI__builtin_ia32_gather3div8si:
7078 case X86::BI__builtin_ia32_gather3siv2df:
7079 case X86::BI__builtin_ia32_gather3siv2di:
7080 case X86::BI__builtin_ia32_gather3siv4df:
7081 case X86::BI__builtin_ia32_gather3siv4di:
7082 case X86::BI__builtin_ia32_gather3siv4sf:
7083 case X86::BI__builtin_ia32_gather3siv4si:
7084 case X86::BI__builtin_ia32_gather3siv8sf:
7085 case X86::BI__builtin_ia32_gather3siv8si:
7086 case X86::BI__builtin_ia32_gathersiv8df:
7087 case X86::BI__builtin_ia32_gathersiv16sf:
7088 case X86::BI__builtin_ia32_gatherdiv8df:
7089 case X86::BI__builtin_ia32_gatherdiv16sf:
7090 case X86::BI__builtin_ia32_gathersiv8di:
7091 case X86::BI__builtin_ia32_gathersiv16si:
7092 case X86::BI__builtin_ia32_gatherdiv8di:
7093 case X86::BI__builtin_ia32_gatherdiv16si:
7094 case X86::BI__builtin_ia32_scatterdiv2df:
7095 case X86::BI__builtin_ia32_scatterdiv2di:
7096 case X86::BI__builtin_ia32_scatterdiv4df:
7097 case X86::BI__builtin_ia32_scatterdiv4di:
7098 case X86::BI__builtin_ia32_scatterdiv4sf:
7099 case X86::BI__builtin_ia32_scatterdiv4si:
7100 case X86::BI__builtin_ia32_scatterdiv8sf:
7101 case X86::BI__builtin_ia32_scatterdiv8si:
7102 case X86::BI__builtin_ia32_scattersiv2df:
7103 case X86::BI__builtin_ia32_scattersiv2di:
7104 case X86::BI__builtin_ia32_scattersiv4df:
7105 case X86::BI__builtin_ia32_scattersiv4di:
7106 case X86::BI__builtin_ia32_scattersiv4sf:
7107 case X86::BI__builtin_ia32_scattersiv4si:
7108 case X86::BI__builtin_ia32_scattersiv8sf:
7109 case X86::BI__builtin_ia32_scattersiv8si:
7110 case X86::BI__builtin_ia32_scattersiv8df:
7111 case X86::BI__builtin_ia32_scattersiv16sf:
7112 case X86::BI__builtin_ia32_scatterdiv8df:
7113 case X86::BI__builtin_ia32_scatterdiv16sf:
7114 case X86::BI__builtin_ia32_scattersiv8di:
7115 case X86::BI__builtin_ia32_scattersiv16si:
7116 case X86::BI__builtin_ia32_scatterdiv8di:
7117 case X86::BI__builtin_ia32_scatterdiv16si:
7130 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7136 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_scale)
7142bool Sema::CheckX86BuiltinTileArgumentsRange(
CallExpr *TheCall,
7144 for (
int ArgNum : ArgNums) {
7151bool Sema::CheckX86BuiltinTileDuplicate(
CallExpr *TheCall,
7155 std::bitset<TileRegHigh + 1> ArgValues;
7156 for (
int ArgNum : ArgNums) {
7162 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7164 int ArgExtValue =
Result.getExtValue();
7166 "Incorrect tile register num.");
7167 if (ArgValues.test(ArgExtValue))
7169 diag::err_x86_builtin_tile_arg_duplicate)
7171 ArgValues.set(ArgExtValue);
7176bool Sema::CheckX86BuiltinTileRangeAndDuplicate(
CallExpr *TheCall,
7178 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
7179 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
7182bool Sema::CheckX86BuiltinTileArguments(
unsigned BuiltinID,
CallExpr *TheCall) {
7183 switch (BuiltinID) {
7186 case X86::BI__builtin_ia32_tileloadd64:
7187 case X86::BI__builtin_ia32_tileloaddt164:
7188 case X86::BI__builtin_ia32_tilestored64:
7189 case X86::BI__builtin_ia32_tilezero:
7190 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
7191 case X86::BI__builtin_ia32_tdpbssd:
7192 case X86::BI__builtin_ia32_tdpbsud:
7193 case X86::BI__builtin_ia32_tdpbusd:
7194 case X86::BI__builtin_ia32_tdpbuud:
7195 case X86::BI__builtin_ia32_tdpbf16ps:
7196 case X86::BI__builtin_ia32_tdpfp16ps:
7197 case X86::BI__builtin_ia32_tcmmimfp16ps:
7198 case X86::BI__builtin_ia32_tcmmrlfp16ps:
7199 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
7204 switch (BuiltinID) {
7205 case X86::BI__builtin_ia32_readeflags_u32:
7206 case X86::BI__builtin_ia32_writeeflags_u32:
7213bool Sema::CheckX86BuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
7216 const llvm::Triple &TT = TI.
getTriple();
7219 diag::err_32_bit_builtin_64_bit_tgt);
7222 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
7226 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
7230 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
7235 int i = 0, l = 0, u = 0;
7236 switch (BuiltinID) {
7239 case X86::BI__builtin_ia32_vec_ext_v2si:
7240 case X86::BI__builtin_ia32_vec_ext_v2di:
7241 case X86::BI__builtin_ia32_vextractf128_pd256:
7242 case X86::BI__builtin_ia32_vextractf128_ps256:
7243 case X86::BI__builtin_ia32_vextractf128_si256:
7244 case X86::BI__builtin_ia32_extract128i256:
7245 case X86::BI__builtin_ia32_extractf64x4_mask:
7246 case X86::BI__builtin_ia32_extracti64x4_mask:
7247 case X86::BI__builtin_ia32_extractf32x8_mask:
7248 case X86::BI__builtin_ia32_extracti32x8_mask:
7249 case X86::BI__builtin_ia32_extractf64x2_256_mask:
7250 case X86::BI__builtin_ia32_extracti64x2_256_mask:
7251 case X86::BI__builtin_ia32_extractf32x4_256_mask:
7252 case X86::BI__builtin_ia32_extracti32x4_256_mask:
7253 i = 1; l = 0; u = 1;
7255 case X86::BI__builtin_ia32_vec_set_v2di:
7256 case X86::BI__builtin_ia32_vinsertf128_pd256:
7257 case X86::BI__builtin_ia32_vinsertf128_ps256:
7258 case X86::BI__builtin_ia32_vinsertf128_si256:
7259 case X86::BI__builtin_ia32_insert128i256:
7260 case X86::BI__builtin_ia32_insertf32x8:
7261 case X86::BI__builtin_ia32_inserti32x8:
7262 case X86::BI__builtin_ia32_insertf64x4:
7263 case X86::BI__builtin_ia32_inserti64x4:
7264 case X86::BI__builtin_ia32_insertf64x2_256:
7265 case X86::BI__builtin_ia32_inserti64x2_256:
7266 case X86::BI__builtin_ia32_insertf32x4_256:
7267 case X86::BI__builtin_ia32_inserti32x4_256:
7268 i = 2; l = 0; u = 1;
7270 case X86::BI__builtin_ia32_vpermilpd:
7271 case X86::BI__builtin_ia32_vec_ext_v4hi:
7272 case X86::BI__builtin_ia32_vec_ext_v4si:
7273 case X86::BI__builtin_ia32_vec_ext_v4sf:
7274 case X86::BI__builtin_ia32_vec_ext_v4di:
7275 case X86::BI__builtin_ia32_extractf32x4_mask:
7276 case X86::BI__builtin_ia32_extracti32x4_mask:
7277 case X86::BI__builtin_ia32_extractf64x2_512_mask:
7278 case X86::BI__builtin_ia32_extracti64x2_512_mask:
7279 i = 1; l = 0; u = 3;
7281 case X86::BI_mm_prefetch:
7282 case X86::BI__builtin_ia32_vec_ext_v8hi:
7283 case X86::BI__builtin_ia32_vec_ext_v8si:
7284 i = 1; l = 0; u = 7;
7286 case X86::BI__builtin_ia32_sha1rnds4:
7287 case X86::BI__builtin_ia32_blendpd:
7288 case X86::BI__builtin_ia32_shufpd:
7289 case X86::BI__builtin_ia32_vec_set_v4hi:
7290 case X86::BI__builtin_ia32_vec_set_v4si:
7291 case X86::BI__builtin_ia32_vec_set_v4di:
7292 case X86::BI__builtin_ia32_shuf_f32x4_256:
7293 case X86::BI__builtin_ia32_shuf_f64x2_256:
7294 case X86::BI__builtin_ia32_shuf_i32x4_256:
7295 case X86::BI__builtin_ia32_shuf_i64x2_256:
7296 case X86::BI__builtin_ia32_insertf64x2_512:
7297 case X86::BI__builtin_ia32_inserti64x2_512:
7298 case X86::BI__builtin_ia32_insertf32x4:
7299 case X86::BI__builtin_ia32_inserti32x4:
7300 i = 2; l = 0; u = 3;
7302 case X86::BI__builtin_ia32_vpermil2pd:
7303 case X86::BI__builtin_ia32_vpermil2pd256:
7304 case X86::BI__builtin_ia32_vpermil2ps:
7305 case X86::BI__builtin_ia32_vpermil2ps256:
7306 i = 3; l = 0; u = 3;
7308 case X86::BI__builtin_ia32_cmpb128_mask:
7309 case X86::BI__builtin_ia32_cmpw128_mask:
7310 case X86::BI__builtin_ia32_cmpd128_mask:
7311 case X86::BI__builtin_ia32_cmpq128_mask:
7312 case X86::BI__builtin_ia32_cmpb256_mask:
7313 case X86::BI__builtin_ia32_cmpw256_mask:
7314 case X86::BI__builtin_ia32_cmpd256_mask:
7315 case X86::BI__builtin_ia32_cmpq256_mask:
7316 case X86::BI__builtin_ia32_cmpb512_mask:
7317 case X86::BI__builtin_ia32_cmpw512_mask:
7318 case X86::BI__builtin_ia32_cmpd512_mask:
7319 case X86::BI__builtin_ia32_cmpq512_mask:
7320 case X86::BI__builtin_ia32_ucmpb128_mask:
7321 case X86::BI__builtin_ia32_ucmpw128_mask:
7322 case X86::BI__builtin_ia32_ucmpd128_mask:
7323 case X86::BI__builtin_ia32_ucmpq128_mask:
7324 case X86::BI__builtin_ia32_ucmpb256_mask:
7325 case X86::BI__builtin_ia32_ucmpw256_mask:
7326 case X86::BI__builtin_ia32_ucmpd256_mask:
7327 case X86::BI__builtin_ia32_ucmpq256_mask:
7328 case X86::BI__builtin_ia32_ucmpb512_mask:
7329 case X86::BI__builtin_ia32_ucmpw512_mask:
7330 case X86::BI__builtin_ia32_ucmpd512_mask:
7331 case X86::BI__builtin_ia32_ucmpq512_mask:
7332 case X86::BI__builtin_ia32_vpcomub:
7333 case X86::BI__builtin_ia32_vpcomuw:
7334 case X86::BI__builtin_ia32_vpcomud:
7335 case X86::BI__builtin_ia32_vpcomuq:
7336 case X86::BI__builtin_ia32_vpcomb:
7337 case X86::BI__builtin_ia32_vpcomw:
7338 case X86::BI__builtin_ia32_vpcomd:
7339 case X86::BI__builtin_ia32_vpcomq:
7340 case X86::BI__builtin_ia32_vec_set_v8hi:
7341 case X86::BI__builtin_ia32_vec_set_v8si:
7342 i = 2; l = 0; u = 7;
7344 case X86::BI__builtin_ia32_vpermilpd256:
7345 case X86::BI__builtin_ia32_roundps:
7346 case X86::BI__builtin_ia32_roundpd:
7347 case X86::BI__builtin_ia32_roundps256:
7348 case X86::BI__builtin_ia32_roundpd256:
7349 case X86::BI__builtin_ia32_getmantpd128_mask:
7350 case X86::BI__builtin_ia32_getmantpd256_mask:
7351 case X86::BI__builtin_ia32_getmantps128_mask:
7352 case X86::BI__builtin_ia32_getmantps256_mask:
7353 case X86::BI__builtin_ia32_getmantpd512_mask:
7354 case X86::BI__builtin_ia32_getmantps512_mask:
7355 case X86::BI__builtin_ia32_getmantph128_mask:
7356 case X86::BI__builtin_ia32_getmantph256_mask:
7357 case X86::BI__builtin_ia32_getmantph512_mask:
7358 case X86::BI__builtin_ia32_vec_ext_v16qi:
7359 case X86::BI__builtin_ia32_vec_ext_v16hi:
7360 i = 1; l = 0; u = 15;
7362 case X86::BI__builtin_ia32_pblendd128:
7363 case X86::BI__builtin_ia32_blendps:
7364 case X86::BI__builtin_ia32_blendpd256:
7365 case X86::BI__builtin_ia32_shufpd256:
7366 case X86::BI__builtin_ia32_roundss:
7367 case X86::BI__builtin_ia32_roundsd:
7368 case X86::BI__builtin_ia32_rangepd128_mask:
7369 case X86::BI__builtin_ia32_rangepd256_mask:
7370 case X86::BI__builtin_ia32_rangepd512_mask:
7371 case X86::BI__builtin_ia32_rangeps128_mask:
7372 case X86::BI__builtin_ia32_rangeps256_mask:
7373 case X86::BI__builtin_ia32_rangeps512_mask:
7374 case X86::BI__builtin_ia32_getmantsd_round_mask:
7375 case X86::BI__builtin_ia32_getmantss_round_mask:
7376 case X86::BI__builtin_ia32_getmantsh_round_mask:
7377 case X86::BI__builtin_ia32_vec_set_v16qi:
7378 case X86::BI__builtin_ia32_vec_set_v16hi:
7379 i = 2; l = 0; u = 15;
7381 case X86::BI__builtin_ia32_vec_ext_v32qi:
7382 i = 1; l = 0; u = 31;
7384 case X86::BI__builtin_ia32_cmpps:
7385 case X86::BI__builtin_ia32_cmpss:
7386 case X86::BI__builtin_ia32_cmppd:
7387 case X86::BI__builtin_ia32_cmpsd:
7388 case X86::BI__builtin_ia32_cmpps256:
7389 case X86::BI__builtin_ia32_cmppd256:
7390 case X86::BI__builtin_ia32_cmpps128_mask:
7391 case X86::BI__builtin_ia32_cmppd128_mask:
7392 case X86::BI__builtin_ia32_cmpps256_mask:
7393 case X86::BI__builtin_ia32_cmppd256_mask:
7394 case X86::BI__builtin_ia32_cmpps512_mask:
7395 case X86::BI__builtin_ia32_cmppd512_mask:
7396 case X86::BI__builtin_ia32_cmpsd_mask:
7397 case X86::BI__builtin_ia32_cmpss_mask:
7398 case X86::BI__builtin_ia32_vec_set_v32qi:
7399 i = 2; l = 0; u = 31;
7401 case X86::BI__builtin_ia32_permdf256:
7402 case X86::BI__builtin_ia32_permdi256:
7403 case X86::BI__builtin_ia32_permdf512:
7404 case X86::BI__builtin_ia32_permdi512:
7405 case X86::BI__builtin_ia32_vpermilps:
7406 case X86::BI__builtin_ia32_vpermilps256:
7407 case X86::BI__builtin_ia32_vpermilpd512:
7408 case X86::BI__builtin_ia32_vpermilps512:
7409 case X86::BI__builtin_ia32_pshufd:
7410 case X86::BI__builtin_ia32_pshufd256:
7411 case X86::BI__builtin_ia32_pshufd512:
7412 case X86::BI__builtin_ia32_pshufhw:
7413 case X86::BI__builtin_ia32_pshufhw256:
7414 case X86::BI__builtin_ia32_pshufhw512:
7415 case X86::BI__builtin_ia32_pshuflw:
7416 case X86::BI__builtin_ia32_pshuflw256:
7417 case X86::BI__builtin_ia32_pshuflw512:
7418 case X86::BI__builtin_ia32_vcvtps2ph:
7419 case X86::BI__builtin_ia32_vcvtps2ph_mask:
7420 case X86::BI__builtin_ia32_vcvtps2ph256:
7421 case X86::BI__builtin_ia32_vcvtps2ph256_mask:
7422 case X86::BI__builtin_ia32_vcvtps2ph512_mask:
7423 case X86::BI__builtin_ia32_rndscaleps_128_mask:
7424 case X86::BI__builtin_ia32_rndscalepd_128_mask:
7425 case X86::BI__builtin_ia32_rndscaleps_256_mask:
7426 case X86::BI__builtin_ia32_rndscalepd_256_mask:
7427 case X86::BI__builtin_ia32_rndscaleps_mask:
7428 case X86::BI__builtin_ia32_rndscalepd_mask:
7429 case X86::BI__builtin_ia32_rndscaleph_mask:
7430 case X86::BI__builtin_ia32_reducepd128_mask:
7431 case X86::BI__builtin_ia32_reducepd256_mask:
7432 case X86::BI__builtin_ia32_reducepd512_mask:
7433 case X86::BI__builtin_ia32_reduceps128_mask:
7434 case X86::BI__builtin_ia32_reduceps256_mask:
7435 case X86::BI__builtin_ia32_reduceps512_mask:
7436 case X86::BI__builtin_ia32_reduceph128_mask:
7437 case X86::BI__builtin_ia32_reduceph256_mask:
7438 case X86::BI__builtin_ia32_reduceph512_mask:
7439 case X86::BI__builtin_ia32_prold512:
7440 case X86::BI__builtin_ia32_prolq512:
7441 case X86::BI__builtin_ia32_prold128:
7442 case X86::BI__builtin_ia32_prold256:
7443 case X86::BI__builtin_ia32_prolq128:
7444 case X86::BI__builtin_ia32_prolq256:
7445 case X86::BI__builtin_ia32_prord512:
7446 case X86::BI__builtin_ia32_prorq512:
7447 case X86::BI__builtin_ia32_prord128:
7448 case X86::BI__builtin_ia32_prord256:
7449 case X86::BI__builtin_ia32_prorq128:
7450 case X86::BI__builtin_ia32_prorq256:
7451 case X86::BI__builtin_ia32_fpclasspd128_mask:
7452 case X86::BI__builtin_ia32_fpclasspd256_mask:
7453 case X86::BI__builtin_ia32_fpclassps128_mask:
7454 case X86::BI__builtin_ia32_fpclassps256_mask:
7455 case X86::BI__builtin_ia32_fpclassps512_mask:
7456 case X86::BI__builtin_ia32_fpclasspd512_mask:
7457 case X86::BI__builtin_ia32_fpclassph128_mask:
7458 case X86::BI__builtin_ia32_fpclassph256_mask:
7459 case X86::BI__builtin_ia32_fpclassph512_mask:
7460 case X86::BI__builtin_ia32_fpclasssd_mask:
7461 case X86::BI__builtin_ia32_fpclassss_mask:
7462 case X86::BI__builtin_ia32_fpclasssh_mask:
7463 case X86::BI__builtin_ia32_pslldqi128_byteshift:
7464 case X86::BI__builtin_ia32_pslldqi256_byteshift:
7465 case X86::BI__builtin_ia32_pslldqi512_byteshift:
7466 case X86::BI__builtin_ia32_psrldqi128_byteshift:
7467 case X86::BI__builtin_ia32_psrldqi256_byteshift:
7468 case X86::BI__builtin_ia32_psrldqi512_byteshift:
7469 case X86::BI__builtin_ia32_kshiftliqi:
7470 case X86::BI__builtin_ia32_kshiftlihi:
7471 case X86::BI__builtin_ia32_kshiftlisi:
7472 case X86::BI__builtin_ia32_kshiftlidi:
7473 case X86::BI__builtin_ia32_kshiftriqi:
7474 case X86::BI__builtin_ia32_kshiftrihi:
7475 case X86::BI__builtin_ia32_kshiftrisi:
7476 case X86::BI__builtin_ia32_kshiftridi:
7477 i = 1; l = 0; u = 255;
7479 case X86::BI__builtin_ia32_vperm2f128_pd256:
7480 case X86::BI__builtin_ia32_vperm2f128_ps256:
7481 case X86::BI__builtin_ia32_vperm2f128_si256:
7482 case X86::BI__builtin_ia32_permti256:
7483 case X86::BI__builtin_ia32_pblendw128:
7484 case X86::BI__builtin_ia32_pblendw256:
7485 case X86::BI__builtin_ia32_blendps256:
7486 case X86::BI__builtin_ia32_pblendd256:
7487 case X86::BI__builtin_ia32_palignr128:
7488 case X86::BI__builtin_ia32_palignr256:
7489 case X86::BI__builtin_ia32_palignr512:
7490 case X86::BI__builtin_ia32_alignq512:
7491 case X86::BI__builtin_ia32_alignd512:
7492 case X86::BI__builtin_ia32_alignd128:
7493 case X86::BI__builtin_ia32_alignd256:
7494 case X86::BI__builtin_ia32_alignq128:
7495 case X86::BI__builtin_ia32_alignq256:
7496 case X86::BI__builtin_ia32_vcomisd:
7497 case X86::BI__builtin_ia32_vcomiss:
7498 case X86::BI__builtin_ia32_shuf_f32x4:
7499 case X86::BI__builtin_ia32_shuf_f64x2:
7500 case X86::BI__builtin_ia32_shuf_i32x4:
7501 case X86::BI__builtin_ia32_shuf_i64x2:
7502 case X86::BI__builtin_ia32_shufpd512:
7503 case X86::BI__builtin_ia32_shufps:
7504 case X86::BI__builtin_ia32_shufps256:
7505 case X86::BI__builtin_ia32_shufps512:
7506 case X86::BI__builtin_ia32_dbpsadbw128:
7507 case X86::BI__builtin_ia32_dbpsadbw256:
7508 case X86::BI__builtin_ia32_dbpsadbw512:
7509 case X86::BI__builtin_ia32_vpshldd128:
7510 case X86::BI__builtin_ia32_vpshldd256:
7511 case X86::BI__builtin_ia32_vpshldd512:
7512 case X86::BI__builtin_ia32_vpshldq128:
7513 case X86::BI__builtin_ia32_vpshldq256:
7514 case X86::BI__builtin_ia32_vpshldq512:
7515 case X86::BI__builtin_ia32_vpshldw128:
7516 case X86::BI__builtin_ia32_vpshldw256:
7517 case X86::BI__builtin_ia32_vpshldw512:
7518 case X86::BI__builtin_ia32_vpshrdd128:
7519 case X86::BI__builtin_ia32_vpshrdd256:
7520 case X86::BI__builtin_ia32_vpshrdd512:
7521 case X86::BI__builtin_ia32_vpshrdq128:
7522 case X86::BI__builtin_ia32_vpshrdq256:
7523 case X86::BI__builtin_ia32_vpshrdq512:
7524 case X86::BI__builtin_ia32_vpshrdw128:
7525 case X86::BI__builtin_ia32_vpshrdw256:
7526 case X86::BI__builtin_ia32_vpshrdw512:
7527 i = 2; l = 0; u = 255;
7529 case X86::BI__builtin_ia32_fixupimmpd512_mask:
7530 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
7531 case X86::BI__builtin_ia32_fixupimmps512_mask:
7532 case X86::BI__builtin_ia32_fixupimmps512_maskz:
7533 case X86::BI__builtin_ia32_fixupimmsd_mask:
7534 case X86::BI__builtin_ia32_fixupimmsd_maskz:
7535 case X86::BI__builtin_ia32_fixupimmss_mask:
7536 case X86::BI__builtin_ia32_fixupimmss_maskz:
7537 case X86::BI__builtin_ia32_fixupimmpd128_mask:
7538 case X86::BI__builtin_ia32_fixupimmpd128_maskz:
7539 case X86::BI__builtin_ia32_fixupimmpd256_mask:
7540 case X86::BI__builtin_ia32_fixupimmpd256_maskz:
7541 case X86::BI__builtin_ia32_fixupimmps128_mask:
7542 case X86::BI__builtin_ia32_fixupimmps128_maskz:
7543 case X86::BI__builtin_ia32_fixupimmps256_mask:
7544 case X86::BI__builtin_ia32_fixupimmps256_maskz:
7545 case X86::BI__builtin_ia32_pternlogd512_mask:
7546 case X86::BI__builtin_ia32_pternlogd512_maskz:
7547 case X86::BI__builtin_ia32_pternlogq512_mask:
7548 case X86::BI__builtin_ia32_pternlogq512_maskz:
7549 case X86::BI__builtin_ia32_pternlogd128_mask:
7550 case X86::BI__builtin_ia32_pternlogd128_maskz:
7551 case X86::BI__builtin_ia32_pternlogd256_mask:
7552 case X86::BI__builtin_ia32_pternlogd256_maskz:
7553 case X86::BI__builtin_ia32_pternlogq128_mask:
7554 case X86::BI__builtin_ia32_pternlogq128_maskz:
7555 case X86::BI__builtin_ia32_pternlogq256_mask:
7556 case X86::BI__builtin_ia32_pternlogq256_maskz:
7557 case X86::BI__builtin_ia32_vsm3rnds2:
7558 i = 3; l = 0; u = 255;
7560 case X86::BI__builtin_ia32_gatherpfdpd:
7561 case X86::BI__builtin_ia32_gatherpfdps:
7562 case X86::BI__builtin_ia32_gatherpfqpd:
7563 case X86::BI__builtin_ia32_gatherpfqps:
7564 case X86::BI__builtin_ia32_scatterpfdpd:
7565 case X86::BI__builtin_ia32_scatterpfdps:
7566 case X86::BI__builtin_ia32_scatterpfqpd:
7567 case X86::BI__builtin_ia32_scatterpfqps:
7568 i = 4; l = 2; u = 3;
7570 case X86::BI__builtin_ia32_reducesd_mask:
7571 case X86::BI__builtin_ia32_reducess_mask:
7572 case X86::BI__builtin_ia32_rndscalesd_round_mask:
7573 case X86::BI__builtin_ia32_rndscaless_round_mask:
7574 case X86::BI__builtin_ia32_rndscalesh_round_mask:
7575 case X86::BI__builtin_ia32_reducesh_mask:
7576 i = 4; l = 0; u = 255;
7578 case X86::BI__builtin_ia32_cmpccxadd32:
7579 case X86::BI__builtin_ia32_cmpccxadd64:
7580 i = 3; l = 0; u = 15;
7588 return BuiltinConstantArgRange(TheCall, i, l, u,
false);
7597 if (Format->getFirstArg() == 0)
7599 else if (IsVariadic)
7603 FSI->
FormatIdx = Format->getFormatIdx() - 1;
7627 if (isa<CXXNullPtrLiteralExpr>(
7642 if (
const auto *CLE = dyn_cast<CompoundLiteralExpr>(
Expr))
7643 if (
const auto *ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))
7644 Expr = ILE->getInit(0);
7654 const Expr *ArgExpr,
7658 S.
PDiag(diag::warn_null_arg)
7680 bool Format =
false;
7693 if (!Format || NumArgs <= Idx)
7695 const Expr *FormatExpr = Args[Idx];
7696 if (
const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
7697 FormatExpr = CSCE->getSubExpr();
7707 S.
Diag(FormatExpr->
getExprLoc(), diag::warn_objc_cdirective_format_string)
7716 if (
auto nullability =
type->getNullability())
7727 assert((FDecl || Proto) &&
"Need a function declaration or prototype");
7733 llvm::SmallBitVector NonNullArgs;
7739 for (
const auto *Arg : Args)
7746 unsigned IdxAST = Idx.getASTIndex();
7747 if (IdxAST >= Args.size())
7749 if (NonNullArgs.empty())
7750 NonNullArgs.resize(Args.size());
7751 NonNullArgs.set(IdxAST);
7756 if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
7760 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
7763 parms = cast<ObjCMethodDecl>(FDecl)->parameters();
7765 unsigned ParamIndex = 0;
7767 I != E; ++I, ++ParamIndex) {
7770 if (NonNullArgs.empty())
7771 NonNullArgs.resize(Args.size());
7773 NonNullArgs.set(ParamIndex);
7780 if (
const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
7785 type = blockType->getPointeeType();
7799 if (NonNullArgs.empty())
7800 NonNullArgs.resize(Args.size());
7802 NonNullArgs.set(Index);
7811 for (
unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
7812 ArgIndex != ArgIndexEnd; ++ArgIndex) {
7813 if (NonNullArgs[ArgIndex])
7826 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->
IgnoreParens());
7830 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
7834 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
7835 if (!PD || !PD->getType()->isRecordType())
7841 if (
const auto *AA = FD->
getAttr<AlignedAttr>()) {
7846 Diag(Loc, diag::note_misaligned_member_used_here) << PD;
7857 StringRef ParamName,
QualType ArgTy,
7885 if (ArgAlign < ParamAlign)
7886 Diag(Loc, diag::warn_param_mismatched_alignment)
7888 << ParamName << (FDecl !=
nullptr) << FDecl;
7903 llvm::SmallBitVector CheckedVarArgs;
7907 CheckedVarArgs.resize(Args.size());
7909 CheckFormatArguments(I, Args, IsMemberFunction, CallType, Loc, Range,
7916 auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
7920 : FDecl && isa<FunctionDecl>(FDecl)
7921 ? cast<FunctionDecl>(FDecl)->getNumParams()
7922 : FDecl && isa<ObjCMethodDecl>(FDecl)
7923 ? cast<ObjCMethodDecl>(FDecl)->param_size()
7926 for (
unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
7928 if (
const Expr *Arg = Args[ArgIdx]) {
7929 if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
7935 if (FDecl || Proto) {
7940 for (
const auto *I : FDecl->
specific_attrs<ArgumentWithTypeTagAttr>())
7941 CheckArgumentWithTypeTag(I, Args, Loc);
7947 if (!Proto && FDecl) {
7949 if (isa_and_nonnull<FunctionProtoType>(FT))
7955 const auto N = std::min<unsigned>(Proto->
getNumParams(), Args.size());
7957 bool IsScalableArg =
false;
7958 for (
unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
7960 if (
const Expr *Arg = Args[ArgIdx]) {
7968 checkAIXMemberAlignment((Arg->
getExprLoc()), Arg);
7972 IsScalableArg =
true;
7974 CheckArgAlignment(Arg->
getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
7983 if (
auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext)) {
7984 llvm::StringMap<bool> CallerFeatureMap;
7986 if (!CallerFeatureMap.contains(
"sme"))
7987 Diag(Loc, diag::err_sme_call_in_non_sme_target);
7989 Diag(Loc, diag::err_sme_call_in_non_sme_target);
7996 const auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext);
7998 (IsScalableArg || IsScalableRet)) {
7999 bool IsCalleeStreaming =
8001 bool IsCalleeStreamingCompatible =
8005 if (!IsCalleeStreamingCompatible &&
8007 ((CallerFnType ==
ArmStreaming) ^ IsCalleeStreaming))) {
8009 Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)
8012 Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)
8023 bool CallerHasZAState =
false;
8024 bool CallerHasZT0State =
false;
8026 auto *
Attr = CallerFD->getAttr<ArmNewAttr>();
8028 CallerHasZAState =
true;
8030 CallerHasZT0State =
true;
8034 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8036 CallerHasZT0State |=
8038 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8044 Diag(Loc, diag::err_sme_za_call_no_za_state);
8047 Diag(Loc, diag::err_sme_zt0_call_no_zt0_state);
8051 Diag(Loc, diag::err_sme_unimplemented_za_save_restore);
8052 Diag(Loc, diag::note_sme_use_preserves_za);
8057 if (FDecl && FDecl->
hasAttr<AllocAlignAttr>()) {
8058 auto *AA = FDecl->
getAttr<AllocAlignAttr>();
8059 const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
8060 if (!Arg->isValueDependent()) {
8062 if (Arg->EvaluateAsInt(Align,
Context)) {
8063 const llvm::APSInt &I = Align.
Val.
getInt();
8064 if (!I.isPowerOf2())
8065 Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
8066 << Arg->getSourceRange();
8069 Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
8088 auto *Ctor = cast<CXXConstructorDecl>(FDecl);
8093 checkCall(FDecl, Proto,
nullptr, Args,
true,
8101 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
8102 isa<CXXMethodDecl>(FDecl);
8103 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
8104 IsMemberOperatorCall;
8110 Expr *ImplicitThis =
nullptr;
8115 ImplicitThis = Args[0];
8118 }
else if (IsMemberFunction && !FDecl->
isStatic() &&
8121 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
8133 cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());
8135 CheckArgAlignment(TheCall->
getRParenLoc(), FDecl,
"'this'", ThisType,
8139 checkCall(FDecl, Proto, ImplicitThis,
llvm::ArrayRef(Args, NumArgs),
8151 CheckTCBEnforcement(TheCall->
getExprLoc(), FDecl);
8153 CheckAbsoluteValueFunction(TheCall, FDecl);
8154 CheckMaxUnsignedZero(TheCall, FDecl);
8155 CheckInfNaNFunction(TheCall, FDecl);
8166 case Builtin::BIstrlcpy:
8167 case Builtin::BIstrlcat:
8168 CheckStrlcpycatArguments(TheCall, FnInfo);
8170 case Builtin::BIstrncat:
8171 CheckStrncatArguments(TheCall, FnInfo);
8173 case Builtin::BIfree:
8174 CheckFreeArguments(TheCall);
8177 CheckMemaccessArguments(TheCall, CMId, FnInfo);
8188 checkCall(Method,
nullptr,
nullptr, Args,
8192 CheckTCBEnforcement(lbrac, Method);
8200 if (
const auto *
V = dyn_cast<VarDecl>(NDecl))
8201 Ty =
V->getType().getNonReferenceType();
8202 else if (
const auto *F = dyn_cast<FieldDecl>(NDecl))
8203 Ty = F->getType().getNonReferenceType();
8220 checkCall(NDecl, Proto,
nullptr,
8233 checkCall(
nullptr, Proto,
nullptr,
8242 if (!llvm::isValidAtomicOrderingCABI(Ordering))
8245 auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
8247 case AtomicExpr::AO__c11_atomic_init:
8248 case AtomicExpr::AO__opencl_atomic_init:
8249 llvm_unreachable(
"There is no ordering argument for an init");
8251 case AtomicExpr::AO__c11_atomic_load:
8252 case AtomicExpr::AO__opencl_atomic_load:
8253 case AtomicExpr::AO__hip_atomic_load:
8254 case AtomicExpr::AO__atomic_load_n:
8255 case AtomicExpr::AO__atomic_load:
8256 case AtomicExpr::AO__scoped_atomic_load_n:
8257 case AtomicExpr::AO__scoped_atomic_load:
8258 return OrderingCABI != llvm::AtomicOrderingCABI::release &&
8259 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8261 case AtomicExpr::AO__c11_atomic_store:
8262 case AtomicExpr::AO__opencl_atomic_store:
8263 case AtomicExpr::AO__hip_atomic_store:
8264 case AtomicExpr::AO__atomic_store:
8265 case AtomicExpr::AO__atomic_store_n:
8266 case AtomicExpr::AO__scoped_atomic_store:
8267 case AtomicExpr::AO__scoped_atomic_store_n:
8268 return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
8269 OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
8270 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8279 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
8323 const unsigned NumForm = GNUCmpXchg + 1;
8324 const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
8325 const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
8333 static_assert(
sizeof(NumArgs)/
sizeof(NumArgs[0]) == NumForm
8334 &&
sizeof(NumVals)/
sizeof(NumVals[0]) == NumForm,
8335 "need to update code for modified forms");
8336 static_assert(AtomicExpr::AO__atomic_add_fetch == 0 &&
8337 AtomicExpr::AO__atomic_xor_fetch + 1 ==
8338 AtomicExpr::AO__c11_atomic_compare_exchange_strong,
8339 "need to update code for modified C11 atomics");
8340 bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&
8341 Op <= AtomicExpr::AO__opencl_atomic_store;
8342 bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
8343 Op <= AtomicExpr::AO__hip_atomic_store;
8344 bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&
8345 Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;
8346 bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
8347 Op <= AtomicExpr::AO__c11_atomic_store) ||
8349 bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
8350 Op == AtomicExpr::AO__atomic_store_n ||
8351 Op == AtomicExpr::AO__atomic_exchange_n ||
8352 Op == AtomicExpr::AO__atomic_compare_exchange_n ||
8353 Op == AtomicExpr::AO__scoped_atomic_load_n ||
8354 Op == AtomicExpr::AO__scoped_atomic_store_n ||
8355 Op == AtomicExpr::AO__scoped_atomic_exchange_n ||
8356 Op == AtomicExpr::AO__scoped_atomic_compare_exchange_n;
8360 enum ArithOpExtraValueType {
8365 unsigned ArithAllows = AOEVT_None;
8368 case AtomicExpr::AO__c11_atomic_init:
8369 case AtomicExpr::AO__opencl_atomic_init:
8373 case AtomicExpr::AO__c11_atomic_load:
8374 case AtomicExpr::AO__opencl_atomic_load:
8375 case AtomicExpr::AO__hip_atomic_load:
8376 case AtomicExpr::AO__atomic_load_n:
8377 case AtomicExpr::AO__scoped_atomic_load_n:
8381 case AtomicExpr::AO__atomic_load:
8382 case AtomicExpr::AO__scoped_atomic_load:
8386 case AtomicExpr::AO__c11_atomic_store:
8387 case AtomicExpr::AO__opencl_atomic_store:
8388 case AtomicExpr::AO__hip_atomic_store:
8389 case AtomicExpr::AO__atomic_store:
8390 case AtomicExpr::AO__atomic_store_n:
8391 case AtomicExpr::AO__scoped_atomic_store:
8392 case AtomicExpr::AO__scoped_atomic_store_n:
8395 case AtomicExpr::AO__atomic_fetch_add:
8396 case AtomicExpr::AO__atomic_fetch_sub:
8397 case AtomicExpr::AO__atomic_add_fetch:
8398 case AtomicExpr::AO__atomic_sub_fetch:
8399 case AtomicExpr::AO__scoped_atomic_fetch_add:
8400 case AtomicExpr::AO__scoped_atomic_fetch_sub:
8401 case AtomicExpr::AO__scoped_atomic_add_fetch:
8402 case AtomicExpr::AO__scoped_atomic_sub_fetch:
8403 case AtomicExpr::AO__c11_atomic_fetch_add:
8404 case AtomicExpr::AO__c11_atomic_fetch_sub:
8405 case AtomicExpr::AO__opencl_atomic_fetch_add:
8406 case AtomicExpr::AO__opencl_atomic_fetch_sub:
8407 case AtomicExpr::AO__hip_atomic_fetch_add:
8408 case AtomicExpr::AO__hip_atomic_fetch_sub:
8409 ArithAllows = AOEVT_Pointer | AOEVT_FP;
8412 case AtomicExpr::AO__atomic_fetch_max:
8413 case AtomicExpr::AO__atomic_fetch_min:
8414 case AtomicExpr::AO__atomic_max_fetch:
8415 case AtomicExpr::AO__atomic_min_fetch:
8416 case AtomicExpr::AO__scoped_atomic_fetch_max:
8417 case AtomicExpr::AO__scoped_atomic_fetch_min:
8418 case AtomicExpr::AO__scoped_atomic_max_fetch:
8419 case AtomicExpr::AO__scoped_atomic_min_fetch:
8420 case AtomicExpr::AO__c11_atomic_fetch_max:
8421 case AtomicExpr::AO__c11_atomic_fetch_min:
8422 case AtomicExpr::AO__opencl_atomic_fetch_max:
8423 case AtomicExpr::AO__opencl_atomic_fetch_min:
8424 case AtomicExpr::AO__hip_atomic_fetch_max:
8425 case AtomicExpr::AO__hip_atomic_fetch_min:
8426 ArithAllows = AOEVT_FP;
8429 case AtomicExpr::AO__c11_atomic_fetch_and:
8430 case AtomicExpr::AO__c11_atomic_fetch_or:
8431 case AtomicExpr::AO__c11_atomic_fetch_xor:
8432 case AtomicExpr::AO__hip_atomic_fetch_and:
8433 case AtomicExpr::AO__hip_atomic_fetch_or:
8434 case AtomicExpr::AO__hip_atomic_fetch_xor:
8435 case AtomicExpr::AO__c11_atomic_fetch_nand:
8436 case AtomicExpr::AO__opencl_atomic_fetch_and:
8437 case AtomicExpr::AO__opencl_atomic_fetch_or:
8438 case AtomicExpr::AO__opencl_atomic_fetch_xor:
8439 case AtomicExpr::AO__atomic_fetch_and:
8440 case AtomicExpr::AO__atomic_fetch_or:
8441 case AtomicExpr::AO__atomic_fetch_xor:
8442 case AtomicExpr::AO__atomic_fetch_nand:
8443 case AtomicExpr::AO__atomic_and_fetch:
8444 case AtomicExpr::AO__atomic_or_fetch:
8445 case AtomicExpr::AO__atomic_xor_fetch:
8446 case AtomicExpr::AO__atomic_nand_fetch:
8447 case AtomicExpr::AO__scoped_atomic_fetch_and:
8448 case AtomicExpr::AO__scoped_atomic_fetch_or:
8449 case AtomicExpr::AO__scoped_atomic_fetch_xor:
8450 case AtomicExpr::AO__scoped_atomic_fetch_nand:
8451 case AtomicExpr::AO__scoped_atomic_and_fetch:
8452 case AtomicExpr::AO__scoped_atomic_or_fetch:
8453 case AtomicExpr::AO__scoped_atomic_xor_fetch:
8454 case AtomicExpr::AO__scoped_atomic_nand_fetch:
8458 case AtomicExpr::AO__c11_atomic_exchange:
8459 case AtomicExpr::AO__hip_atomic_exchange:
8460 case AtomicExpr::AO__opencl_atomic_exchange:
8461 case AtomicExpr::AO__atomic_exchange_n:
8462 case AtomicExpr::AO__scoped_atomic_exchange_n:
8466 case AtomicExpr::AO__atomic_exchange:
8467 case AtomicExpr::AO__scoped_atomic_exchange:
8471 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
8472 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
8473 case AtomicExpr::AO__hip_atomic_compare_exchange_strong:
8474 case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
8475 case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
8476 case AtomicExpr::AO__hip_atomic_compare_exchange_weak:
8480 case AtomicExpr::AO__atomic_compare_exchange:
8481 case AtomicExpr::AO__atomic_compare_exchange_n:
8482 case AtomicExpr::AO__scoped_atomic_compare_exchange:
8483 case AtomicExpr::AO__scoped_atomic_compare_exchange_n:
8488 unsigned AdjustedNumArgs = NumArgs[Form];
8489 if ((IsOpenCL || IsHIP || IsScoped) &&
8490 Op != AtomicExpr::AO__opencl_atomic_init)
8493 if (Args.size() < AdjustedNumArgs) {
8494 Diag(CallRange.
getEnd(), diag::err_typecheck_call_too_few_args)
8495 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8498 }
else if (Args.size() > AdjustedNumArgs) {
8499 Diag(Args[AdjustedNumArgs]->getBeginLoc(),
8500 diag::err_typecheck_call_too_many_args)
8501 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8507 Expr *Ptr = Args[0];
8512 Ptr = ConvertedPtr.
get();
8515 Diag(ExprRange.
getBegin(), diag::err_atomic_builtin_must_be_pointer)
8525 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic)
8531 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_atomic)
8537 }
else if (Form != Load && Form != LoadCopy) {
8539 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_pointer)
8546 if (Form == Arithmetic) {
8549 auto IsAllowedValueType = [&](
QualType ValType,
8550 unsigned AllowedType) ->
bool {
8554 return AllowedType & AOEVT_Pointer;
8560 &llvm::APFloat::x87DoubleExtended())
8564 if (!IsAllowedValueType(ValType, ArithAllows)) {
8565 auto DID = ArithAllows & AOEVT_FP
8566 ? (ArithAllows & AOEVT_Pointer
8567 ? diag::err_atomic_op_needs_atomic_int_ptr_or_fp
8568 : diag::err_atomic_op_needs_atomic_int_or_fp)
8569 : diag::err_atomic_op_needs_atomic_int;
8576 diag::err_incomplete_type)) {
8582 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
8593 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_trivial_copy)
8609 Diag(ExprRange.
getBegin(), diag::err_arc_atomic_ownership)
8621 if (Form ==
Copy || Form == LoadCopy || Form == GNUXchg ||
8624 else if (Form == C11CmpXchg || Form == GNUCmpXchg)
8630 bool IsPassedByAddress =
false;
8631 if (!IsC11 && !IsHIP && !IsN) {
8633 IsPassedByAddress =
true;
8638 APIOrderedArgs.push_back(Args[0]);
8642 APIOrderedArgs.push_back(Args[1]);
8648 APIOrderedArgs.push_back(Args[2]);
8649 APIOrderedArgs.push_back(Args[1]);
8652 APIOrderedArgs.push_back(Args[2]);
8653 APIOrderedArgs.push_back(Args[3]);
8654 APIOrderedArgs.push_back(Args[1]);
8657 APIOrderedArgs.push_back(Args[2]);
8658 APIOrderedArgs.push_back(Args[4]);
8659 APIOrderedArgs.push_back(Args[1]);
8660 APIOrderedArgs.push_back(Args[3]);
8663 APIOrderedArgs.push_back(Args[2]);
8664 APIOrderedArgs.push_back(Args[4]);
8665 APIOrderedArgs.push_back(Args[5]);
8666 APIOrderedArgs.push_back(Args[1]);
8667 APIOrderedArgs.push_back(Args[3]);
8671 APIOrderedArgs.append(Args.begin(), Args.end());
8678 for (
unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
8680 if (i < NumVals[Form] + 1) {
8693 assert(Form != Load);
8696 else if (Form ==
Init || Form == Arithmetic)
8698 else if (Form ==
Copy || Form == Xchg) {
8699 if (IsPassedByAddress) {
8706 Expr *ValArg = APIOrderedArgs[i];
8713 AS = PtrTy->getPointeeType().getAddressSpace();
8722 if (IsPassedByAddress)
8742 APIOrderedArgs[i] = Arg.
get();
8747 SubExprs.push_back(Ptr);
8751 SubExprs.push_back(APIOrderedArgs[1]);
8754 SubExprs.push_back(APIOrderedArgs[1]);
8760 SubExprs.push_back(APIOrderedArgs[2]);
8761 SubExprs.push_back(APIOrderedArgs[1]);
8765 SubExprs.push_back(APIOrderedArgs[3]);
8766 SubExprs.push_back(APIOrderedArgs[1]);
8767 SubExprs.push_back(APIOrderedArgs[2]);
8770 SubExprs.push_back(APIOrderedArgs[3]);
8771 SubExprs.push_back(APIOrderedArgs[1]);
8772 SubExprs.push_back(APIOrderedArgs[4]);
8773 SubExprs.push_back(APIOrderedArgs[2]);
8776 SubExprs.push_back(APIOrderedArgs[4]);
8777 SubExprs.push_back(APIOrderedArgs[1]);
8778 SubExprs.push_back(APIOrderedArgs[5]);
8779 SubExprs.push_back(APIOrderedArgs[2]);
8780 SubExprs.push_back(APIOrderedArgs[3]);
8785 if (SubExprs.size() >= 2 && Form !=
Init) {
8786 std::optional<llvm::APSInt>
Success =
8787 SubExprs[1]->getIntegerConstantExpr(
Context);
8789 Diag(SubExprs[1]->getBeginLoc(),
8790 diag::warn_atomic_op_has_invalid_memory_order)
8791 << (Form == C11CmpXchg || Form == GNUCmpXchg)
8792 << SubExprs[1]->getSourceRange();
8794 if (SubExprs.size() >= 5) {
8795 if (std::optional<llvm::APSInt> Failure =
8796 SubExprs[3]->getIntegerConstantExpr(
Context)) {
8797 if (!llvm::is_contained(
8798 {llvm::AtomicOrderingCABI::relaxed,
8799 llvm::AtomicOrderingCABI::consume,
8800 llvm::AtomicOrderingCABI::acquire,
8801 llvm::AtomicOrderingCABI::seq_cst},
8802 (llvm::AtomicOrderingCABI)Failure->getSExtValue())) {
8803 Diag(SubExprs[3]->getBeginLoc(),
8804 diag::warn_atomic_op_has_invalid_memory_order)
8805 << 2 << SubExprs[3]->getSourceRange();
8812 auto *
Scope = Args[Args.size() - 1];
8813 if (std::optional<llvm::APSInt>
Result =
8815 if (!ScopeModel->isValid(
Result->getZExtValue()))
8816 Diag(
Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
8817 <<
Scope->getSourceRange();
8819 SubExprs.push_back(
Scope);
8825 if ((Op == AtomicExpr::AO__c11_atomic_load ||
8826 Op == AtomicExpr::AO__c11_atomic_store ||
8827 Op == AtomicExpr::AO__opencl_atomic_load ||
8828 Op == AtomicExpr::AO__hip_atomic_load ||
8829 Op == AtomicExpr::AO__opencl_atomic_store ||
8830 Op == AtomicExpr::AO__hip_atomic_store) &&
8833 << ((Op == AtomicExpr::AO__c11_atomic_load ||
8834 Op == AtomicExpr::AO__opencl_atomic_load ||
8835 Op == AtomicExpr::AO__hip_atomic_load)
8840 Diag(Ptr->
getExprLoc(), diag::err_atomic_builtin_bit_int_prohibit);
8856 assert(Fn &&
"builtin call without direct callee!");
8871bool Sema::BuiltinWasmRefNullExtern(
CallExpr *TheCall) {
8880bool Sema::BuiltinWasmRefNullFunc(
CallExpr *TheCall) {
8915 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
8917 <<
Callee->getSourceRange();
8930 FirstArg = FirstArgResult.
get();
8931 TheCall->
setArg(0, FirstArg);
8943 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
8978#define BUILTIN_ROW(x) \
8979 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
8980 Builtin::BI##x##_8, Builtin::BI##x##_16 }
8982 static const unsigned BuiltinIndices[][5] = {
9008 case 1: SizeIndex = 0;
break;
9009 case 2: SizeIndex = 1;
break;
9010 case 4: SizeIndex = 2;
break;
9011 case 8: SizeIndex = 3;
break;
9012 case 16: SizeIndex = 4;
break;
9024 unsigned BuiltinIndex, NumFixed = 1;
9025 bool WarnAboutSemanticsChange =
false;
9026 switch (BuiltinID) {
9027 default: llvm_unreachable(
"Unknown overloaded atomic builtin!");
9028 case Builtin::BI__sync_fetch_and_add:
9029 case Builtin::BI__sync_fetch_and_add_1:
9030 case Builtin::BI__sync_fetch_and_add_2:
9031 case Builtin::BI__sync_fetch_and_add_4:
9032 case Builtin::BI__sync_fetch_and_add_8:
9033 case Builtin::BI__sync_fetch_and_add_16:
9037 case Builtin::BI__sync_fetch_and_sub:
9038 case Builtin::BI__sync_fetch_and_sub_1:
9039 case Builtin::BI__sync_fetch_and_sub_2:
9040 case Builtin::BI__sync_fetch_and_sub_4:
9041 case Builtin::BI__sync_fetch_and_sub_8:
9042 case Builtin::BI__sync_fetch_and_sub_16:
9046 case Builtin::BI__sync_fetch_and_or:
9047 case Builtin::BI__sync_fetch_and_or_1:
9048 case Builtin::BI__sync_fetch_and_or_2:
9049 case Builtin::BI__sync_fetch_and_or_4:
9050 case Builtin::BI__sync_fetch_and_or_8:
9051 case Builtin::BI__sync_fetch_and_or_16:
9055 case Builtin::BI__sync_fetch_and_and:
9056 case Builtin::BI__sync_fetch_and_and_1:
9057 case Builtin::BI__sync_fetch_and_and_2:
9058 case Builtin::BI__sync_fetch_and_and_4:
9059 case Builtin::BI__sync_fetch_and_and_8:
9060 case Builtin::BI__sync_fetch_and_and_16:
9064 case Builtin::BI__sync_fetch_and_xor:
9065 case Builtin::BI__sync_fetch_and_xor_1:
9066 case Builtin::BI__sync_fetch_and_xor_2:
9067 case Builtin::BI__sync_fetch_and_xor_4:
9068 case Builtin::BI__sync_fetch_and_xor_8:
9069 case Builtin::BI__sync_fetch_and_xor_16:
9073 case Builtin::BI__sync_fetch_and_nand:
9074 case Builtin::BI__sync_fetch_and_nand_1:
9075 case Builtin::BI__sync_fetch_and_nand_2:
9076 case Builtin::BI__sync_fetch_and_nand_4:
9077 case Builtin::BI__sync_fetch_and_nand_8:
9078 case Builtin::BI__sync_fetch_and_nand_16:
9080 WarnAboutSemanticsChange =
true;
9083 case Builtin::BI__sync_add_and_fetch:
9084 case Builtin::BI__sync_add_and_fetch_1:
9085 case Builtin::BI__sync_add_and_fetch_2:
9086 case Builtin::BI__sync_add_and_fetch_4:
9087 case Builtin::BI__sync_add_and_fetch_8:
9088 case Builtin::BI__sync_add_and_fetch_16:
9092 case Builtin::BI__sync_sub_and_fetch:
9093 case Builtin::BI__sync_sub_and_fetch_1:
9094 case Builtin::BI__sync_sub_and_fetch_2:
9095 case Builtin::BI__sync_sub_and_fetch_4:
9096 case Builtin::BI__sync_sub_and_fetch_8:
9097 case Builtin::BI__sync_sub_and_fetch_16:
9101 case Builtin::BI__sync_and_and_fetch:
9102 case Builtin::BI__sync_and_and_fetch_1:
9103 case Builtin::BI__sync_and_and_fetch_2:
9104 case Builtin::BI__sync_and_and_fetch_4:
9105 case Builtin::BI__sync_and_and_fetch_8:
9106 case Builtin::BI__sync_and_and_fetch_16:
9110 case Builtin::BI__sync_or_and_fetch:
9111 case Builtin::BI__sync_or_and_fetch_1:
9112 case Builtin::BI__sync_or_and_fetch_2:
9113 case Builtin::BI__sync_or_and_fetch_4:
9114 case Builtin::BI__sync_or_and_fetch_8:
9115 case Builtin::BI__sync_or_and_fetch_16:
9119 case Builtin::BI__sync_xor_and_fetch:
9120 case Builtin::BI__sync_xor_and_fetch_1:
9121 case Builtin::BI__sync_xor_and_fetch_2:
9122 case Builtin::BI__sync_xor_and_fetch_4:
9123 case Builtin::BI__sync_xor_and_fetch_8:
9124 case Builtin::BI__sync_xor_and_fetch_16:
9128 case Builtin::BI__sync_nand_and_fetch:
9129 case Builtin::BI__sync_nand_and_fetch_1:
9130 case Builtin::BI__sync_nand_and_fetch_2:
9131 case Builtin::BI__sync_nand_and_fetch_4:
9132 case Builtin::BI__sync_nand_and_fetch_8:
9133 case Builtin::BI__sync_nand_and_fetch_16:
9135 WarnAboutSemanticsChange =
true;
9138 case Builtin::BI__sync_val_compare_and_swap:
9139 case Builtin::BI__sync_val_compare_and_swap_1:
9140 case Builtin::BI__sync_val_compare_and_swap_2:
9141 case Builtin::BI__sync_val_compare_and_swap_4:
9142 case Builtin::BI__sync_val_compare_and_swap_8:
9143 case Builtin::BI__sync_val_compare_and_swap_16:
9148 case Builtin::BI__sync_bool_compare_and_swap:
9149 case Builtin::BI__sync_bool_compare_and_swap_1:
9150 case Builtin::BI__sync_bool_compare_and_swap_2:
9151 case Builtin::BI__sync_bool_compare_and_swap_4:
9152 case Builtin::BI__sync_bool_compare_and_swap_8:
9153 case Builtin::BI__sync_bool_compare_and_swap_16:
9159 case Builtin::BI__sync_lock_test_and_set:
9160 case Builtin::BI__sync_lock_test_and_set_1:
9161 case Builtin::BI__sync_lock_test_and_set_2:
9162 case Builtin::BI__sync_lock_test_and_set_4:
9163 case Builtin::BI__sync_lock_test_and_set_8:
9164 case Builtin::BI__sync_lock_test_and_set_16:
9168 case Builtin::BI__sync_lock_release:
9169 case Builtin::BI__sync_lock_release_1:
9170 case Builtin::BI__sync_lock_release_2:
9171 case Builtin::BI__sync_lock_release_4:
9172 case Builtin::BI__sync_lock_release_8:
9173 case Builtin::BI__sync_lock_release_16:
9179 case Builtin::BI__sync_swap:
9180 case Builtin::BI__sync_swap_1:
9181 case Builtin::BI__sync_swap_2:
9182 case Builtin::BI__sync_swap_4:
9183 case Builtin::BI__sync_swap_8:
9184 case Builtin::BI__sync_swap_16:
9192 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
9193 << 0 << 1 + NumFixed << TheCall->
getNumArgs() << 0
9194 <<
Callee->getSourceRange();
9198 Diag(TheCall->
getEndLoc(), diag::warn_atomic_implicit_seq_cst)
9199 <<
Callee->getSourceRange();
9201 if (WarnAboutSemanticsChange) {
9202 Diag(TheCall->
getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
9203 <<
Callee->getSourceRange();
9208 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
9211 if (NewBuiltinID == BuiltinID)
9212 NewBuiltinDecl = FDecl;
9218 assert(Res.getFoundDecl());
9219 NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
9220 if (!NewBuiltinDecl)
9227 for (
unsigned i = 0; i != NumFixed; ++i) {
9258 CK_BuiltinFnToFnPtr);
9270 if (BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {
9271 Diag(FirstArg->
getExprLoc(), diag::err_atomic_builtin_ext_int_size);
9275 return TheCallResult;
9290 assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||
9291 BuiltinID == Builtin::BI__builtin_nontemporal_load) &&
9292 "Unexpected nontemporal load/store builtin!");
9293 bool isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;
9294 unsigned numArgs = isStore ? 2 : 1;
9304 Expr *PointerArg = TheCall->
getArg(numArgs - 1);
9310 PointerArg = PointerArgResult.
get();
9311 TheCall->
setArg(numArgs - 1, PointerArg);
9315 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
9328 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
9335 return TheCallResult;
9347 return TheCallResult;
9354bool Sema::CheckObjCString(
Expr *Arg) {
9358 if (!Literal || !
Literal->isOrdinary()) {
9359 Diag(Arg->
getBeginLoc(), diag::err_cfstring_literal_not_string_constant)
9364 if (
Literal->containsNonAsciiOrNull()) {
9365 StringRef String =
Literal->getString();
9366 unsigned NumBytes = String.size();
9368 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
9369 llvm::UTF16 *ToPtr = &ToBuf[0];
9371 llvm::ConversionResult
Result =
9372 llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
9373 ToPtr + NumBytes, llvm::strictConversion);
9375 if (
Result != llvm::conversionOK)
9386 auto *
Literal = dyn_cast<StringLiteral>(Arg);
9388 if (
auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
9389 Literal = ObjcLiteral->getString();
9393 if (!Literal || (!
Literal->isOrdinary() && !
Literal->isUTF8())) {
9411 bool IsX64 = TT.getArch() == llvm::Triple::x86_64;
9412 bool IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||
9413 TT.getArch() == llvm::Triple::aarch64_32);
9414 bool IsWindows = TT.isOSWindows();
9415 bool IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;
9416 if (IsX64 || IsAArch64) {
9424 diag::err_ms_va_start_used_in_sysv_function);
9433 diag::err_va_start_used_in_wrong_abi_function)
9448 bool IsVariadic =
false;
9451 if (
auto *
Block = dyn_cast<BlockDecl>(Caller)) {
9452 IsVariadic =
Block->isVariadic();
9453 Params =
Block->parameters();
9454 }
else if (
auto *FD = dyn_cast<FunctionDecl>(Caller)) {
9457 }
else if (
auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {
9458 IsVariadic = MD->isVariadic();
9460 Params = MD->parameters();
9461 }
else if (isa<CapturedDecl>(Caller)) {
9477 *LastParam = Params.empty() ? nullptr : Params.back();
9485bool Sema::BuiltinVAStart(
unsigned BuiltinID,
CallExpr *TheCall) {
9510 bool SecondArgIsLastNamedArgument =
false;
9512 if (std::optional<llvm::APSInt> Val =
9521 bool IsCRegister =
false;
9523 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
9524 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
9525 SecondArgIsLastNamedArgument = PV == LastParam;
9527 Type = PV->getType();
9528 ParamLoc = PV->getLocation();
9534 if (!SecondArgIsLastNamedArgument)
9536 diag::warn_second_arg_of_va_start_not_last_named_param);
9541 if (!Context.isPromotableIntegerType(Type))
9543 if (!Type->isEnumeralType())
9545 const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
9547 Context.typesAreCompatible(ED->getPromotionType(), Type));
9549 unsigned Reason = 0;
9551 else if (IsCRegister) Reason = 2;
9552 Diag(Arg->
getBeginLoc(), diag::warn_va_start_type_is_undefined) << Reason;
9553 Diag(ParamLoc, diag::note_parameter_type) <<
Type;
9560 auto IsSuitablyTypedFormatArgument = [
this](
const Expr *Arg) ->
bool {
9580 if (
Call->getNumArgs() < 3)
9582 diag::err_typecheck_call_too_few_args_at_least)
9583 << 0 << 3 <<
Call->getNumArgs()
9596 const Expr *Arg1 =
Call->getArg(1)->IgnoreParens();
9599 const Expr *Arg2 =
Call->getArg(2)->IgnoreParens();
9604 if (!Arg1Ty->
isPointerType() || !IsSuitablyTypedFormatArgument(Arg1))
9606 << Arg1->
getType() << ConstCharPtrTy << 1
9609 << 2 << Arg1->
getType() << ConstCharPtrTy;
9614 << Arg2->
getType() << SizeTy << 1
9617 << 3 << Arg2->
getType() << SizeTy;
9624bool Sema::BuiltinUnorderedCompare(
CallExpr *TheCall,
unsigned BuiltinID) {
9628 if (BuiltinID == Builtin::BI__builtin_isunordered &&
9656 diag::err_typecheck_call_invalid_ordered_compare)
9667bool Sema::BuiltinFPClassification(
CallExpr *TheCall,
unsigned NumArgs,
9668 unsigned BuiltinID) {
9673 if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
9674 BuiltinID == Builtin::BI__builtin_isinf ||
9675 BuiltinID == Builtin::BI__builtin_isinf_sign))
9679 if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
9680 BuiltinID == Builtin::BI__builtin_isunordered))
9684 bool IsFPClass = NumArgs == 2;
9687 unsigned FPArgNo = IsFPClass ? 0 : NumArgs - 1;
9691 for (
unsigned i = 0; i < FPArgNo; ++i) {
9716 TheCall->
setArg(FPArgNo, OrigArg);
9730 diag::err_typecheck_call_invalid_unary_fp)
9736 if (BuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
9742 if (!VectorResultTy.
isNull())
9743 ResultTy = VectorResultTy;
9753bool Sema::BuiltinComplex(
CallExpr *TheCall) {
9757 bool Dependent =
false;
9758 for (
unsigned I = 0; I != 2; ++I) {
9769 return Diag(Arg->
getBeginLoc(), diag::err_typecheck_call_requires_real_fp)
9788 diag::err_typecheck_call_different_arg_types)
9814bool Sema::BuiltinVSX(
CallExpr *TheCall) {
9815 unsigned ExpectedNumArgs = 3;
9822 diag::err_vsx_builtin_nonconstant_argument)
9834 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
9842 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
9861 diag::err_typecheck_call_too_few_args_at_least)
9869 unsigned numElements = 0;
9884 unsigned numResElements = TheCall->
getNumArgs() - 2;
9893 diag::err_vec_builtin_incompatible_vector)
9900 diag::err_vec_builtin_incompatible_vector)
9905 }
else if (numElements != numResElements) {
9912 for (
unsigned i = 2; i < TheCall->
getNumArgs(); i++) {
9917 std::optional<llvm::APSInt>
Result;
9920 diag::err_shufflevector_nonconstant_argument)
9927 if (
Result->getActiveBits() > 64 ||
9928 Result->getZExtValue() >= numElements * 2)
9930 diag::err_shufflevector_argument_too_large)
9936 for (
unsigned i = 0, e = TheCall->
getNumArgs(); i != e; i++) {
9937 exprs.push_back(TheCall->
getArg(i));
9938 TheCall->
setArg(i,
nullptr);
9957 diag::err_convertvector_non_vector)
9960 return ExprError(
Diag(BuiltinLoc, diag::err_builtin_non_vector_type)
9962 <<
"__builtin_convertvector");
9967 if (SrcElts != DstElts)
9969 diag::err_convertvector_incompatible_vector)
9974 BuiltinLoc, RParenLoc);
9980bool Sema::BuiltinPrefetch(
CallExpr *TheCall) {
9985 diag::err_typecheck_call_too_many_args_at_most)
9986 << 0 << 3 << NumArgs << 0
9991 for (
unsigned i = 1; i != NumArgs; ++i)
9992 if (BuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
9999bool Sema::BuiltinArithmeticFence(
CallExpr *TheCall) {
10001 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
10011 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
10024bool Sema::BuiltinAssume(
CallExpr *TheCall) {
10031 << cast<FunctionDecl>(TheCall->
getCalleeDecl())->getIdentifier();
10039bool Sema::BuiltinAllocaWithAlign(
CallExpr *TheCall) {
10045 if (
const auto *UE =
10047 if (UE->getKind() == UETT_AlignOf ||
10048 UE->getKind() == UETT_PreferredAlignOf)
10054 if (!
Result.isPowerOf2())
10055 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10062 if (
Result > std::numeric_limits<int32_t>::max())
10064 << std::numeric_limits<int32_t>::max() << Arg->
getSourceRange();
10072bool Sema::BuiltinAssumeAligned(
CallExpr *TheCall) {
10085 TheCall->
setArg(0, FirstArgResult.
get());
10094 if (BuiltinConstantArg(TheCall, 1,
Result))
10097 if (!
Result.isPowerOf2())
10098 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10110 TheCall->
setArg(2, ThirdArg);
10116bool Sema::BuiltinOSLogFormat(
CallExpr *TheCall) {
10117 unsigned BuiltinID =
10118 cast<FunctionDecl>(TheCall->
getCalleeDecl())->getBuiltinID();
10119 bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
10122 unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
10123 if (NumArgs < NumRequiredArgs) {
10124 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args)
10125 << 0 << NumRequiredArgs << NumArgs
10128 if (NumArgs >= NumRequiredArgs + 0x100) {
10130 diag::err_typecheck_call_too_many_args_at_most)
10131 << 0 << (NumRequiredArgs + 0xff) << NumArgs
10142 if (Arg.isInvalid())
10144 TheCall->
setArg(i, Arg.get());
10149 unsigned FormatIdx = i;
10159 unsigned FirstDataArg = i;
10160 while (i < NumArgs) {
10178 llvm::SmallBitVector CheckedVarArgs(NumArgs,
false);
10180 bool Success = CheckFormatArguments(
10198bool Sema::BuiltinConstantArg(
CallExpr *TheCall,
int ArgNum,
10206 std::optional<llvm::APSInt> R;
10208 return Diag(TheCall->
getBeginLoc(), diag::err_constant_integer_arg_type)
10216bool Sema::BuiltinConstantArgRange(
CallExpr *TheCall,
int ArgNum,
int Low,
10217 int High,
bool RangeIsError) {
10228 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10231 if (
Result.getSExtValue() < Low ||
Result.getSExtValue() > High) {
10233 return Diag(TheCall->
getBeginLoc(), diag::err_argument_invalid_range)
10239 PDiag(diag::warn_argument_invalid_range)
10249bool Sema::BuiltinConstantArgMultiple(
CallExpr *TheCall,
int ArgNum,
10259 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10262 if (
Result.getSExtValue() % Num != 0)
10271bool Sema::BuiltinConstantArgPower2(
CallExpr *TheCall,
int ArgNum) {
10280 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10288 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_power_of_2)
10293 if (
Value.isNegative())
10304 if ((
Value & 0xFF) != 0)
10317bool Sema::BuiltinConstantArgShiftedByte(
CallExpr *TheCall,
int ArgNum,
10318 unsigned ArgBits) {
10327 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10332 Result.setIsUnsigned(
true);
10337 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_shifted_byte)
10346bool Sema::BuiltinConstantArgShiftedByteOrXXFF(
CallExpr *TheCall,
int ArgNum,
10347 unsigned ArgBits) {
10356 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10361 Result.setIsUnsigned(
true);
10369 diag::err_argument_not_shifted_byte_or_xxff)
10374bool Sema::BuiltinARMMemoryTaggingCall(
unsigned BuiltinID,
CallExpr *TheCall) {
10375 if (BuiltinID == AArch64::BI__builtin_arm_irg) {
10386 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10395 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10399 TheCall->
setType(FirstArgType);
10403 if (BuiltinID == AArch64::BI__builtin_arm_addg) {
10413 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10418 TheCall->
setType(FirstArgType);
10421 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
10424 if (BuiltinID == AArch64::BI__builtin_arm_gmi) {
10435 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10440 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10446 if (BuiltinID == AArch64::BI__builtin_arm_ldg ||
10447 BuiltinID == AArch64::BI__builtin_arm_stg) {
10457 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10462 if (BuiltinID == AArch64::BI__builtin_arm_ldg)
10463 TheCall->
setType(FirstArgType);
10467 if (BuiltinID == AArch64::BI__builtin_arm_subp) {
10480 auto isNull = [&] (
Expr *E) ->
bool {
10486 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10490 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10501 return Diag(TheCall->
getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
10509 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_any2arg_pointer)
10523 assert(
false &&
"Unhandled ARM MTE intrinsic");
10529bool Sema::BuiltinARMSpecialReg(
unsigned BuiltinID,
CallExpr *TheCall,
10530 int ArgNum,
unsigned ExpectedFieldNum,
10532 bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
10533 BuiltinID == ARM::BI__builtin_arm_wsr64 ||
10534 BuiltinID == ARM::BI__builtin_arm_rsr ||
10535 BuiltinID == ARM::BI__builtin_arm_rsrp ||
10536 BuiltinID == ARM::BI__builtin_arm_wsr ||
10537 BuiltinID == ARM::BI__builtin_arm_wsrp;
10538 bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
10539 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
10540 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10541 BuiltinID == AArch64::BI__builtin_arm_wsr128 ||
10542 BuiltinID == AArch64::BI__builtin_arm_rsr ||
10543 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
10544 BuiltinID == AArch64::BI__builtin_arm_wsr ||
10545 BuiltinID == AArch64::BI__builtin_arm_wsrp;
10546 assert((IsARMBuiltin || IsAArch64Builtin) &&
"Unexpected ARM builtin.");
10555 return Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
10561 Reg.split(Fields,
":");
10563 if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))
10564 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10571 if (Fields.size() > 1) {
10572 bool FiveFields = Fields.size() == 5;
10574 bool ValidString =
true;
10575 if (IsARMBuiltin) {
10576 ValidString &= Fields[0].starts_with_insensitive(
"cp") ||
10577 Fields[0].starts_with_insensitive(
"p");
10579 Fields[0] = Fields[0].drop_front(
10580 Fields[0].starts_with_insensitive(
"cp") ? 2 : 1);
10582 ValidString &= Fields[2].starts_with_insensitive(
"c");
10584 Fields[2] = Fields[2].drop_front(1);
10587 ValidString &= Fields[3].starts_with_insensitive(
"c");
10589 Fields[3] = Fields[3].drop_front(1);
10595 Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});
10597 Ranges.append({15, 7, 15});
10599 for (
unsigned i=0; i<Fields.size(); ++i) {
10601 ValidString &= !Fields[i].getAsInteger(10, IntField);
10602 ValidString &= (IntField >= 0 && IntField <= Ranges[i]);
10606 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10608 }
else if (IsAArch64Builtin && Fields.size() == 1) {
10616 if (BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10617 BuiltinID == AArch64::BI__builtin_arm_wsr128)
10622 auto MaxLimit = llvm::StringSwitch<std::optional<unsigned>>(Reg)
10623 .CaseLower(
"spsel", 15)
10624 .CaseLower(
"daifclr", 15)
10625 .CaseLower(
"daifset", 15)
10626 .CaseLower(
"pan", 15)
10627 .CaseLower(
"uao", 15)
10628 .CaseLower(
"dit", 15)
10629 .CaseLower(
"ssbs", 15)
10630 .CaseLower(
"tco", 15)
10631 .CaseLower(
"allint", 1)
10632 .CaseLower(
"pm", 1)
10633 .Default(std::nullopt);
10653 return BuiltinConstantArgRange(TheCall, 1, 0, *MaxLimit);
10663bool Sema::BuiltinPPCMMACall(
CallExpr *TheCall,
unsigned BuiltinID,
10664 const char *TypeStr) {
10666 assert((TypeStr[0] !=
'\0') &&
10667 "Invalid types in PPC MMA builtin declaration");
10670 unsigned ArgNum = 0;
10677 while (*TypeStr !=
'\0') {
10701 diag::err_typecheck_convert_incompatible)
10707 if (Mask != 0 && BuiltinConstantArgRange(TheCall, ArgNum, 0, Mask,
true))
10717 while (*TypeStr !=
'\0') {
10730bool Sema::BuiltinLongjmp(
CallExpr *TheCall) {
10732 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_unsupported)
10739 if (BuiltinConstantArg(TheCall, 1,
Result))
10743 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
10751bool Sema::BuiltinSetjmp(
CallExpr *TheCall) {
10753 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_setjmp_unsupported)
10760class UncoveredArgHandler {
10761 enum {
Unknown = -1, AllCovered = -2 };
10763 signed FirstUncoveredArg =
Unknown;
10767 UncoveredArgHandler() =
default;
10769 bool hasUncoveredArg()
const {
10770 return (FirstUncoveredArg >= 0);
10773 unsigned getUncoveredArg()
const {
10774 assert(hasUncoveredArg() &&
"no uncovered argument");
10775 return FirstUncoveredArg;
10778 void setAllCovered() {
10781 DiagnosticExprs.clear();
10782 FirstUncoveredArg = AllCovered;
10785 void Update(
signed NewFirstUncoveredArg,
const Expr *StrExpr) {
10786 assert(NewFirstUncoveredArg >= 0 &&
"Outside range");
10789 if (FirstUncoveredArg == AllCovered)
10794 if (NewFirstUncoveredArg == FirstUncoveredArg)
10795 DiagnosticExprs.push_back(StrExpr);
10796 else if (NewFirstUncoveredArg > FirstUncoveredArg) {
10797 DiagnosticExprs.clear();
10798 DiagnosticExprs.push_back(StrExpr);
10799 FirstUncoveredArg = NewFirstUncoveredArg;
10803 void Diagnose(
Sema &S,
bool IsFunctionCall,
const Expr *ArgExpr);
10806enum StringLiteralCheckType {
10808 SLCT_UncheckedLiteral,
10809 SLCT_CheckedLiteral
10816 bool AddendIsRight) {
10817 unsigned BitWidth = Offset.getBitWidth();
10818 unsigned AddendBitWidth = Addend.getBitWidth();
10820 if (Addend.isUnsigned()) {
10821 Addend = Addend.zext(++AddendBitWidth);
10822 Addend.setIsSigned(
true);
10825 if (AddendBitWidth > BitWidth) {
10826 Offset = Offset.sext(AddendBitWidth);
10827 BitWidth = AddendBitWidth;
10828 }
else if (BitWidth > AddendBitWidth) {
10829 Addend = Addend.sext(BitWidth);
10833 llvm::APSInt ResOffset = Offset;
10834 if (BinOpKind == BO_Add)
10835 ResOffset = Offset.sadd_ov(Addend, Ov);
10837 assert(AddendIsRight && BinOpKind == BO_Sub &&
10838 "operator must be add or sub with addend on the right");
10839 ResOffset = Offset.ssub_ov(Addend, Ov);
10845 assert(BitWidth <= std::numeric_limits<unsigned>::max() / 2 &&
10846 "index (intermediate) result too big");
10847 Offset = Offset.sext(2 * BitWidth);
10848 sumOffsets(Offset, Addend, BinOpKind, AddendIsRight);
10852 Offset = ResOffset;
10860class FormatStringLiteral {
10865 FormatStringLiteral(
const StringLiteral *fexpr, int64_t Offset = 0)
10866 : FExpr(fexpr), Offset(Offset) {}
10868 StringRef getString()
const {
10869 return FExpr->
getString().drop_front(Offset);
10872 unsigned getByteLength()
const {
10873 return FExpr->
getByteLength() - getCharByteWidth() * Offset;
10876 unsigned getLength()
const {
return FExpr->
getLength() - Offset; }
10883 bool isAscii()
const {
return FExpr->
isOrdinary(); }
10884 bool isWide()
const {
return FExpr->
isWide(); }
10885 bool isUTF8()
const {
return FExpr->
isUTF8(); }
10886 bool isUTF16()
const {
return FExpr->
isUTF16(); }
10887 bool isUTF32()
const {
return FExpr->
isUTF32(); }
10888 bool isPascal()
const {
return FExpr->
isPascal(); }
10893 unsigned *StartTokenByteOffset =
nullptr)
const {
10895 StartToken, StartTokenByteOffset);
10908 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
10912 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
10913 bool IgnoreStringsWithoutSpecifiers);
10922static StringLiteralCheckType
10927 llvm::SmallBitVector &CheckedVarArgs,
10928 UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset,
10929 bool IgnoreStringsWithoutSpecifiers =
false) {
10931 return SLCT_NotALiteral;
10933 assert(Offset.isSigned() &&
"invalid offset");
10936 return SLCT_NotALiteral;
10945 return SLCT_UncheckedLiteral;
10948 case Stmt::InitListExprClass:
10952 Type, CallType,
false,
10953 CheckedVarArgs, UncoveredArg, Offset,
10954 IgnoreStringsWithoutSpecifiers);
10956 return SLCT_NotALiteral;
10957 case Stmt::BinaryConditionalOperatorClass:
10958 case Stmt::ConditionalOperatorClass: {
10962 cast<AbstractConditionalOperator>(E);
10967 bool CheckLeft =
true, CheckRight =
true;
10970 if (
C->getCond()->EvaluateAsBooleanCondition(
10973 CheckRight =
false;
10982 StringLiteralCheckType Left;
10984 Left = SLCT_UncheckedLiteral;
10987 firstDataArg,
Type, CallType, InFunctionCall,
10988 CheckedVarArgs, UncoveredArg, Offset,
10989 IgnoreStringsWithoutSpecifiers);
10990 if (Left == SLCT_NotALiteral || !CheckRight) {
10996 S,
C->getFalseExpr(), Args, APK, format_idx, firstDataArg,
Type,
10997 CallType, InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
10998 IgnoreStringsWithoutSpecifiers);
11000 return (CheckLeft && Left < Right) ? Left : Right;
11003 case Stmt::ImplicitCastExprClass:
11004 E = cast<ImplicitCastExpr>(E)->getSubExpr();
11007 case Stmt::OpaqueValueExprClass:
11008 if (
const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
11012 return SLCT_NotALiteral;
11014 case Stmt::PredefinedExprClass:
11018 return SLCT_UncheckedLiteral;
11020 case Stmt::DeclRefExprClass: {
11026 bool isConstant =
false;
11030 isConstant = AT->getElementType().isConstant(S.
Context);
11032 isConstant =
T.isConstant(S.
Context) &&
11037 isConstant =
T.isConstant(S.
Context);
11041 if (
const Expr *
Init = VD->getAnyInitializer()) {
11044 if (InitList->isStringLiteralInit())
11045 Init = InitList->getInit(0)->IgnoreParenImpCasts();
11048 S,
Init, Args, APK, format_idx, firstDataArg,
Type, CallType,
11049 false, CheckedVarArgs, UncoveredArg, Offset);
11090 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
11091 if (
const auto *D = dyn_cast<Decl>(PV->getDeclContext())) {
11093 bool IsCXXMember =
false;
11094 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D))
11095 IsCXXMember = MD->isInstance();
11097 bool IsVariadic =
false;
11099 IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();
11100 else if (
const auto *BD = dyn_cast<BlockDecl>(D))
11101 IsVariadic = BD->isVariadic();
11102 else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D))
11103 IsVariadic = OMD->isVariadic();
11110 if (PV->getFunctionScopeIndex() == CallerFSI.
FormatIdx &&
11123 return SLCT_UncheckedLiteral;
11132 return SLCT_NotALiteral;
11135 case Stmt::CallExprClass:
11136 case Stmt::CXXMemberCallExprClass: {
11137 const CallExpr *CE = cast<CallExpr>(E);
11139 bool IsFirst =
true;
11140 StringLiteralCheckType CommonResult;
11141 for (
const auto *FA : ND->specific_attrs<FormatArgAttr>()) {
11142 const Expr *Arg = CE->
getArg(FA->getFormatIdx().getASTIndex());
11144 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11145 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11146 IgnoreStringsWithoutSpecifiers);
11153 return CommonResult;
11155 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
11157 if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
11158 BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString) {
11161 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11162 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11163 IgnoreStringsWithoutSpecifiers);
11169 Type, CallType,
false,
11170 CheckedVarArgs, UncoveredArg, Offset,
11171 IgnoreStringsWithoutSpecifiers);
11172 return SLCT_NotALiteral;
11174 case Stmt::ObjCMessageExprClass: {
11175 const auto *ME = cast<ObjCMessageExpr>(E);
11176 if (
const auto *MD = ME->getMethodDecl()) {
11177 if (
const auto *FA = MD->getAttr<FormatArgAttr>()) {
11186 if (MD->isInstanceMethod() && (IFace = MD->getClassInterface()) &&
11188 MD->getSelector().isKeywordSelector(
11189 {
"localizedStringForKey",
"value",
"table"})) {
11190 IgnoreStringsWithoutSpecifiers =
true;
11193 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
11195 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11196 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11197 IgnoreStringsWithoutSpecifiers);
11201 return SLCT_NotALiteral;
11203 case Stmt::ObjCStringLiteralClass:
11204 case Stmt::StringLiteralClass: {
11210 StrE = cast<StringLiteral>(E);
11213 if (Offset.isNegative() || Offset > StrE->
getLength()) {
11216 return SLCT_NotALiteral;
11218 FormatStringLiteral FStr(StrE, Offset.sextOrTrunc(64).getSExtValue());
11220 InFunctionCall, CallType, CheckedVarArgs, UncoveredArg,
11221 IgnoreStringsWithoutSpecifiers);
11222 return SLCT_CheckedLiteral;
11225 return SLCT_NotALiteral;
11227 case Stmt::BinaryOperatorClass: {
11241 if (LIsInt != RIsInt) {
11245 if (BinOpKind == BO_Add) {
11258 return SLCT_NotALiteral;
11260 case Stmt::UnaryOperatorClass: {
11262 auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->
getSubExpr());
11263 if (UnaOp->
getOpcode() == UO_AddrOf && ASE) {
11265 if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.
Context,
11270 E = ASE->getBase();
11275 return SLCT_NotALiteral;
11279 return SLCT_NotALiteral;
11290 const auto *LVE =
Result.Val.getLValueBase().dyn_cast<
const Expr *>();
11291 if (isa_and_nonnull<StringLiteral>(LVE))
11298 return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
11304 .Cases(
"kprintf",
"cmn_err",
"vcmn_err",
"zcmn_err",
FST_Kprintf)
11314bool Sema::CheckFormatArguments(
const FormatAttr *Format,
11318 llvm::SmallBitVector &CheckedVarArgs) {
11319 FormatStringInfo FSI;
11322 return CheckFormatArguments(Args, FSI.ArgPassingKind, FSI.FormatIdx,
11324 CallType, Loc, Range, CheckedVarArgs);
11330 unsigned format_idx,
unsigned firstDataArg,
11331 FormatStringType
Type,
11334 llvm::SmallBitVector &CheckedVarArgs) {
11336 if (format_idx >= Args.size()) {
11337 Diag(Loc, diag::warn_missing_format_string) << Range;
11341 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
11355 UncoveredArgHandler UncoveredArg;
11357 *
this, OrigFormatExpr, Args, APK, format_idx, firstDataArg,
Type,
11359 true, CheckedVarArgs, UncoveredArg,
11360 llvm::APSInt(64,
false) = 0);
11363 if (UncoveredArg.hasUncoveredArg()) {
11364 unsigned ArgIdx = UncoveredArg.getUncoveredArg() + firstDataArg;
11365 assert(ArgIdx < Args.size() &&
"ArgIdx outside bounds");
11366 UncoveredArg.Diagnose(*
this,
true, Args[ArgIdx]);
11369 if (CT != SLCT_NotALiteral)
11371 return CT == SLCT_CheckedLiteral;
11388 if (Args.size() == firstDataArg) {
11389 Diag(FormatLoc, diag::warn_format_nonliteral_noargs)
11397 Diag(FormatLoc, diag::note_format_security_fixit)
11401 Diag(FormatLoc, diag::note_format_security_fixit)
11406 Diag(FormatLoc, diag::warn_format_nonliteral)
11417 const FormatStringLiteral *FExpr;
11418 const Expr *OrigFormatExpr;
11420 const unsigned FirstDataArg;
11421 const unsigned NumDataArgs;
11425 unsigned FormatIdx;
11426 llvm::SmallBitVector CoveredArgs;
11427 bool usesPositionalArgs =
false;
11428 bool atFirstArg =
true;
11429 bool inFunctionCall;
11431 llvm::SmallBitVector &CheckedVarArgs;
11432 UncoveredArgHandler &UncoveredArg;
11435 CheckFormatHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11436 const Expr *origFormatExpr,
11438 unsigned numDataArgs,
const char *beg,
11442 llvm::SmallBitVector &CheckedVarArgs,
11443 UncoveredArgHandler &UncoveredArg)
11444 : S(
s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(
type),
11445 FirstDataArg(firstDataArg), NumDataArgs(numDataArgs), Beg(beg),
11446 ArgPassingKind(APK), Args(Args), FormatIdx(formatIdx),
11447 inFunctionCall(inFunctionCall), CallType(callType),
11448 CheckedVarArgs(CheckedVarArgs), UncoveredArg(UncoveredArg) {
11449 CoveredArgs.resize(numDataArgs);
11450 CoveredArgs.reset();
11453 void DoneProcessing();
11455 void HandleIncompleteSpecifier(
const char *startSpecifier,
11456 unsigned specifierLen)
override;
11458 void HandleInvalidLengthModifier(
11461 const char *startSpecifier,
unsigned specifierLen,
11464 void HandleNonStandardLengthModifier(
11466 const char *startSpecifier,
unsigned specifierLen);
11468 void HandleNonStandardConversionSpecifier(
11470 const char *startSpecifier,
unsigned specifierLen);
11472 void HandlePosition(
const char *startPos,
unsigned posLen)
override;
11474 void HandleInvalidPosition(
const char *startSpecifier,
11475 unsigned specifierLen,
11478 void HandleZeroPosition(
const char *startPos,
unsigned posLen)
override;
11480 void HandleNullChar(
const char *nullCharacter)
override;
11482 template <
typename Range>
11484 EmitFormatDiagnostic(
Sema &S,
bool inFunctionCall,
const Expr *ArgumentExpr,
11486 bool IsStringLocation, Range StringRange,
11490 bool HandleInvalidConversionSpecifier(
unsigned argIndex,
SourceLocation Loc,
11491 const char *startSpec,
11492 unsigned specifierLen,
11493 const char *csStart,
unsigned csLen);
11496 const char *startSpec,
11497 unsigned specifierLen);
11501 unsigned specifierLen);
11504 const Expr *getDataArg(
unsigned i)
const;
11508 const char *startSpecifier,
unsigned specifierLen,
11509 unsigned argIndex);
11511 template <
typename Range>
11513 bool IsStringLocation, Range StringRange,
11519SourceRange CheckFormatHandler::getFormatStringRange() {
11524getSpecifierRange(
const char *startSpecifier,
unsigned specifierLen) {
11526 SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
11529 End = End.getLocWithOffset(1);
11534SourceLocation CheckFormatHandler::getLocationOfByte(
const char *x) {
11539void CheckFormatHandler::HandleIncompleteSpecifier(
const char *startSpecifier,
11540 unsigned specifierLen){
11541 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_incomplete_specifier),
11542 getLocationOfByte(startSpecifier),
11544 getSpecifierRange(startSpecifier, specifierLen));
11547void CheckFormatHandler::HandleInvalidLengthModifier(
11550 const char *startSpecifier,
unsigned specifierLen,
unsigned DiagID) {
11551 using namespace analyze_format_string;
11553 const LengthModifier &LM = FS.getLengthModifier();
11554 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11557 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11559 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11560 getLocationOfByte(LM.getStart()),
11562 getSpecifierRange(startSpecifier, specifierLen));
11564 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11565 << FixedLM->toString()
11570 if (DiagID == diag::warn_format_nonsensical_length)
11573 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11574 getLocationOfByte(LM.getStart()),
11576 getSpecifierRange(startSpecifier, specifierLen),
11581void CheckFormatHandler::HandleNonStandardLengthModifier(
11583 const char *startSpecifier,
unsigned specifierLen) {
11584 using namespace analyze_format_string;
11586 const LengthModifier &LM = FS.getLengthModifier();
11587 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11590 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11592 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11593 << LM.toString() << 0,
11594 getLocationOfByte(LM.getStart()),
11596 getSpecifierRange(startSpecifier, specifierLen));
11598 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11599 << FixedLM->toString()
11603 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11604 << LM.toString() << 0,
11605 getLocationOfByte(LM.getStart()),
11607 getSpecifierRange(startSpecifier, specifierLen));
11611void CheckFormatHandler::HandleNonStandardConversionSpecifier(
11613 const char *startSpecifier,
unsigned specifierLen) {
11614 using namespace analyze_format_string;
11619 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11623 getSpecifierRange(startSpecifier, specifierLen));
11626 S.
Diag(getLocationOfByte(CS.
getStart()), diag::note_format_fix_specifier)
11627 << FixedCS->toString()
11630 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11634 getSpecifierRange(startSpecifier, specifierLen));
11638void CheckFormatHandler::HandlePosition(
const char *startPos,
11640 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard_positional_arg),
11641 getLocationOfByte(startPos),
11643 getSpecifierRange(startPos, posLen));
11646void CheckFormatHandler::HandleInvalidPosition(
11647 const char *startSpecifier,
unsigned specifierLen,
11649 EmitFormatDiagnostic(
11650 S.
PDiag(diag::warn_format_invalid_positional_specifier) << (
unsigned)p,
11651 getLocationOfByte(startSpecifier),
true,
11652 getSpecifierRange(startSpecifier, specifierLen));
11655void CheckFormatHandler::HandleZeroPosition(
const char *startPos,
11657 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_zero_positional_specifier),
11658 getLocationOfByte(startPos),
11660 getSpecifierRange(startPos, posLen));
11663void CheckFormatHandler::HandleNullChar(
const char *nullCharacter) {
11664 if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
11666 EmitFormatDiagnostic(
11667 S.
PDiag(diag::warn_printf_format_string_contains_null_char),
11668 getLocationOfByte(nullCharacter),
true,
11669 getFormatStringRange());
11675const Expr *CheckFormatHandler::getDataArg(
unsigned i)
const {
11676 return Args[FirstDataArg + i];
11679void CheckFormatHandler::DoneProcessing() {
11684 CoveredArgs.flip();
11685 signed notCoveredArg = CoveredArgs.find_first();
11686 if (notCoveredArg >= 0) {
11687 assert((
unsigned)notCoveredArg < NumDataArgs);
11688 UncoveredArg.Update(notCoveredArg, OrigFormatExpr);
11690 UncoveredArg.setAllCovered();
11695void UncoveredArgHandler::Diagnose(
Sema &S,
bool IsFunctionCall,
11696 const Expr *ArgExpr) {
11697 assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
11709 for (
auto E : DiagnosticExprs)
11712 CheckFormatHandler::EmitFormatDiagnostic(
11713 S, IsFunctionCall, DiagnosticExprs[0],
11719CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex,
11721 const char *startSpec,
11722 unsigned specifierLen,
11723 const char *csStart,
11725 bool keepGoing =
true;
11726 if (argIndex < NumDataArgs) {
11729 CoveredArgs.set(argIndex);
11745 std::string CodePointStr;
11746 if (!llvm::sys::locale::isPrint(*csStart)) {
11747 llvm::UTF32 CodePoint;
11748 const llvm::UTF8 **B =
reinterpret_cast<const llvm::UTF8 **
>(&csStart);
11749 const llvm::UTF8 *E =
11750 reinterpret_cast<const llvm::UTF8 *
>(csStart + csLen);
11751 llvm::ConversionResult
Result =
11752 llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
11754 if (
Result != llvm::conversionOK) {
11755 unsigned char FirstChar = *csStart;
11756 CodePoint = (llvm::UTF32)FirstChar;
11759 llvm::raw_string_ostream OS(CodePointStr);
11760 if (CodePoint < 256)
11761 OS <<
"\\x" << llvm::format(
"%02x", CodePoint);
11762 else if (CodePoint <= 0xFFFF)
11763 OS <<
"\\u" << llvm::format(
"%04x", CodePoint);
11765 OS <<
"\\U" << llvm::format(
"%08x", CodePoint);
11770 EmitFormatDiagnostic(
11771 S.
PDiag(diag::warn_format_invalid_conversion) << Specifier, Loc,
11772 true, getSpecifierRange(startSpec, specifierLen));
11778CheckFormatHandler::HandlePositionalNonpositionalArgs(
SourceLocation Loc,
11779 const char *startSpec,
11780 unsigned specifierLen) {
11781 EmitFormatDiagnostic(
11782 S.
PDiag(diag::warn_format_mix_positional_nonpositional_args),
11783 Loc,
true, getSpecifierRange(startSpec, specifierLen));
11787CheckFormatHandler::CheckNumArgs(
11790 const char *startSpecifier,
unsigned specifierLen,
unsigned argIndex) {
11792 if (argIndex >= NumDataArgs) {
11794 ? (S.
PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
11795 << (argIndex+1) << NumDataArgs)
11796 : S.
PDiag(diag::warn_printf_insufficient_data_args);
11797 EmitFormatDiagnostic(
11798 PDiag, getLocationOfByte(CS.
getStart()),
true,
11799 getSpecifierRange(startSpecifier, specifierLen));
11803 UncoveredArg.setAllCovered();
11809template<
typename Range>
11812 bool IsStringLocation,
11815 EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
11816 Loc, IsStringLocation, StringRange, FixIt);
11846template <
typename Range>
11847void CheckFormatHandler::EmitFormatDiagnostic(
11848 Sema &S,
bool InFunctionCall,
const Expr *ArgumentExpr,
11851 if (InFunctionCall) {
11856 S.
Diag(IsStringLocation ? ArgumentExpr->
getExprLoc() : Loc, PDiag)
11860 S.
Diag(IsStringLocation ? Loc : StringRange.getBegin(),
11861 diag::note_format_string_defined);
11863 Note << StringRange;
11872class CheckPrintfHandler :
public CheckFormatHandler {
11874 CheckPrintfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11875 const Expr *origFormatExpr,
11877 unsigned numDataArgs,
bool isObjC,
const char *beg,
11881 llvm::SmallBitVector &CheckedVarArgs,
11882 UncoveredArgHandler &UncoveredArg)
11883 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
11884 numDataArgs, beg, APK, Args, formatIdx,
11885 inFunctionCall, CallType, CheckedVarArgs,
11891 bool allowsObjCArg()
const {
11896 bool HandleInvalidPrintfConversionSpecifier(
11898 const char *startSpecifier,
11899 unsigned specifierLen)
override;
11901 void handleInvalidMaskType(StringRef MaskType)
override;
11904 const char *startSpecifier,
unsigned specifierLen,
11907 const char *StartSpecifier,
11908 unsigned SpecifierLen,
11912 const char *startSpecifier,
unsigned specifierLen);
11916 const char *startSpecifier,
unsigned specifierLen);
11919 const char *startSpecifier,
unsigned specifierLen);
11923 const char *startSpecifier,
unsigned specifierLen);
11927 void HandleEmptyObjCModifierFlag(
const char *startFlag,
11928 unsigned flagLen)
override;
11930 void HandleInvalidObjCModifierFlag(
const char *startFlag,
11931 unsigned flagLen)
override;
11933 void HandleObjCFlagsWithNonObjCConversion(
const char *flagsStart,
11934 const char *flagsEnd,
11935 const char *conversionPosition)
11941bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
11943 const char *startSpecifier,
11944 unsigned specifierLen) {
11946 FS.getConversionSpecifier();
11948 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
11950 startSpecifier, specifierLen,
11954void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
11955 S.
Diag(getLocationOfByte(MaskType.data()), diag::err_invalid_mask_type_size);
11958bool CheckPrintfHandler::HandleAmount(
11960 const char *startSpecifier,
unsigned specifierLen) {
11964 if (argIndex >= NumDataArgs) {
11965 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_missing_arg)
11967 getLocationOfByte(Amt.
getStart()),
11969 getSpecifierRange(startSpecifier, specifierLen));
11979 CoveredArgs.set(argIndex);
11980 const Expr *Arg = getDataArg(argIndex);
11990 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_wrong_type)
11993 getLocationOfByte(Amt.
getStart()),
11995 getSpecifierRange(startSpecifier, specifierLen));
12005void CheckPrintfHandler::HandleInvalidAmount(
12009 const char *startSpecifier,
12010 unsigned specifierLen) {
12012 FS.getConversionSpecifier();
12020 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_optional_amount)
12022 getLocationOfByte(Amt.
getStart()),
12024 getSpecifierRange(startSpecifier, specifierLen),
12030 const char *startSpecifier,
12031 unsigned specifierLen) {
12034 FS.getConversionSpecifier();
12035 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_flag)
12039 getSpecifierRange(startSpecifier, specifierLen),
12044void CheckPrintfHandler::HandleIgnoredFlag(
12048 const char *startSpecifier,
12049 unsigned specifierLen) {
12051 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_ignored_flag)
12055 getSpecifierRange(startSpecifier, specifierLen),
12057 getSpecifierRange(ignoredFlag.
getPosition(), 1)));
12060void CheckPrintfHandler::HandleEmptyObjCModifierFlag(
const char *startFlag,
12061 unsigned flagLen) {
12063 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_empty_objc_flag),
12064 getLocationOfByte(startFlag),
12066 getSpecifierRange(startFlag, flagLen));
12069void CheckPrintfHandler::HandleInvalidObjCModifierFlag(
const char *startFlag,
12070 unsigned flagLen) {
12072 auto Range = getSpecifierRange(startFlag, flagLen);
12073 StringRef flag(startFlag, flagLen);
12074 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_invalid_objc_flag) << flag,
12075 getLocationOfByte(startFlag),
12080void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
12081 const char *flagsStart,
const char *flagsEnd,
const char *conversionPosition) {
12083 auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
12084 auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
12085 EmitFormatDiagnostic(S.
PDiag(diag) << StringRef(conversionPosition, 1),
12086 getLocationOfByte(conversionPosition),
12094template<
typename MemberKind>
12115 if (MemberKind *FK = dyn_cast<MemberKind>(
decl))
12116 Results.insert(FK);
12128 MethodSet Results =
12129 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", *
this, E->
getType());
12130 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12132 if ((*MI)->getMinRequiredArguments() == 0)
12140bool CheckPrintfHandler::checkForCStrMembers(
12144 MethodSet Results =
12145 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", S, E->
getType());
12147 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12163bool CheckPrintfHandler::HandlePrintfSpecifier(
12166 using namespace analyze_format_string;
12167 using namespace analyze_printf;
12169 const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
12171 if (FS.consumesDataArgument()) {
12173 atFirstArg =
false;
12174 usesPositionalArgs = FS.usesPositionalArg();
12176 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12177 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12178 startSpecifier, specifierLen);
12185 if (!HandleAmount(FS.getFieldWidth(), 0,
12186 startSpecifier, specifierLen)) {
12190 if (!HandleAmount(FS.getPrecision(), 1,
12191 startSpecifier, specifierLen)) {
12195 if (!CS.consumesDataArgument()) {
12202 unsigned argIndex = FS.getArgIndex();
12203 if (argIndex < NumDataArgs) {
12207 CoveredArgs.set(argIndex);
12211 if (CS.getKind() == ConversionSpecifier::FreeBSDbArg ||
12212 CS.getKind() == ConversionSpecifier::FreeBSDDArg) {
12214 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex + 1))
12218 CoveredArgs.set(argIndex + 1);
12221 const Expr *Ex = getDataArg(argIndex);
12223 (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
12226 EmitFormatDiagnostic(
12227 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12231 getSpecifierRange(startSpecifier, specifierLen));
12234 Ex = getDataArg(argIndex + 1);
12237 EmitFormatDiagnostic(
12238 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12242 getSpecifierRange(startSpecifier, specifierLen));
12249 if (!allowsObjCArg() && CS.isObjCArg()) {
12250 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12255 if (FSType !=
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::PArg) {
12256 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12261 if (FSType ==
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {
12262 EmitFormatDiagnostic(S.
PDiag(diag::warn_os_log_format_narg),
12263 getLocationOfByte(CS.getStart()),
12265 getSpecifierRange(startSpecifier, specifierLen));
12272 (CS.getKind() == ConversionSpecifier::PArg ||
12273 CS.getKind() == ConversionSpecifier::sArg ||
12274 CS.getKind() == ConversionSpecifier::ObjCObjArg)) {
12275 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12281 if (FS.isPublic().isSet()) {
12282 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12284 getLocationOfByte(FS.isPublic().getPosition()),
12286 getSpecifierRange(startSpecifier, specifierLen));
12288 if (FS.isPrivate().isSet()) {
12289 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12291 getLocationOfByte(FS.isPrivate().getPosition()),
12293 getSpecifierRange(startSpecifier, specifierLen));
12297 const llvm::Triple &Triple =
Target.getTriple();
12298 if (CS.getKind() == ConversionSpecifier::nArg &&
12299 (Triple.isAndroid() || Triple.isOSFuchsia())) {
12300 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_narg_not_supported),
12301 getLocationOfByte(CS.getStart()),
12303 getSpecifierRange(startSpecifier, specifierLen));
12307 if (!FS.hasValidFieldWidth()) {
12308 HandleInvalidAmount(FS, FS.getFieldWidth(), 0,
12309 startSpecifier, specifierLen);
12313 if (!FS.hasValidPrecision()) {
12314 HandleInvalidAmount(FS, FS.getPrecision(), 1,
12315 startSpecifier, specifierLen);
12319 if (CS.getKind() == ConversionSpecifier::PArg &&
12320 FS.getPrecision().getHowSpecified() == OptionalAmount::NotSpecified) {
12321 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_no_precision),
12322 getLocationOfByte(startSpecifier),
12324 getSpecifierRange(startSpecifier, specifierLen));
12328 if (!FS.hasValidThousandsGroupingPrefix())
12329 HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen);
12330 if (!FS.hasValidLeadingZeros())
12331 HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
12332 if (!FS.hasValidPlusPrefix())
12333 HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
12334 if (!FS.hasValidSpacePrefix())
12335 HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
12336 if (!FS.hasValidAlternativeForm())
12337 HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
12338 if (!FS.hasValidLeftJustified())
12339 HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
12342 if (FS.hasSpacePrefix() && FS.hasPlusPrefix())
12343 HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
12344 startSpecifier, specifierLen);
12345 if (FS.hasLeadingZeros() && FS.isLeftJustified())
12346 HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
12347 startSpecifier, specifierLen);
12352 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12353 diag::warn_format_nonsensical_length);
12354 else if (!FS.hasStandardLengthModifier())
12355 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12356 else if (!FS.hasStandardLengthConversionCombination())
12357 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12358 diag::warn_format_non_standard_conversion_spec);
12360 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12361 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12367 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12370 const Expr *Arg = getDataArg(argIndex);
12374 return checkFormatExpr(FS, startSpecifier, specifierLen, Arg);
12386 case Stmt::ArraySubscriptExprClass:
12387 case Stmt::CallExprClass:
12388 case Stmt::CharacterLiteralClass:
12389 case Stmt::CXXBoolLiteralExprClass:
12390 case Stmt::DeclRefExprClass:
12391 case Stmt::FloatingLiteralClass:
12392 case Stmt::IntegerLiteralClass:
12393 case Stmt::MemberExprClass:
12394 case Stmt::ObjCArrayLiteralClass:
12395 case Stmt::ObjCBoolLiteralExprClass:
12396 case Stmt::ObjCBoxedExprClass:
12397 case Stmt::ObjCDictionaryLiteralClass:
12398 case Stmt::ObjCEncodeExprClass:
12399 case Stmt::ObjCIvarRefExprClass:
12400 case Stmt::ObjCMessageExprClass:
12401 case Stmt::ObjCPropertyRefExprClass:
12402 case Stmt::ObjCStringLiteralClass:
12403 case Stmt::ObjCSubscriptRefExprClass:
12404 case Stmt::ParenExprClass:
12405 case Stmt::StringLiteralClass:
12406 case Stmt::UnaryOperatorClass:
12413static std::pair<QualType, StringRef>
12420 StringRef Name = UserTy->getDecl()->getName();
12421 QualType CastTy = llvm::StringSwitch<QualType>(Name)
12425 .Case(
"SInt32", Context.
IntTy)
12430 return std::make_pair(CastTy, Name);
12432 TyTy = UserTy->desugar();
12436 if (
const ParenExpr *PE = dyn_cast<ParenExpr>(E))
12438 PE->getSubExpr()->getType(),
12447 StringRef TrueName, FalseName;
12449 std::tie(TrueTy, TrueName) =
12451 CO->getTrueExpr()->getType(),
12452 CO->getTrueExpr());
12453 std::tie(FalseTy, FalseName) =
12455 CO->getFalseExpr()->getType(),
12456 CO->getFalseExpr());
12458 if (TrueTy == FalseTy)
12459 return std::make_pair(TrueTy, TrueName);
12460 else if (TrueTy.
isNull())
12461 return std::make_pair(FalseTy, FalseName);
12462 else if (FalseTy.
isNull())
12463 return std::make_pair(TrueTy, TrueName);
12466 return std::make_pair(
QualType(), StringRef());
12485 From = VecTy->getElementType();
12487 To = VecTy->getElementType();
12499 diag::warn_format_conversion_argument_type_mismatch_signedness, Loc)
12508 const char *StartSpecifier,
12509 unsigned SpecifierLen,
12511 using namespace analyze_format_string;
12512 using namespace analyze_printf;
12521 while (
const TypeOfExprType *TET = dyn_cast<TypeOfExprType>(ExprTy)) {
12522 ExprTy = TET->getUnderlyingExpr()->getType();
12534 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::cArg &&
12537 getSpecifierRange(StartSpecifier, SpecifierLen);
12539 llvm::raw_svector_ostream os(FSString);
12541 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_bool_as_character)
12547 ArgType::MatchKind ImplicitMatch = ArgType::NoMatch;
12549 ArgType::MatchKind OrigMatch = Match;
12552 if (Match == ArgType::Match)
12556 assert(Match != ArgType::NoMatchPromotionTypeConfusion);
12565 E = ICE->getSubExpr();
12575 if (OrigMatch == ArgType::NoMatchSignedness &&
12576 ImplicitMatch != ArgType::NoMatchSignedness)
12583 if (ImplicitMatch == ArgType::Match)
12594 FS.getLengthModifier().getKind() != LengthModifier::AsChar)
12601 if (Match == ArgType::MatchPromotion)
12602 Match = ArgType::NoMatch;
12605 if (Match == ArgType::MatchPromotion) {
12609 ImplicitMatch != ArgType::NoMatchPromotionTypeConfusion &&
12610 ImplicitMatch != ArgType::NoMatchTypeConfusion)
12612 Match = ArgType::NoMatch;
12614 if (ImplicitMatch == ArgType::NoMatchPedantic ||
12615 ImplicitMatch == ArgType::NoMatchTypeConfusion)
12616 Match = ImplicitMatch;
12617 assert(Match != ArgType::MatchPromotion);
12620 bool IsEnum =
false;
12621 bool IsScopedEnum =
false;
12624 IntendedTy = EnumTy->getDecl()->getIntegerType();
12625 if (EnumTy->isUnscopedEnumerationType()) {
12626 ExprTy = IntendedTy;
12631 IsScopedEnum =
true;
12638 if (isObjCContext() &&
12639 FS.getConversionSpecifier().getKind() == ConversionSpecifier::CArg) {
12649 const llvm::APInt &
V = IL->getValue();
12659 if (TD->getUnderlyingType() == IntendedTy)
12667 bool ShouldNotPrintDirectly =
false; StringRef CastTyName;
12675 if (!IsScopedEnum &&
12676 (CastTyName ==
"NSInteger" || CastTyName ==
"NSUInteger") &&
12679 Match = ArgType::NoMatchPedantic;
12680 IntendedTy = CastTy;
12681 ShouldNotPrintDirectly =
true;
12686 PrintfSpecifier fixedFS = FS;
12693 llvm::raw_svector_ostream os(buf);
12694 fixedFS.toString(os);
12696 CharSourceRange SpecRange = getSpecifierRange(StartSpecifier, SpecifierLen);
12698 if (IntendedTy == ExprTy && !ShouldNotPrintDirectly && !IsScopedEnum) {
12701 case ArgType::Match:
12702 case ArgType::MatchPromotion:
12703 case ArgType::NoMatchPromotionTypeConfusion:
12704 case ArgType::NoMatchSignedness:
12705 llvm_unreachable(
"expected non-matching");
12706 case ArgType::NoMatchPedantic:
12707 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12709 case ArgType::NoMatchTypeConfusion:
12710 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12712 case ArgType::NoMatch:
12713 Diag = diag::warn_format_conversion_argument_type_mismatch;
12734 llvm::raw_svector_ostream CastFix(CastBuf);
12735 CastFix << (S.
LangOpts.CPlusPlus ?
"static_cast<" :
"(");
12737 CastFix << (S.
LangOpts.CPlusPlus ?
">" :
")");
12743 if ((IntendedMatch != ArgType::Match) || ShouldNotPrintDirectly)
12746 if (
const CStyleCastExpr *CCast = dyn_cast<CStyleCastExpr>(E)) {
12748 SourceRange CastRange(CCast->getLParenLoc(), CCast->getRParenLoc());
12770 if (ShouldNotPrintDirectly && !IsScopedEnum) {
12776 Name = TypedefTy->getDecl()->getName();
12779 unsigned Diag = Match == ArgType::NoMatchPedantic
12780 ? diag::warn_format_argument_needs_cast_pedantic
12781 : diag::warn_format_argument_needs_cast;
12782 EmitFormatDiagnostic(S.
PDiag(
Diag) << Name << IntendedTy << IsEnum
12793 ? diag::warn_format_conversion_argument_type_mismatch_pedantic
12794 : diag::warn_format_conversion_argument_type_mismatch;
12796 EmitFormatDiagnostic(
12808 bool EmitTypeMismatch =
false;
12814 case ArgType::Match:
12815 case ArgType::MatchPromotion:
12816 case ArgType::NoMatchPromotionTypeConfusion:
12817 case ArgType::NoMatchSignedness:
12818 llvm_unreachable(
"expected non-matching");
12819 case ArgType::NoMatchPedantic:
12820 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12822 case ArgType::NoMatchTypeConfusion:
12823 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12825 case ArgType::NoMatch:
12826 Diag = diag::warn_format_conversion_argument_type_mismatch;
12830 EmitFormatDiagnostic(
12839 EmitTypeMismatch =
true;
12841 EmitFormatDiagnostic(
12842 S.
PDiag(diag::warn_non_pod_vararg_with_format_string)
12843 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12847 checkForCStrMembers(AT, E);
12853 EmitTypeMismatch =
true;
12855 EmitFormatDiagnostic(
12856 S.
PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
12857 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12865 << isa<InitListExpr>(E) << ExprTy << CallType
12870 if (EmitTypeMismatch) {
12876 EmitFormatDiagnostic(
12877 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12883 assert(FirstDataArg + FS.getArgIndex() < CheckedVarArgs.size() &&
12884 "format string specifier index out of range");
12885 CheckedVarArgs[FirstDataArg + FS.getArgIndex()] =
true;
12895class CheckScanfHandler :
public CheckFormatHandler {
12897 CheckScanfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
12899 unsigned firstDataArg,
unsigned numDataArgs,
12903 llvm::SmallBitVector &CheckedVarArgs,
12904 UncoveredArgHandler &UncoveredArg)
12905 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
12906 numDataArgs, beg, APK, Args, formatIdx,
12907 inFunctionCall, CallType, CheckedVarArgs,
12911 const char *startSpecifier,
12912 unsigned specifierLen)
override;
12914 bool HandleInvalidScanfConversionSpecifier(
12916 const char *startSpecifier,
12917 unsigned specifierLen)
override;
12919 void HandleIncompleteScanList(
const char *start,
const char *end)
override;
12924void CheckScanfHandler::HandleIncompleteScanList(
const char *start,
12926 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_scanlist_incomplete),
12927 getLocationOfByte(end),
true,
12928 getSpecifierRange(start, end - start));
12931bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
12933 const char *startSpecifier,
12934 unsigned specifierLen) {
12936 FS.getConversionSpecifier();
12938 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
12940 startSpecifier, specifierLen,
12944bool CheckScanfHandler::HandleScanfSpecifier(
12946 const char *startSpecifier,
12947 unsigned specifierLen) {
12948 using namespace analyze_scanf;
12949 using namespace analyze_format_string;
12951 const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
12955 if (FS.consumesDataArgument()) {
12957 atFirstArg =
false;
12958 usesPositionalArgs = FS.usesPositionalArg();
12960 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12961 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12962 startSpecifier, specifierLen);
12968 const OptionalAmount &Amt = FS.getFieldWidth();
12969 if (Amt.getHowSpecified() == OptionalAmount::Constant) {
12970 if (Amt.getConstantAmount() == 0) {
12972 Amt.getConstantLength());
12973 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_nonzero_width),
12974 getLocationOfByte(Amt.getStart()),
12980 if (!FS.consumesDataArgument()) {
12987 unsigned argIndex = FS.getArgIndex();
12988 if (argIndex < NumDataArgs) {
12992 CoveredArgs.set(argIndex);
12998 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12999 diag::warn_format_nonsensical_length);
13000 else if (!FS.hasStandardLengthModifier())
13001 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
13002 else if (!FS.hasStandardLengthConversionCombination())
13003 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
13004 diag::warn_format_non_standard_conversion_spec);
13006 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
13007 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
13013 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
13017 const Expr *Ex = getDataArg(argIndex);
13034 ScanfSpecifier fixedFS = FS;
13039 Pedantic ? diag::warn_format_conversion_argument_type_mismatch_pedantic
13040 : diag::warn_format_conversion_argument_type_mismatch;
13045 llvm::raw_svector_ostream os(buf);
13046 fixedFS.toString(os);
13048 EmitFormatDiagnostic(
13053 getSpecifierRange(startSpecifier, specifierLen),
13055 getSpecifierRange(startSpecifier, specifierLen), os.str()));
13062 getSpecifierRange(startSpecifier, specifierLen));
13069 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
13073 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
13074 bool IgnoreStringsWithoutSpecifiers) {
13076 if (!FExpr->isAscii() && !FExpr->isUTF8()) {
13077 CheckFormatHandler::EmitFormatDiagnostic(
13078 S, inFunctionCall, Args[format_idx],
13079 S.
PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
13085 StringRef StrRef = FExpr->getString();
13086 const char *Str = StrRef.data();
13090 assert(
T &&
"String literal not of constant array type!");
13091 size_t TypeSize =
T->getZExtSize();
13092 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13093 const unsigned numDataArgs = Args.size() - firstDataArg;
13095 if (IgnoreStringsWithoutSpecifiers &&
13102 if (TypeSize <= StrRef.size() && !StrRef.substr(0, TypeSize).contains(
'\0')) {
13103 CheckFormatHandler::EmitFormatDiagnostic(
13104 S, inFunctionCall, Args[format_idx],
13105 S.
PDiag(diag::warn_printf_format_string_not_null_terminated),
13106 FExpr->getBeginLoc(),
13112 if (StrLen == 0 && numDataArgs > 0) {
13113 CheckFormatHandler::EmitFormatDiagnostic(
13114 S, inFunctionCall, Args[format_idx],
13115 S.
PDiag(diag::warn_empty_format_string), FExpr->getBeginLoc(),
13123 CheckPrintfHandler H(
13124 S, FExpr, OrigFormatExpr,
Type, firstDataArg, numDataArgs,
13126 Args, format_idx, inFunctionCall, CallType, CheckedVarArgs,
13132 H.DoneProcessing();
13134 CheckScanfHandler H(S, FExpr, OrigFormatExpr,
Type, firstDataArg,
13135 numDataArgs, Str, APK, Args, format_idx, inFunctionCall,
13136 CallType, CheckedVarArgs, UncoveredArg);
13140 H.DoneProcessing();
13147 const char *Str = StrRef.data();
13150 assert(
T &&
"String literal not of constant array type!");
13151 size_t TypeSize =
T->getZExtSize();
13152 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13163 switch (AbsFunction) {
13167 case Builtin::BI__builtin_abs:
13168 return Builtin::BI__builtin_labs;
13169 case Builtin::BI__builtin_labs:
13170 return Builtin::BI__builtin_llabs;
13171 case Builtin::BI__builtin_llabs:
13174 case Builtin::BI__builtin_fabsf:
13175 return Builtin::BI__builtin_fabs;
13176 case Builtin::BI__builtin_fabs:
13177 return Builtin::BI__builtin_fabsl;
13178 case Builtin::BI__builtin_fabsl:
13181 case Builtin::BI__builtin_cabsf:
13182 return Builtin::BI__builtin_cabs;
13183 case Builtin::BI__builtin_cabs:
13184 return Builtin::BI__builtin_cabsl;
13185 case Builtin::BI__builtin_cabsl:
13188 case Builtin::BIabs:
13189 return Builtin::BIlabs;
13190 case Builtin::BIlabs:
13191 return Builtin::BIllabs;
13192 case Builtin::BIllabs:
13195 case Builtin::BIfabsf:
13196 return Builtin::BIfabs;
13197 case Builtin::BIfabs:
13198 return Builtin::BIfabsl;
13199 case Builtin::BIfabsl:
13202 case Builtin::BIcabsf:
13203 return Builtin::BIcabs;
13204 case Builtin::BIcabs:
13205 return Builtin::BIcabsl;
13206 case Builtin::BIcabsl:
13213 unsigned AbsType) {
13235 unsigned AbsFunctionKind) {
13236 unsigned BestKind = 0;
13238 for (
unsigned Kind = AbsFunctionKind; Kind != 0;
13244 else if (Context.
hasSameType(ParamType, ArgType)) {
13267 llvm_unreachable(
"Type not integer, floating, or complex");
13274 switch (ValueKind) {
13279 case Builtin::BI__builtin_fabsf:
13280 case Builtin::BI__builtin_fabs:
13281 case Builtin::BI__builtin_fabsl:
13282 case Builtin::BI__builtin_cabsf:
13283 case Builtin::BI__builtin_cabs:
13284 case Builtin::BI__builtin_cabsl:
13285 return Builtin::BI__builtin_abs;
13286 case Builtin::BIfabsf:
13287 case Builtin::BIfabs:
13288 case Builtin::BIfabsl:
13289 case Builtin::BIcabsf:
13290 case Builtin::BIcabs:
13291 case Builtin::BIcabsl:
13292 return Builtin::BIabs;
13298 case Builtin::BI__builtin_abs:
13299 case Builtin::BI__builtin_labs:
13300 case Builtin::BI__builtin_llabs:
13301 case Builtin::BI__builtin_cabsf:
13302 case Builtin::BI__builtin_cabs:
13303 case Builtin::BI__builtin_cabsl:
13304 return Builtin::BI__builtin_fabsf;
13305 case Builtin::BIabs:
13306 case Builtin::BIlabs:
13307 case Builtin::BIllabs:
13308 case Builtin::BIcabsf:
13309 case Builtin::BIcabs:
13310 case Builtin::BIcabsl:
13311 return Builtin::BIfabsf;
13317 case Builtin::BI__builtin_abs:
13318 case Builtin::BI__builtin_labs:
13319 case Builtin::BI__builtin_llabs:
13320 case Builtin::BI__builtin_fabsf:
13321 case Builtin::BI__builtin_fabs:
13322 case Builtin::BI__builtin_fabsl:
13323 return Builtin::BI__builtin_cabsf;
13324 case Builtin::BIabs:
13325 case Builtin::BIlabs:
13326 case Builtin::BIllabs:
13327 case Builtin::BIfabsf:
13328 case Builtin::BIfabs:
13329 case Builtin::BIfabsl:
13330 return Builtin::BIcabsf;
13333 llvm_unreachable(
"Unable to convert function");
13344 case Builtin::BI__builtin_abs:
13345 case Builtin::BI__builtin_fabs:
13346 case Builtin::BI__builtin_fabsf:
13347 case Builtin::BI__builtin_fabsl:
13348 case Builtin::BI__builtin_labs:
13349 case Builtin::BI__builtin_llabs:
13350 case Builtin::BI__builtin_cabs:
13351 case Builtin::BI__builtin_cabsf:
13352 case Builtin::BI__builtin_cabsl:
13353 case Builtin::BIabs:
13354 case Builtin::BIlabs:
13355 case Builtin::BIllabs:
13356 case Builtin::BIfabs:
13357 case Builtin::BIfabsf:
13358 case Builtin::BIfabsl:
13359 case Builtin::BIcabs:
13360 case Builtin::BIcabsf:
13361 case Builtin::BIcabsl:
13364 llvm_unreachable(
"Unknown Builtin type");
13370 unsigned AbsKind,
QualType ArgType) {
13371 bool EmitHeaderHint =
true;
13372 const char *HeaderName =
nullptr;
13373 StringRef FunctionName;
13375 FunctionName =
"std::abs";
13377 HeaderName =
"cstdlib";
13379 HeaderName =
"cmath";
13381 llvm_unreachable(
"Invalid Type");
13390 for (
const auto *I : R) {
13393 FDecl = dyn_cast<FunctionDecl>(UsingD->getTargetDecl());
13395 FDecl = dyn_cast<FunctionDecl>(I);
13410 EmitHeaderHint =
false;
13428 EmitHeaderHint =
false;
13432 }
else if (!R.
empty()) {
13438 S.
Diag(Loc, diag::note_replace_abs_function)
13444 if (!EmitHeaderHint)
13447 S.
Diag(Loc, diag::note_include_header_or_declare) << HeaderName
13451template <std::
size_t StrLen>
13453 const char (&Str)[StrLen]) {
13468 (
Call->getBuiltinCallee() == Builtin::BI__builtin_nanf)) &&
13469 FPO.getNoHonorNaNs())
13470 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13471 << 1 << 0 <<
Call->getSourceRange();
13475 FPO.getNoHonorInfs())
13476 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13477 << 0 << 0 <<
Call->getSourceRange();
13481void Sema::CheckAbsoluteValueFunction(
const CallExpr *
Call,
13483 if (
Call->getNumArgs() != 1)
13488 if (AbsKind == 0 && !IsStdAbs)
13491 QualType ArgType =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13497 StringRef FunctionName =
13499 Diag(
Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
13500 Diag(
Call->getExprLoc(), diag::note_remove_abs)
13509 unsigned DiagType = 0;
13515 Diag(
Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;
13529 if (ArgValueKind == ParamValueKind) {
13534 Diag(
Call->getExprLoc(), diag::warn_abs_too_small)
13535 << FDecl << ArgType << ParamType;
13537 if (NewAbsKind == 0)
13541 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13550 if (NewAbsKind == 0)
13553 Diag(
Call->getExprLoc(), diag::warn_wrong_absolute_value_type)
13554 << FDecl << ParamValueKind << ArgValueKind;
13557 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13563 if (!
Call || !FDecl)
return;
13567 if (
Call->getExprLoc().isMacroID())
return;
13570 if (
Call->getNumArgs() != 2)
return;
13573 if (!ArgList)
return;
13574 if (ArgList->size() != 1)
return;
13577 const auto& TA = ArgList->
get(0);
13579 QualType ArgType = TA.getAsType();
13583 auto IsLiteralZeroArg = [](
const Expr* E) ->
bool {
13584 const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
13585 if (!MTE)
return false;
13586 const auto *Num = dyn_cast<IntegerLiteral>(MTE->getSubExpr());
13587 if (!Num)
return false;
13588 if (Num->getValue() != 0)
return false;
13592 const Expr *FirstArg =
Call->getArg(0);
13593 const Expr *SecondArg =
Call->getArg(1);
13594 const bool IsFirstArgZero = IsLiteralZeroArg(FirstArg);
13595 const bool IsSecondArgZero = IsLiteralZeroArg(SecondArg);
13598 if (IsFirstArgZero == IsSecondArgZero)
return;
13603 SourceRange ZeroRange = IsFirstArgZero ? FirstRange : SecondRange;
13605 Diag(
Call->getExprLoc(), diag::warn_max_unsigned_zero)
13606 << IsFirstArgZero <<
Call->getCallee()->getSourceRange() << ZeroRange;
13610 if (IsFirstArgZero) {
13618 Diag(
Call->getExprLoc(), diag::note_remove_max_call)
13638 if (!Size->isComparisonOp() && !Size->isLogicalOp())
13642 S.
Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison)
13643 << SizeRange << FnName;
13644 S.
Diag(FnLoc, diag::note_memsize_comparison_paren)
13649 S.
Diag(SizeRange.
getBegin(), diag::note_memsize_comparison_cast_silence)
13660 bool &IsContained) {
13663 IsContained =
false;
13676 for (
auto *FD : RD->
fields()) {
13680 IsContained =
true;
13681 return ContainedRD;
13689 if (
const auto *Unary = dyn_cast<UnaryExprOrTypeTraitExpr>(E))
13690 if (Unary->getKind() == UETT_SizeOf)
13699 if (!
SizeOf->isArgumentType())
13700 return SizeOf->getArgumentExpr()->IgnoreParenImpCasts();
13707 return SizeOf->getTypeOfArgument();
13713struct SearchNonTrivialToInitializeField
13718 SearchNonTrivialToInitializeField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13722 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13723 asDerived().visitArray(PDIK, AT, SL);
13727 Super::visitWithKind(PDIK, FT, SL);
13742 visit(getContext().getBaseElementType(AT), SL);
13747 SearchNonTrivialToInitializeField(E, S).visitStruct(RT,
SourceLocation());
13756struct SearchNonTrivialToCopyField
13760 SearchNonTrivialToCopyField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13764 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13765 asDerived().visitArray(PCK, AT, SL);
13769 Super::visitWithKind(PCK, FT, SL);
13784 visit(getContext().getBaseElementType(AT), SL);
13792 SearchNonTrivialToCopyField(E, S).visitStruct(RT,
SourceLocation());
13807 if (
const auto *BO = dyn_cast<BinaryOperator>(SizeofExpr)) {
13808 if (BO->getOpcode() != BO_Mul && BO->getOpcode() != BO_Add)
13832 return SM.getFileID(CallLoc) !=
SM.getFileID(ArgLoc);
13834 return SM.getFileID(
SM.getImmediateMacroCallerLoc(CallLoc)) !=
13835 SM.getFileID(
SM.getImmediateMacroCallerLoc(ArgLoc));
13841 if (BId != Builtin::BImemset && BId != Builtin::BIbzero)
13844 const Expr *SizeArg =
13845 Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
13847 auto isLiteralZero = [](
const Expr *E) {
13848 return (isa<IntegerLiteral>(E) &&
13849 cast<IntegerLiteral>(E)->getValue() == 0) ||
13850 (isa<CharacterLiteral>(E) &&
13851 cast<CharacterLiteral>(E)->getValue() == 0);
13857 if (isLiteralZero(SizeArg) &&
13864 if (BId == Builtin::BIbzero ||
13867 S.
Diag(DiagLoc, diag::warn_suspicious_bzero_size);
13868 S.
Diag(DiagLoc, diag::note_suspicious_bzero_size_silence);
13869 }
else if (!isLiteralZero(
Call->getArg(1)->IgnoreImpCasts())) {
13870 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 0;
13871 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 0;
13879 if (BId == Builtin::BImemset &&
13883 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 1;
13884 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 1;
13896void Sema::CheckMemaccessArguments(
const CallExpr *
Call,
13903 unsigned ExpectedNumArgs =
13904 (BId == Builtin::BIstrndup || BId == Builtin::BIbzero ? 2 : 3);
13905 if (
Call->getNumArgs() < ExpectedNumArgs)
13908 unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
13909 BId == Builtin::BIstrndup ? 1 : 2);
13911 (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
13912 const Expr *LenExpr =
Call->getArg(LenArg)->IgnoreParenImpCasts();
13915 Call->getBeginLoc(),
Call->getRParenLoc()))
13924 llvm::FoldingSetNodeID SizeOfArgID;
13929 QualType FirstArgTy =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13933 for (
unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {
13934 const Expr *Dest =
Call->getArg(ArgIdx)->IgnoreParenImpCasts();
13956 if (SizeOfArgID == llvm::FoldingSetNodeID())
13958 llvm::FoldingSetNodeID DestID;
13960 if (DestID == SizeOfArgID) {
13963 unsigned ActionIdx = 0;
13964 StringRef ReadableName = FnName->
getName();
13966 if (
const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
13967 if (UnaryOp->getOpcode() == UO_AddrOf)
13981 if (
SM.isMacroArgExpansion(SL)) {
13983 SL =
SM.getSpellingLoc(SL);
13991 PDiag(diag::warn_sizeof_pointer_expr_memaccess)
13998 PDiag(diag::warn_sizeof_pointer_expr_memaccess_note)
14013 PDiag(diag::warn_sizeof_pointer_type_memaccess)
14014 << FnName << SizeOfArgTy << ArgIdx
14021 PointeeTy = DestTy;
14032 unsigned OperationType = 0;
14033 const bool IsCmp = BId == Builtin::BImemcmp || BId == Builtin::BIbcmp;
14036 if (ArgIdx != 0 || IsCmp) {
14037 if (BId == Builtin::BImemcpy)
14039 else if(BId == Builtin::BImemmove)
14046 PDiag(diag::warn_dyn_class_memaccess)
14047 << (IsCmp ? ArgIdx + 2 : ArgIdx) << FnName
14048 << IsContained << ContainedRD << OperationType
14049 <<
Call->getCallee()->getSourceRange());
14051 BId != Builtin::BImemset)
14054 PDiag(diag::warn_arc_object_memaccess)
14055 << ArgIdx << FnName << PointeeTy
14056 <<
Call->getCallee()->getSourceRange());
14058 if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
14059 RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
14061 PDiag(diag::warn_cstruct_memaccess)
14062 << ArgIdx << FnName << PointeeTy << 0);
14063 SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *
this);
14064 }
else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
14065 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
14067 PDiag(diag::warn_cstruct_memaccess)
14068 << ArgIdx << FnName << PointeeTy << 1);
14069 SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *
this);
14078 PDiag(diag::note_bad_memaccess_silence)
14098 if (isa<IntegerLiteral>(RHS))
14100 else if (isa<IntegerLiteral>(LHS))
14114 if (CAT->getZExtSize() <= 1)
14124void Sema::CheckStrlcpycatArguments(
const CallExpr *
Call,
14128 unsigned NumArgs =
Call->getNumArgs();
14129 if ((NumArgs != 3) && (NumArgs != 4))
14134 const Expr *CompareWithSrc =
nullptr;
14137 Call->getBeginLoc(),
Call->getRParenLoc()))
14142 CompareWithSrc = Ex;
14145 if (
const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
14146 if (SizeCall->getBuiltinCallee() == Builtin::BIstrlen &&
14147 SizeCall->getNumArgs() == 1)
14152 if (!CompareWithSrc)
14159 const DeclRefExpr *SrcArgDRE = dyn_cast<DeclRefExpr>(SrcArg);
14163 const DeclRefExpr *CompareWithSrcDRE = dyn_cast<DeclRefExpr>(CompareWithSrc);
14164 if (!CompareWithSrcDRE ||
14168 const Expr *OriginalSizeArg =
Call->getArg(2);
14169 Diag(CompareWithSrcDRE->
getBeginLoc(), diag::warn_strlcpycat_wrong_size)
14176 const Expr *DstArg =
Call->getArg(0)->IgnoreParenImpCasts();
14181 llvm::raw_svector_ostream
OS(sizeString);
14186 Diag(OriginalSizeArg->
getBeginLoc(), diag::note_strlcpycat_wrong_size)
14193 if (
const DeclRefExpr *D1 = dyn_cast_or_null<DeclRefExpr>(E1))
14194 if (
const DeclRefExpr *D2 = dyn_cast_or_null<DeclRefExpr>(E2))
14195 return D1->getDecl() == D2->getDecl();
14200 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
14204 return CE->getArg(0)->IgnoreParenCasts();
14212void Sema::CheckStrncatArguments(
const CallExpr *CE,
14227 unsigned PatternType = 0;
14235 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(LenArg)) {
14236 if (BE->getOpcode() == BO_Sub) {
14249 if (PatternType == 0)
14258 if (
SM.isMacroArgExpansion(SL)) {
14259 SL =
SM.getSpellingLoc(SL);
14268 if (!isKnownSizeArray) {
14269 if (PatternType == 1)
14270 Diag(SL, diag::warn_strncat_wrong_size) << SR;
14272 Diag(SL, diag::warn_strncat_src_size) << SR;
14276 if (PatternType == 1)
14277 Diag(SL, diag::warn_strncat_large_size) << SR;
14279 Diag(SL, diag::warn_strncat_src_size) << SR;
14282 llvm::raw_svector_ostream
OS(sizeString);
14290 Diag(SL, diag::note_strncat_wrong_size)
14295void CheckFreeArgumentsOnLvalue(
Sema &S,
const std::string &CalleeName,
14297 if (isa<FieldDecl, FunctionDecl, VarDecl>(D)) {
14299 << CalleeName << 0 << cast<NamedDecl>(D);
14304void CheckFreeArgumentsAddressof(
Sema &S,
const std::string &CalleeName,
14306 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->
getSubExpr())) {
14307 const Decl *D = Lvalue->getDecl();
14308 if (isa<DeclaratorDecl>(D))
14309 if (!dyn_cast<DeclaratorDecl>(D)->getType()->isReferenceType())
14310 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
14313 if (
const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->
getSubExpr()))
14314 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
14315 Lvalue->getMemberDecl());
14318void CheckFreeArgumentsPlus(
Sema &S,
const std::string &CalleeName,
14320 const auto *Lambda = dyn_cast<LambdaExpr>(
14325 S.
Diag(Lambda->getBeginLoc(), diag::warn_free_nonheap_object)
14326 << CalleeName << 2 ;
14329void CheckFreeArgumentsStackArray(
Sema &S,
const std::string &CalleeName,
14331 const auto *Var = dyn_cast<VarDecl>(Lvalue->
getDecl());
14332 if (Var ==
nullptr)
14336 << CalleeName << 0 << Var;
14339void CheckFreeArgumentsCast(
Sema &S,
const std::string &CalleeName,
14342 llvm::raw_svector_ostream OS(SizeString);
14345 if (Kind == clang::CK_BitCast &&
14346 !
Cast->getSubExpr()->getType()->isFunctionPointerType())
14348 if (Kind == clang::CK_IntegralToPointer &&
14349 !isa<IntegerLiteral>(
14350 Cast->getSubExpr()->IgnoreParenImpCasts()->IgnoreParens()))
14353 switch (
Cast->getCastKind()) {
14354 case clang::CK_BitCast:
14355 case clang::CK_IntegralToPointer:
14356 case clang::CK_FunctionToPointerDecay:
14365 S.
Diag(
Cast->getBeginLoc(), diag::warn_free_nonheap_object)
14366 << CalleeName << 0 << OS.str();
14371void Sema::CheckFreeArguments(
const CallExpr *E) {
14372 const std::string CalleeName =
14373 cast<FunctionDecl>(E->
getCalleeDecl())->getQualifiedNameAsString();
14377 if (
const auto *UnaryExpr = dyn_cast<UnaryOperator>(Arg))
14379 case UnaryOperator::Opcode::UO_AddrOf:
14380 return CheckFreeArgumentsAddressof(*
this, CalleeName, UnaryExpr);
14381 case UnaryOperator::Opcode::UO_Plus:
14382 return CheckFreeArgumentsPlus(*
this, CalleeName, UnaryExpr);
14387 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
14389 return CheckFreeArgumentsStackArray(*
this, CalleeName, Lvalue);
14391 if (
const auto *
Label = dyn_cast<AddrLabelExpr>(Arg)) {
14392 Diag(
Label->getBeginLoc(), diag::warn_free_nonheap_object)
14393 << CalleeName << 0 <<
Label->getLabel()->getIdentifier();
14397 if (isa<BlockExpr>(Arg)) {
14399 << CalleeName << 1 ;
14404 if (
const auto *Cast = dyn_cast<CastExpr>(E->
getArg(0)))
14405 return CheckFreeArgumentsCast(*
this, CalleeName, Cast);
14409Sema::CheckReturnValExpr(
Expr *RetValExp,
QualType lhsType,
14415 if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) ||
14418 Diag(ReturnLoc, diag::warn_null_ret)
14428 if (Op == OO_New || Op == OO_Array_New) {
14433 Diag(ReturnLoc, diag::warn_operator_new_returns_null)
14439 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
14445 CheckPPCMMAType(RetValExp->
getType(), ReturnLoc);
14458 auto getCastAndLiteral = [&FPLiteral, &FPCast](
Expr *L,
Expr *R) {
14459 FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
14461 return FPLiteral && FPCast;
14464 if (getCastAndLiteral(LHS, RHS) || getCastAndLiteral(RHS, LHS)) {
14470 llvm::APFloat TargetC = FPLiteral->
getValue();
14472 llvm::APFloat::rmNearestTiesToEven, &Lossy);
14476 Diag(Loc, diag::warn_float_compare_literal)
14477 << (Opcode == BO_EQ) <<
QualType(SourceTy, 0)
14490 if (
auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
14491 if (
auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
14492 if (DRL->getDecl() == DRR->getDecl())
14500 if (
FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
14501 if (FLL->isExact())
14504 if (
FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
14505 if (FLR->isExact())
14509 if (
CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
14510 if (CL->getBuiltinCallee())
14513 if (
CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
14514 if (CR->getBuiltinCallee())
14518 Diag(Loc, diag::warn_floatingpoint_eq)
14539 IntRange(
unsigned Width,
bool NonNegative)
14540 : Width(Width), NonNegative(NonNegative) {}
14543 unsigned valueBits()
const {
14544 return NonNegative ? Width : Width - 1;
14548 static IntRange forBoolType() {
14549 return IntRange(1,
true);
14554 return forValueOfCanonicalType(
C,
14562 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14563 T = VT->getElementType().getTypePtr();
14565 T = CT->getElementType().getTypePtr();
14566 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14567 T = AT->getValueType().getTypePtr();
14569 if (!
C.getLangOpts().CPlusPlus) {
14571 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14572 T = ET->getDecl()->getIntegerType().getDesugaredType(
C).getTypePtr();
14573 }
else if (
const EnumType *ET = dyn_cast<EnumType>(
T)) {
14578 if (
Enum->isFixed()) {
14579 return IntRange(
C.getIntWidth(
QualType(
T, 0)),
14580 !ET->isSignedIntegerOrEnumerationType());
14583 unsigned NumPositive =
Enum->getNumPositiveBits();
14584 unsigned NumNegative =
Enum->getNumNegativeBits();
14586 if (NumNegative == 0)
14587 return IntRange(NumPositive,
true);
14589 return IntRange(std::max(NumPositive + 1, NumNegative),
14593 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14594 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14610 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14611 T = VT->getElementType().getTypePtr();
14613 T = CT->getElementType().getTypePtr();
14614 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14615 T = AT->getValueType().getTypePtr();
14616 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14617 T =
C.getCanonicalType(ET->getDecl()->getIntegerType()).getTypePtr();
14619 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14620 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14629 static IntRange join(IntRange L, IntRange R) {
14630 bool Unsigned = L.NonNegative && R.NonNegative;
14631 return IntRange(std::max(L.valueBits(), R.valueBits()) + !
Unsigned,
14632 L.NonNegative && R.NonNegative);
14636 static IntRange bit_and(IntRange L, IntRange R) {
14637 unsigned Bits = std::max(L.Width, R.Width);
14638 bool NonNegative =
false;
14639 if (L.NonNegative) {
14640 Bits = std::min(Bits, L.Width);
14641 NonNegative =
true;
14643 if (R.NonNegative) {
14644 Bits = std::min(Bits, R.Width);
14645 NonNegative =
true;
14647 return IntRange(Bits, NonNegative);
14651 static IntRange sum(IntRange L, IntRange R) {
14652 bool Unsigned = L.NonNegative && R.NonNegative;
14653 return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !
Unsigned,
14658 static IntRange difference(IntRange L, IntRange R) {
14662 bool CanWiden = !L.NonNegative || !R.NonNegative;
14663 bool Unsigned = L.NonNegative && R.Width == 0;
14664 return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
14670 static IntRange product(IntRange L, IntRange R) {
14674 bool CanWiden = !L.NonNegative && !R.NonNegative;
14675 bool Unsigned = L.NonNegative && R.NonNegative;
14676 return IntRange(L.valueBits() + R.valueBits() + CanWiden + !
Unsigned,
14681 static IntRange rem(IntRange L, IntRange R) {
14685 return IntRange(std::min(L.valueBits(), R.valueBits()) + !
Unsigned,
14693 unsigned MaxWidth) {
14694 if (value.isSigned() && value.isNegative())
14695 return IntRange(value.getSignificantBits(),
false);
14697 if (value.getBitWidth() > MaxWidth)
14698 value = value.trunc(MaxWidth);
14702 return IntRange(value.getActiveBits(),
true);
14706 unsigned MaxWidth) {
14707 if (result.
isInt())
14714 R = IntRange::join(R, El);
14722 return IntRange::join(R, I);
14737 Ty = AtomicRHS->getValueType();
14750 bool InConstantContext,
bool Approximate) {
14761 if (
const auto *CE = dyn_cast<ImplicitCastExpr>(E)) {
14762 if (CE->getCastKind() == CK_NoOp || CE->getCastKind() == CK_LValueToRValue)
14763 return GetExprRange(
C, CE->getSubExpr(), MaxWidth, InConstantContext,
14766 IntRange OutputTypeRange = IntRange::forValueOfType(
C,
GetExprType(CE));
14768 bool isIntegerCast = CE->getCastKind() == CK_IntegralCast ||
14769 CE->getCastKind() == CK_BooleanToSignedIntegral;
14772 if (!isIntegerCast)
14773 return OutputTypeRange;
14776 std::min(MaxWidth, OutputTypeRange.Width),
14777 InConstantContext, Approximate);
14780 if (SubRange.Width >= OutputTypeRange.Width)
14781 return OutputTypeRange;
14785 return IntRange(SubRange.Width,
14786 SubRange.NonNegative || OutputTypeRange.NonNegative);
14789 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
14792 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult,
C))
14794 CondResult ? CO->getTrueExpr() : CO->getFalseExpr(),
14795 MaxWidth, InConstantContext, Approximate);
14800 Expr *E = CO->getTrueExpr();
14802 ? IntRange{0,
true}
14803 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14804 E = CO->getFalseExpr();
14806 ? IntRange{0,
true}
14807 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14808 return IntRange::join(L, R);
14811 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
14812 IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
14814 switch (BO->getOpcode()) {
14816 llvm_unreachable(
"builtin <=> should have class type");
14827 return IntRange::forBoolType();
14845 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14856 Combine = IntRange::bit_and;
14864 = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
14865 if (I->getValue() == 1) {
14866 IntRange R = IntRange::forValueOfType(
C,
GetExprType(E));
14867 return IntRange(R.Width,
true);
14877 case BO_ShrAssign: {
14878 IntRange L =
GetExprRange(
C, BO->getLHS(), MaxWidth, InConstantContext,
14883 if (std::optional<llvm::APSInt> shift =
14884 BO->getRHS()->getIntegerConstantExpr(
C)) {
14885 if (shift->isNonNegative()) {
14886 if (shift->uge(L.Width))
14887 L.Width = (L.NonNegative ? 0 : 1);
14889 L.Width -= shift->getZExtValue();
14898 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14903 Combine = IntRange::sum;
14907 if (BO->getLHS()->getType()->isPointerType())
14910 Combine = IntRange::difference;
14915 Combine = IntRange::product;
14923 IntRange L =
GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext,
14927 if (std::optional<llvm::APSInt> divisor =
14928 BO->getRHS()->getIntegerConstantExpr(
C)) {
14929 unsigned log2 = divisor->logBase2();
14930 if (
log2 >= L.Width)
14931 L.Width = (L.NonNegative ? 0 : 1);
14933 L.Width = std::min(L.Width -
log2, MaxWidth);
14940 IntRange R =
GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext,
14942 return IntRange(L.Width, L.NonNegative && R.NonNegative);
14946 Combine = IntRange::rem;
14958 unsigned opWidth =
C.getIntWidth(
T);
14960 GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext, Approximate);
14962 GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext, Approximate);
14963 IntRange
C = Combine(L, R);
14965 C.Width = std::min(
C.Width, MaxWidth);
14969 if (
const auto *UO = dyn_cast<UnaryOperator>(E)) {
14970 switch (UO->getOpcode()) {
14973 return IntRange::forBoolType();
14981 return GetExprRange(
C, UO->getSubExpr(), MaxWidth, InConstantContext,
14986 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
14987 return GetExprRange(
C, OVE->getSourceExpr(), MaxWidth, InConstantContext,
14991 return IntRange(BitField->getBitWidthValue(
C),
14992 BitField->getType()->isUnsignedIntegerOrEnumerationType());
14998 bool InConstantContext,
bool Approximate) {
15007 const llvm::fltSemantics &Src,
15008 const llvm::fltSemantics &Tgt) {
15009 llvm::APFloat truncated = value;
15012 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
15013 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
15015 return truncated.bitwiseIsEqual(value);
15024 const llvm::fltSemantics &Src,
15025 const llvm::fltSemantics &Tgt) {
15042 bool IsListInit =
false);
15048 if (isa<EnumConstantDecl>(DR->getDecl()))
15058 return MacroName !=
"YES" && MacroName !=
"NO" &&
15059 MacroName !=
"true" && MacroName !=
"false";
15082struct PromotedRange {
15084 llvm::APSInt PromotedMin;
15086 llvm::APSInt PromotedMax;
15088 PromotedRange(IntRange R,
unsigned BitWidth,
bool Unsigned) {
15090 PromotedMin = PromotedMax = llvm::APSInt(BitWidth,
Unsigned);
15091 else if (R.Width >= BitWidth && !
Unsigned) {
15095 PromotedMin = llvm::APSInt::getMinValue(BitWidth,
Unsigned);
15096 PromotedMax = llvm::APSInt::getMaxValue(BitWidth,
Unsigned);
15098 PromotedMin = llvm::APSInt::getMinValue(R.Width, R.NonNegative)
15099 .extOrTrunc(BitWidth);
15100 PromotedMin.setIsUnsigned(
Unsigned);
15102 PromotedMax = llvm::APSInt::getMaxValue(R.Width, R.NonNegative)
15103 .extOrTrunc(BitWidth);
15104 PromotedMax.setIsUnsigned(
Unsigned);
15109 bool isContiguous()
const {
return PromotedMin <= PromotedMax; }
15119 InRangeFlag = 0x40,
15122 Min =
LE | InRangeFlag,
15124 Max =
GE | InRangeFlag,
15127 OnlyValue =
LE |
GE |
EQ | InRangeFlag,
15132 assert(
Value.getBitWidth() == PromotedMin.getBitWidth() &&
15133 Value.isUnsigned() == PromotedMin.isUnsigned());
15134 if (!isContiguous()) {
15135 assert(
Value.isUnsigned() &&
"discontiguous range for signed compare");
15136 if (
Value.isMinValue())
return Min;
15137 if (
Value.isMaxValue())
return Max;
15143 switch (llvm::APSInt::compareValues(
Value, PromotedMin)) {
15144 case -1:
return Less;
15145 case 0:
return PromotedMin == PromotedMax ? OnlyValue :
Min;
15147 switch (llvm::APSInt::compareValues(
Value, PromotedMax)) {
15149 case 0:
return Max;
15154 llvm_unreachable(
"impossible compare result");
15157 static std::optional<StringRef>
15159 if (Op == BO_Cmp) {
15161 if (ConstantOnRHS) std::swap(LTFlag, GTFlag);
15163 if (R & EQ)
return StringRef(
"'std::strong_ordering::equal'");
15164 if (R & LTFlag)
return StringRef(
"'std::strong_ordering::less'");
15165 if (R & GTFlag)
return StringRef(
"'std::strong_ordering::greater'");
15166 return std::nullopt;
15173 }
else if (Op == BO_NE) {
15177 if ((Op == BO_LT || Op == BO_GE) ^ ConstantOnRHS) {
15184 if (Op == BO_GE || Op == BO_LE)
15185 std::swap(TrueFlag, FalseFlag);
15188 return StringRef(
"true");
15190 return StringRef(
"false");
15191 return std::nullopt;
15199 if (ICE->getCastKind() != CK_IntegralCast &&
15200 ICE->getCastKind() != CK_NoOp)
15202 E = ICE->getSubExpr();
15211 enum ConstantValueKind {
15216 if (
auto *BL = dyn_cast<CXXBoolLiteralExpr>(Constant))
15217 return BL->getValue() ? ConstantValueKind::LiteralTrue
15218 : ConstantValueKind::LiteralFalse;
15219 return ConstantValueKind::Miscellaneous;
15224 const llvm::APSInt &
Value,
15225 bool RhsConstant) {
15250 OtherT = AT->getValueType();
15251 IntRange OtherTypeRange = IntRange::forValueOfType(S.
Context, OtherT);
15255 bool IsObjCSignedCharBool = S.
getLangOpts().ObjC &&
15256 S.
NSAPIObj->isObjCBOOLType(OtherT) &&
15261 bool OtherIsBooleanDespiteType =
15263 if (OtherIsBooleanDespiteType || IsObjCSignedCharBool)
15264 OtherTypeRange = OtherValueRange = IntRange::forBoolType();
15268 PromotedRange OtherPromotedValueRange(OtherValueRange,
Value.getBitWidth(),
15269 Value.isUnsigned());
15270 auto Cmp = OtherPromotedValueRange.compare(
Value);
15271 auto Result = PromotedRange::constantValue(E->
getOpcode(), Cmp, RhsConstant);
15277 bool TautologicalTypeCompare =
false;
15279 PromotedRange OtherPromotedTypeRange(OtherTypeRange,
Value.getBitWidth(),
15280 Value.isUnsigned());
15281 auto TypeCmp = OtherPromotedTypeRange.compare(
Value);
15284 TautologicalTypeCompare =
true;
15292 if (!TautologicalTypeCompare && OtherValueRange.Width == 0)
15301 bool InRange = Cmp & PromotedRange::InRangeFlag;
15307 if (
Other->refersToBitField() && InRange &&
Value == 0 &&
15308 Other->getType()->isUnsignedIntegerOrEnumerationType())
15309 TautologicalTypeCompare =
true;
15314 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
15315 ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
15319 llvm::raw_svector_ostream OS(PrettySourceValue);
15321 OS <<
'\'' << *ED <<
"' (" <<
Value <<
")";
15322 }
else if (
auto *BL = dyn_cast<ObjCBoolLiteralExpr>(
15324 OS << (BL->getValue() ?
"YES" :
"NO");
15329 if (!TautologicalTypeCompare) {
15331 << RhsConstant << OtherValueRange.Width << OtherValueRange.NonNegative
15337 if (IsObjCSignedCharBool) {
15339 S.
PDiag(diag::warn_tautological_compare_objc_bool)
15340 << OS.str() << *
Result);
15347 if (!InRange ||
Other->isKnownToHaveBooleanValue()) {
15351 S.
PDiag(!InRange ? diag::warn_out_of_range_compare
15352 : diag::warn_tautological_bool_compare)
15354 << OtherIsBooleanDespiteType << *
Result
15361 ? diag::warn_unsigned_enum_always_true_comparison
15362 : IsCharTy ? diag::warn_unsigned_char_always_true_comparison
15363 : diag::warn_unsigned_always_true_comparison)
15364 : diag::warn_tautological_constant_compare;
15401 std::optional<llvm::APSInt> RHSValue =
15403 std::optional<llvm::APSInt> LHSValue =
15407 if (RHSValue && LHSValue)
15411 if ((
bool)RHSValue ^ (
bool)LHSValue) {
15413 const bool RhsConstant = (
bool)RHSValue;
15414 Expr *Const = RhsConstant ? RHS : LHS;
15416 const llvm::APSInt &
Value = RhsConstant ? *RHSValue : *LHSValue;
15439 if (
const auto *TET = dyn_cast<TypeOfExprType>(LHS->
getType()))
15441 if (
const auto *TET = dyn_cast<TypeOfExprType>(RHS->
getType()))
15447 Expr *signedOperand, *unsignedOperand;
15450 "unsigned comparison between two signed integer expressions?");
15451 signedOperand = LHS;
15452 unsignedOperand = RHS;
15454 signedOperand = RHS;
15455 unsignedOperand = LHS;
15461 IntRange signedRange =
15471 if (signedRange.NonNegative)
15480 IntRange unsignedRange =
15486 assert(unsignedRange.NonNegative &&
"unsigned range includes negative?");
15488 if (unsignedRange.Width < comparisonWidth)
15493 S.
PDiag(diag::warn_mixed_sign_comparison)
15521 S.
Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield)
15522 << BitfieldEnumDecl;
15529 Init->isValueDependent() ||
15530 Init->isTypeDependent())
15533 Expr *OriginalInit =
Init->IgnoreParenImpCasts();
15556 unsigned DiagID = 0;
15557 if (SignedEnum && !SignedBitfield) {
15558 DiagID = diag::warn_unsigned_bitfield_assigned_signed_enum;
15559 }
else if (SignedBitfield && !SignedEnum &&
15561 DiagID = diag::warn_signed_bitfield_enum_conversion;
15565 S.
Diag(InitLoc, DiagID) << Bitfield << ED;
15570 << SignedEnum << TypeRange;
15581 if (BitsNeeded > FieldWidth) {
15583 S.
Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
15595 unsigned OriginalWidth =
Value.getBitWidth();
15601 bool OneAssignedToOneBitBitfield = FieldWidth == 1 &&
Value == 1;
15602 if (OneAssignedToOneBitBitfield && !S.
LangOpts.CPlusPlus) {
15609 if (!
Value.isSigned() ||
Value.isNegative())
15610 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(OriginalInit))
15611 if (UO->getOpcode() == UO_Minus || UO->getOpcode() == UO_Not)
15612 OriginalWidth =
Value.getSignificantBits();
15614 if (OriginalWidth <= FieldWidth)
15618 llvm::APSInt TruncatedValue =
Value.trunc(FieldWidth);
15622 TruncatedValue = TruncatedValue.extend(OriginalWidth);
15623 if (llvm::APSInt::isSameValue(
Value, TruncatedValue))
15627 std::string PrettyTrunc =
toString(TruncatedValue, 10);
15629 S.
Diag(InitLoc, OneAssignedToOneBitBitfield
15630 ? diag::warn_impcast_single_bit_bitield_precision_constant
15631 : diag::warn_impcast_bitfield_precision_constant)
15632 << PrettyValue << PrettyTrunc << OriginalInit->
getType()
15633 <<
Init->getSourceRange();
15665 bool pruneControlFlow =
false) {
15666 if (pruneControlFlow) {
15680 unsigned diag,
bool pruneControlFlow =
false) {
15692 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
15693 Ignored = OVE->getSourceExpr();
15694 bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
15695 isa<BinaryOperator>(Ignored) ||
15696 isa<CXXOperatorCallExpr>(Ignored);
15713 if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
15716 const bool IsLiteral =
15717 isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
15719 llvm::APFloat
Value(0.0);
15726 S.
Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
15731 diag::warn_impcast_float_integer, PruneWarnings);
15734 bool isExact =
false;
15738 llvm::APFloat::opStatus
Result =
Value.convertToInteger(
15739 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
15747 unsigned precision = llvm::APFloat::semanticsPrecision(
Value.getSemantics());
15748 precision = (precision * 59 + 195) / 196;
15749 Value.toString(PrettySourceValue, precision);
15754 S.
Diag(CContext, diag::warn_impcast_constant_value_to_objc_bool)
15755 << PrettySourceValue);
15758 if (
Result == llvm::APFloat::opOK && isExact) {
15759 if (IsLiteral)
return;
15760 return DiagnoseImpCast(S, E,
T, CContext, diag::warn_impcast_float_integer,
15766 if (!IsBool &&
Result == llvm::APFloat::opInvalidOp)
15769 IsLiteral ? diag::warn_impcast_literal_float_to_integer_out_of_range
15770 : diag::warn_impcast_float_to_integer_out_of_range,
15773 unsigned DiagID = 0;
15776 DiagID = diag::warn_impcast_literal_float_to_integer;
15777 }
else if (IntegerValue == 0) {
15778 if (
Value.isZero()) {
15780 diag::warn_impcast_float_integer, PruneWarnings);
15783 DiagID = diag::warn_impcast_float_to_integer_zero;
15785 if (IntegerValue.isUnsigned()) {
15786 if (!IntegerValue.isMaxValue()) {
15788 diag::warn_impcast_float_integer, PruneWarnings);
15791 if (!IntegerValue.isMaxSignedValue() &&
15792 !IntegerValue.isMinSignedValue()) {
15794 diag::warn_impcast_float_integer, PruneWarnings);
15798 DiagID = diag::warn_impcast_float_to_integer;
15803 PrettyTargetValue =
Value.isZero() ?
"false" :
"true";
15805 IntegerValue.toString(PrettyTargetValue);
15807 if (PruneWarnings) {
15810 << E->
getType() <<
T.getUnqualifiedType()
15811 << PrettySourceValue << PrettyTargetValue
15815 << E->
getType() <<
T.getUnqualifiedType() << PrettySourceValue
15823 assert(isa<CompoundAssignOperator>(E) &&
15824 "Must be compound assignment operation");
15834 const auto *RBT = cast<CompoundAssignOperator>(E)
15835 ->getComputationResultType()
15842 if (ResultBT->isInteger())
15844 E->
getExprLoc(), diag::warn_impcast_float_integer);
15846 if (!ResultBT->isFloatingPoint())
15855 diag::warn_impcast_float_result_precision);
15860 if (!Range.Width)
return "0";
15862 llvm::APSInt ValueInRange =
Value;
15863 ValueInRange.setIsSigned(!Range.NonNegative);
15864 ValueInRange = ValueInRange.trunc(Range.Width);
15865 return toString(ValueInRange, 10);
15869 if (!isa<ImplicitCastExpr>(Ex))
15874 const Type *Source =
15876 if (
Target->isDependentType())
15880 dyn_cast<BuiltinType>(ToBool ? Source :
Target);
15881 const Type *BoolCandidateType = ToBool ?
Target : Source;
15890 for (
unsigned i = 0; i < NumArgs; ++i) {
15895 bool IsSwapped = ((i > 0) &&
15897 IsSwapped |= ((i < (NumArgs - 1)) &&
15903 diag::warn_impcast_floating_point_to_bool);
15910 if (S.
Diags.
isIgnored(diag::warn_impcast_null_pointer_to_integer,
15915 if (isa<CallExpr>(E))
15920 bool IsGNUNullExpr = isa<GNUNullExpr>(NewE);
15922 if (!IsGNUNullExpr && !HasNullPtrType)
15939 if (IsGNUNullExpr && Loc.
isMacroID()) {
15942 if (MacroName ==
"NULL")
15950 S.
Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
15968 unsigned ElementKind) {
15970 if (
auto ICE = dyn_cast<ImplicitCastExpr>(Element)) {
15971 if (ICE->getCastKind() == CK_BitCast &&
15973 Element = ICE->getSubExpr();
15976 QualType ElementType = Element->getType();
15983 S.
Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element)
15984 << ElementType << ElementKind << TargetElementType
15985 << Element->getSourceRange();
15988 if (
auto ArrayLiteral = dyn_cast<ObjCArrayLiteral>(Element))
15990 else if (
auto DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(Element))
16002 if (!TargetObjCPtr)
16005 if (TargetObjCPtr->isUnspecialized() ||
16006 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
16011 if (TypeArgs.size() != 1)
16014 QualType TargetElementType = TypeArgs[0];
16015 for (
unsigned I = 0, N = ArrayLiteral->
getNumElements(); I != N; ++I) {
16031 if (!TargetObjCPtr)
16034 if (TargetObjCPtr->isUnspecialized() ||
16035 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
16040 if (TypeArgs.size() != 2)
16043 QualType TargetKeyType = TypeArgs[0];
16044 QualType TargetObjectType = TypeArgs[1];
16045 for (
unsigned I = 0, N = DictionaryLiteral->
getNumElements(); I != N; ++I) {
16060 const char FirstLiteralCharacter =
16062 if (FirstLiteralCharacter ==
'0')
16069 const char FirstContextCharacter =
16071 if (FirstContextCharacter ==
'{')
16079 const auto *IL = dyn_cast<IntegerLiteral>(E);
16081 if (
auto *UO = dyn_cast<UnaryOperator>(E)) {
16082 if (UO->getOpcode() == UO_Minus)
16083 return dyn_cast<IntegerLiteral>(UO->getSubExpr());
16094 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
16098 if (Opc == BO_Shl) {
16101 if (LHS && LHS->getValue() == 0)
16102 S.
Diag(ExprLoc, diag::warn_left_shift_always) << 0;
16104 RHS->getValue().isNonNegative() &&
16106 S.
Diag(ExprLoc, diag::warn_left_shift_always)
16107 << (
Result.Val.getInt() != 0);
16109 S.
Diag(ExprLoc, diag::warn_left_shift_in_bool_context) << E;
16113 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
16118 if ((LHS->getValue() == 0 || LHS->getValue() == 1) &&
16119 (RHS->getValue() == 0 || RHS->getValue() == 1))
16122 if (LHS->getValue() != 0 && RHS->getValue() != 0)
16123 S.
Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
16129 bool *ICContext =
nullptr,
16130 bool IsListInit =
false) {
16135 if (Source ==
Target)
return;
16136 if (
Target->isDependentType())
return;
16150 if (
Target->isSpecificBuiltinType(BuiltinType::Bool)) {
16151 if (isa<StringLiteral>(E))
16156 diag::warn_impcast_string_literal_to_bool);
16157 if (isa<ObjCStringLiteral>(E) || isa<ObjCArrayLiteral>(E) ||
16158 isa<ObjCDictionaryLiteral>(E) || isa<ObjCBoxedExpr>(E)) {
16162 diag::warn_impcast_objective_c_literal_to_bool);
16178 if (
Result.Val.getInt() != 1 &&
Result.Val.getInt() != 0) {
16181 S.
Diag(CC, diag::warn_impcast_constant_value_to_objc_bool)
16190 if (
auto *ArrayLiteral = dyn_cast<ObjCArrayLiteral>(E))
16192 else if (
auto *DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(E))
16196 if (isa<VectorType>(Source)) {
16197 if (
Target->isSveVLSBuiltinType() &&
16204 if (
Target->isRVVVLSBuiltinType() &&
16211 if (!isa<VectorType>(
Target)) {
16229 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
16230 Target = cast<VectorType>(
Target)->getElementType().getTypePtr();
16232 if (
auto VecTy = dyn_cast<VectorType>(
Target))
16233 Target = VecTy->getElementType().getTypePtr();
16236 if (isa<ComplexType>(Source)) {
16237 if (!isa<ComplexType>(
Target)) {
16243 ? diag::err_impcast_complex_scalar
16244 : diag::warn_impcast_complex_scalar);
16247 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
16248 Target = cast<ComplexType>(
Target)->getElementType().getTypePtr();
16251 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
16303 else if (Order < 0) {
16313 if (TargetBT && TargetBT->
isInteger()) {
16328 if (
Target->isBooleanType() && isa<CallExpr>(E)) {
16332 CallExpr *CEx = cast<CallExpr>(E);
16336 if (isa<ImplicitCastExpr>(LastA) &&
16340 diag::warn_impcast_floating_point_to_bool);
16349 if (
Target->isUnsaturatedFixedPointType()) {
16353 llvm::APFixedPoint
Value =
Result.Val.getFixedPoint();
16358 S.
PDiag(diag::warn_impcast_fixed_point_range)
16359 <<
Value.toString() <<
T
16365 }
else if (
Target->isIntegerType()) {
16370 llvm::APFixedPoint FXResult =
Result.Val.getFixedPoint();
16373 llvm::APSInt IntResult = FXResult.convertToInt(
16375 Target->isSignedIntegerOrEnumerationType(), &Overflowed);
16379 S.
PDiag(diag::warn_impcast_fixed_point_range)
16380 << FXResult.toString() <<
T
16387 }
else if (
Target->isUnsaturatedFixedPointType()) {
16395 llvm::APFixedPoint IntResult = llvm::APFixedPoint::getFromIntValue(
16400 S.
PDiag(diag::warn_impcast_fixed_point_range)
16419 unsigned int SourcePrecision =
SourceRange.Width;
16423 unsigned int TargetPrecision = llvm::APFloatBase::semanticsPrecision(
16426 if (SourcePrecision > 0 && TargetPrecision > 0 &&
16427 SourcePrecision > TargetPrecision) {
16429 if (std::optional<llvm::APSInt> SourceInt =
16434 llvm::APFloat TargetFloatValue(
16436 llvm::APFloat::opStatus ConversionStatus =
16437 TargetFloatValue.convertFromAPInt(
16439 llvm::APFloat::rmNearestTiesToEven);
16441 if (ConversionStatus != llvm::APFloat::opOK) {
16443 SourceInt->toString(PrettySourceValue, 10);
16445 TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
16449 S.
PDiag(diag::warn_impcast_integer_float_precision_constant)
16450 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16456 diag::warn_impcast_integer_float_precision);
16465 if (
Target->isBooleanType())
16473 if (
Target->isSpecificBuiltinType(BuiltinType::Bool))
16480 S.
Diag(CC, diag::warn_impcast_int_to_objc_signed_char_bool)
16484 IntRange SourceTypeRange =
16485 IntRange::forTargetOfCanonicalType(S.
Context, Source);
16488 IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.
Context,
Target);
16490 if (LikelySourceRange.Width > TargetRange.Width) {
16496 llvm::APSInt
Value(32);
16507 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16508 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16520 return DiagnoseImpCast(S, E,
T, CC, diag::warn_impcast_integer_precision);
16523 if (TargetRange.Width > SourceTypeRange.Width) {
16524 if (
auto *UO = dyn_cast<UnaryOperator>(E))
16525 if (UO->getOpcode() == UO_Minus)
16527 if (
Target->isUnsignedIntegerType())
16529 diag::warn_impcast_high_order_zero_bits);
16530 if (
Target->isSignedIntegerType())
16532 diag::warn_impcast_nonnegative_result);
16536 if (TargetRange.Width == LikelySourceRange.Width &&
16537 !TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16553 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16554 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16563 if ((!isa<EnumType>(
Target) || !isa<EnumType>(Source)) &&
16564 ((TargetRange.NonNegative && !LikelySourceRange.NonNegative) ||
16565 (!TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16566 LikelySourceRange.Width == TargetRange.Width))) {
16570 if (SourceBT && SourceBT->
isInteger() && TargetBT &&
16576 unsigned DiagID = diag::warn_impcast_integer_sign;
16584 DiagID = diag::warn_impcast_integer_sign_conditional;
16599 if (SourceEnum->getDecl()->hasNameForLinkage() &&
16600 TargetEnum->getDecl()->hasNameForLinkage() &&
16601 SourceEnum != TargetEnum) {
16606 diag::warn_impcast_different_enum_types);
16620 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(E))
16633 if (
auto *BCO = dyn_cast<BinaryConditionalOperator>(E))
16634 TrueExpr = BCO->getCommon();
16636 bool Suspicious =
false;
16645 if (!Suspicious)
return;
16648 if (!S.
Diags.
isIgnored(diag::warn_impcast_integer_sign_conditional, CC))
16655 Suspicious =
false;
16657 E->
getType(), CC, &Suspicious);
16660 E->
getType(), CC, &Suspicious);
16677struct AnalyzeImplicitConversionsWorkItem {
16687 Sema &S, AnalyzeImplicitConversionsWorkItem Item,
16689 Expr *OrigE = Item.E;
16698 bool IsListInit = Item.IsListInit ||
16699 (isa<InitListExpr>(OrigE) && S.
getLangOpts().CPlusPlus);
16704 Expr *SourceExpr = E;
16709 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(E))
16710 if (
auto *Src = OVE->getSourceExpr())
16713 if (
const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
16714 if (UO->getOpcode() == UO_Not &&
16715 UO->getSubExpr()->isKnownToHaveBooleanValue())
16716 S.
Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
16720 if (
const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
16721 if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
16722 BO->getLHS()->isKnownToHaveBooleanValue() &&
16723 BO->getRHS()->isKnownToHaveBooleanValue() &&
16724 BO->getLHS()->HasSideEffects(S.
Context) &&
16725 BO->getRHS()->HasSideEffects(S.
Context)) {
16736 if (SR.str() ==
"&" || SR.str() ==
"|") {
16738 S.
Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical)
16739 << (BO->getOpcode() == BO_And ?
"&" :
"|")
16742 BO->getOperatorLoc(),
16743 (BO->getOpcode() == BO_And ?
"&&" :
"||"));
16744 S.
Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
16750 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(SourceExpr)) {
16771 for (
auto *SE : POE->semantics())
16772 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(SE))
16773 WorkList.push_back({OVE->getSourceExpr(), CC, IsListInit});
16777 if (
auto *CE = dyn_cast<ExplicitCastExpr>(E)) {
16781 WorkList.push_back({E, CC, IsListInit});
16787 if (BO->isComparisonOp())
16791 if (BO->getOpcode() == BO_Assign)
16794 if (BO->isAssignmentOp())
16802 if (isa<StmtExpr>(E))
return;
16805 if (isa<UnaryExprOrTypeTraitExpr>(E))
return;
16810 bool IsLogicalAndOperator = BO && BO->
getOpcode() == BO_LAnd;
16812 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
16816 if (
auto *CSE = dyn_cast<CoroutineSuspendExpr>(E))
16817 if (ChildExpr == CSE->getOperand())
16823 if (IsLogicalAndOperator &&
16828 WorkList.push_back({ChildExpr, CC, IsListInit});
16833 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16837 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16842 if (
U->getOpcode() == UO_LNot) {
16844 }
else if (
U->getOpcode() != UO_AddrOf) {
16845 if (
U->getSubExpr()->getType()->isAtomicType())
16846 S.
Diag(
U->getSubExpr()->getBeginLoc(),
16847 diag::warn_atomic_implicit_seq_cst);
16858 WorkList.push_back({OrigE, CC, IsListInit});
16859 while (!WorkList.empty())
16869 diag::err_opencl_enqueue_kernel_invalid_local_size_type);
16886 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
16889 }
else if (
const MemberExpr *M = dyn_cast<MemberExpr>(E)) {
16890 if (!M->getMemberDecl()->getType()->isReferenceType())
16892 }
else if (
const CallExpr *
Call = dyn_cast<CallExpr>(E)) {
16893 if (!
Call->getCallReturnType(SemaRef.
Context)->isReferenceType())
16895 FD =
Call->getDirectCallee();
16904 SemaRef.
Diag(FD->
getLocation(), diag::note_reference_is_return_value) << FD;
16918 if (
SM.isMacroBodyExpansion(Loc))
16920 Loc =
SM.getImmediateMacroCallerLoc(Loc);
16949 if (isa<CXXThisExpr>(E)) {
16950 unsigned DiagID = IsCompare ? diag::warn_this_null_compare
16951 : diag::warn_this_bool_conversion;
16956 bool IsAddressOf =
false;
16958 if (
auto *UO = dyn_cast<UnaryOperator>(E->
IgnoreParens())) {
16959 if (UO->getOpcode() != UO_AddrOf)
16961 IsAddressOf =
true;
16962 E = UO->getSubExpr();
16966 unsigned DiagID = IsCompare
16967 ? diag::warn_address_of_reference_null_compare
16968 : diag::warn_address_of_reference_bool_conversion;
16976 auto ComplainAboutNonnullParamOrCall = [&](
const Attr *NonnullAttr) {
16977 bool IsParam = isa<NonNullAttr>(NonnullAttr);
16979 llvm::raw_string_ostream S(Str);
16981 unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare
16982 : diag::warn_cast_nonnull_to_bool;
16985 Diag(NonnullAttr->getLocation(), diag::note_declared_nonnull) << IsParam;
16990 if (
auto *Callee =
Call->getDirectCallee()) {
16991 if (
const Attr *A = Callee->getAttr<ReturnsNonNullAttr>()) {
16992 ComplainAboutNonnullParamOrCall(A);
17001 if (
const auto *MCallExpr = dyn_cast<CXXMemberCallExpr>(E)) {
17002 if (
const auto *MRecordDecl = MCallExpr->getRecordDecl();
17003 MRecordDecl && MRecordDecl->isLambda()) {
17006 << MRecordDecl->getSourceRange() << Range << IsEqual;
17016 }
else if (
MemberExpr *M = dyn_cast<MemberExpr>(E)) {
17017 D = M->getMemberDecl();
17025 if (
const auto* PV = dyn_cast<ParmVarDecl>(D)) {
17028 if (
const Attr *A = PV->getAttr<NonNullAttr>()) {
17029 ComplainAboutNonnullParamOrCall(A);
17033 if (
const auto *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
17037 auto ParamIter = llvm::find(FD->
parameters(), PV);
17039 unsigned ParamNo = std::distance(FD->
param_begin(), ParamIter);
17043 ComplainAboutNonnullParamOrCall(
NonNull);
17048 if (ArgNo.getASTIndex() == ParamNo) {
17049 ComplainAboutNonnullParamOrCall(
NonNull);
17063 if (IsAddressOf && IsFunction) {
17068 if (!IsAddressOf && !IsFunction && !IsArray)
17073 llvm::raw_string_ostream S(Str);
17076 unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare
17077 : diag::warn_impcast_pointer_to_bool;
17084 DiagType = AddressOf;
17085 else if (IsFunction)
17086 DiagType = FunctionPointer;
17088 DiagType = ArrayPointer;
17090 llvm_unreachable(
"Could not determine diagnostic.");
17092 << Range << IsEqual;
17105 if (ReturnType.
isNull())
17150 CheckArrayAccess(E);
17159 ::CheckBoolLikeConversion(*
this, E, CC);
17164void Sema::CheckForIntOverflow (
const Expr *E) {
17169 const Expr *OriginalE = Exprs.pop_back_val();
17172 if (isa<BinaryOperator, UnaryOperator>(E)) {
17177 if (
const auto *InitList = dyn_cast<InitListExpr>(OriginalE))
17178 Exprs.append(InitList->inits().begin(), InitList->inits().end());
17179 else if (isa<ObjCBoxedExpr>(OriginalE))
17181 else if (
const auto *
Call = dyn_cast<CallExpr>(E))
17182 Exprs.append(
Call->arg_begin(),
Call->arg_end());
17183 else if (
const auto *Message = dyn_cast<ObjCMessageExpr>(E))
17184 Exprs.append(Message->arg_begin(), Message->arg_end());
17185 else if (
const auto *Construct = dyn_cast<CXXConstructExpr>(E))
17186 Exprs.append(Construct->arg_begin(), Construct->arg_end());
17187 else if (
const auto *Temporary = dyn_cast<CXXBindTemporaryExpr>(E))
17188 Exprs.push_back(Temporary->getSubExpr());
17189 else if (
const auto *Array = dyn_cast<ArraySubscriptExpr>(E))
17190 Exprs.push_back(Array->getIdx());
17191 else if (
const auto *Compound = dyn_cast<CompoundLiteralExpr>(E))
17192 Exprs.push_back(Compound->getInitializer());
17193 else if (
const auto *New = dyn_cast<CXXNewExpr>(E);
17194 New && New->isArray()) {
17195 if (
auto ArraySize = New->getArraySize())
17196 Exprs.push_back(*ArraySize);
17198 }
while (!Exprs.empty());
17213 class SequenceTree {
17217 LLVM_PREFERRED_TYPE(
bool)
17218 unsigned Merged : 1;
17226 friend class SequenceTree;
17230 explicit Seq(
unsigned N) : Index(N) {}
17233 Seq() : Index(0) {}
17236 SequenceTree() { Values.push_back(
Value(0)); }
17237 Seq root()
const {
return Seq(0); }
17244 return Seq(Values.size() - 1);
17248 void merge(
Seq S) {
17249 Values[S.Index].Merged =
true;
17255 bool isUnsequenced(
Seq Cur,
Seq Old) {
17256 unsigned C = representative(Cur.Index);
17257 unsigned Target = representative(Old.Index);
17261 C = Values[
C].Parent;
17268 unsigned representative(
unsigned K) {
17269 if (Values[K].Merged)
17271 return Values[K].Parent = representative(Values[K].
Parent);
17291 UK_ModAsSideEffect,
17293 UK_Count = UK_ModAsSideEffect + 1
17299 const Expr *UsageExpr =
nullptr;
17300 SequenceTree::Seq
Seq;
17306 Usage Uses[UK_Count];
17309 bool Diagnosed =
false;
17313 using UsageInfoMap = llvm::SmallDenseMap<Object, UsageInfo, 16>;
17321 UsageInfoMap UsageMap;
17324 SequenceTree::Seq Region;
17339 struct SequencedSubexpression {
17340 SequencedSubexpression(SequenceChecker &Self)
17341 : Self(Self), OldModAsSideEffect(Self.ModAsSideEffect) {
17342 Self.ModAsSideEffect = &ModAsSideEffect;
17345 ~SequencedSubexpression() {
17346 for (
const std::pair<Object, Usage> &M : llvm::reverse(ModAsSideEffect)) {
17350 UsageInfo &UI = Self.UsageMap[M.first];
17351 auto &SideEffectUsage = UI.Uses[UK_ModAsSideEffect];
17352 Self.addUsage(M.first, UI, SideEffectUsage.UsageExpr, UK_ModAsValue);
17353 SideEffectUsage = M.second;
17355 Self.ModAsSideEffect = OldModAsSideEffect;
17358 SequenceChecker &Self;
17367 class EvaluationTracker {
17369 EvaluationTracker(SequenceChecker &Self)
17370 : Self(Self), Prev(Self.EvalTracker) {
17371 Self.EvalTracker =
this;
17374 ~EvaluationTracker() {
17375 Self.EvalTracker = Prev;
17377 Prev->EvalOK &= EvalOK;
17380 bool evaluate(
const Expr *E,
bool &Result) {
17384 Result, Self.SemaRef.Context,
17385 Self.SemaRef.isConstantEvaluatedContext());
17390 SequenceChecker &Self;
17391 EvaluationTracker *Prev;
17392 bool EvalOK =
true;
17393 } *EvalTracker =
nullptr;
17397 Object getObject(
const Expr *E,
bool Mod)
const {
17399 if (
const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
17400 if (Mod && (UO->getOpcode() == UO_PreInc || UO->getOpcode() == UO_PreDec))
17401 return getObject(UO->getSubExpr(), Mod);
17402 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
17403 if (BO->getOpcode() == BO_Comma)
17404 return getObject(BO->getRHS(), Mod);
17405 if (Mod && BO->isAssignmentOp())
17406 return getObject(BO->getLHS(), Mod);
17407 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
17409 if (isa<CXXThisExpr>(ME->getBase()->IgnoreParenCasts()))
17410 return ME->getMemberDecl();
17411 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
17420 void addUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr, UsageKind UK) {
17422 Usage &
U = UI.Uses[UK];
17423 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq)) {
17427 if (UK == UK_ModAsSideEffect && ModAsSideEffect)
17428 ModAsSideEffect->push_back(std::make_pair(O,
U));
17430 U.UsageExpr = UsageExpr;
17440 void checkUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr,
17441 UsageKind OtherKind,
bool IsModMod) {
17445 const Usage &
U = UI.Uses[OtherKind];
17446 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq))
17449 const Expr *Mod =
U.UsageExpr;
17450 const Expr *ModOrUse = UsageExpr;
17451 if (OtherKind == UK_Use)
17452 std::swap(Mod, ModOrUse);
17456 SemaRef.
PDiag(IsModMod ? diag::warn_unsequenced_mod_mod
17457 : diag::warn_unsequenced_mod_use)
17459 UI.Diagnosed =
true;
17488 void notePreUse(Object O,
const Expr *UseExpr) {
17489 UsageInfo &UI = UsageMap[O];
17491 checkUsage(O, UI, UseExpr, UK_ModAsValue,
false);
17494 void notePostUse(Object O,
const Expr *UseExpr) {
17495 UsageInfo &UI = UsageMap[O];
17496 checkUsage(O, UI, UseExpr, UK_ModAsSideEffect,
17498 addUsage(O, UI, UseExpr, UK_Use);
17501 void notePreMod(Object O,
const Expr *ModExpr) {
17502 UsageInfo &UI = UsageMap[O];
17504 checkUsage(O, UI, ModExpr, UK_ModAsValue,
true);
17505 checkUsage(O, UI, ModExpr, UK_Use,
false);
17508 void notePostMod(Object O,
const Expr *ModExpr, UsageKind UK) {
17509 UsageInfo &UI = UsageMap[O];
17510 checkUsage(O, UI, ModExpr, UK_ModAsSideEffect,
17512 addUsage(O, UI, ModExpr, UK);
17516 SequenceChecker(
Sema &S,
const Expr *E,
17518 :
Base(S.Context), SemaRef(S), Region(
Tree.root()), WorkList(WorkList) {
17522 (void)this->WorkList;
17525 void VisitStmt(
const Stmt *S) {
17529 void VisitExpr(
const Expr *E) {
17531 Base::VisitStmt(E);
17535 for (
auto *Sub : CSE->
children()) {
17536 const Expr *ChildExpr = dyn_cast_or_null<Expr>(Sub);
17551 void VisitCastExpr(
const CastExpr *E) {
17563 void VisitSequencedExpressions(
const Expr *SequencedBefore,
17564 const Expr *SequencedAfter) {
17565 SequenceTree::Seq BeforeRegion =
Tree.allocate(Region);
17566 SequenceTree::Seq AfterRegion =
Tree.allocate(Region);
17567 SequenceTree::Seq OldRegion = Region;
17570 SequencedSubexpression SeqBefore(*
this);
17571 Region = BeforeRegion;
17572 Visit(SequencedBefore);
17575 Region = AfterRegion;
17576 Visit(SequencedAfter);
17578 Region = OldRegion;
17580 Tree.merge(BeforeRegion);
17581 Tree.merge(AfterRegion);
17589 VisitSequencedExpressions(ASE->
getLHS(), ASE->
getRHS());
17596 void VisitBinPtrMemD(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17597 void VisitBinPtrMemI(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17603 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17610 void VisitBinShl(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17611 void VisitBinShr(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17616 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17628 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17632 SequenceTree::Seq RHSRegion;
17633 SequenceTree::Seq LHSRegion;
17635 RHSRegion =
Tree.allocate(Region);
17636 LHSRegion =
Tree.allocate(Region);
17638 RHSRegion = Region;
17639 LHSRegion = Region;
17641 SequenceTree::Seq OldRegion = Region;
17657 SequencedSubexpression SeqBefore(*
this);
17658 Region = RHSRegion;
17662 Region = LHSRegion;
17665 if (O && isa<CompoundAssignOperator>(BO))
17666 notePostUse(O, BO);
17670 Region = LHSRegion;
17673 if (O && isa<CompoundAssignOperator>(BO))
17674 notePostUse(O, BO);
17676 Region = RHSRegion;
17684 Region = OldRegion;
17688 : UK_ModAsSideEffect);
17690 Tree.merge(RHSRegion);
17691 Tree.merge(LHSRegion);
17696 VisitBinAssign(CAO);
17699 void VisitUnaryPreInc(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17700 void VisitUnaryPreDec(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17704 return VisitExpr(UO);
17712 : UK_ModAsSideEffect);
17715 void VisitUnaryPostInc(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17716 void VisitUnaryPostDec(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17720 return VisitExpr(UO);
17724 notePostMod(O, UO, UK_ModAsSideEffect);
17733 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17734 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17735 SequenceTree::Seq OldRegion = Region;
17737 EvaluationTracker Eval(*
this);
17739 SequencedSubexpression Sequenced(*
this);
17740 Region = LHSRegion;
17747 bool EvalResult =
false;
17748 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17749 bool ShouldVisitRHS = !EvalOK || !EvalResult;
17750 if (ShouldVisitRHS) {
17751 Region = RHSRegion;
17755 Region = OldRegion;
17756 Tree.merge(LHSRegion);
17757 Tree.merge(RHSRegion);
17766 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17767 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17768 SequenceTree::Seq OldRegion = Region;
17770 EvaluationTracker Eval(*
this);
17772 SequencedSubexpression Sequenced(*
this);
17773 Region = LHSRegion;
17779 bool EvalResult =
false;
17780 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17781 bool ShouldVisitRHS = !EvalOK || EvalResult;
17782 if (ShouldVisitRHS) {
17783 Region = RHSRegion;
17787 Region = OldRegion;
17788 Tree.merge(LHSRegion);
17789 Tree.merge(RHSRegion);
17797 SequenceTree::Seq ConditionRegion =
Tree.allocate(Region);
17813 SequenceTree::Seq TrueRegion =
Tree.allocate(Region);
17814 SequenceTree::Seq FalseRegion =
Tree.allocate(Region);
17815 SequenceTree::Seq OldRegion = Region;
17817 EvaluationTracker Eval(*
this);
17819 SequencedSubexpression Sequenced(*
this);
17820 Region = ConditionRegion;
17830 bool EvalResult =
false;
17831 bool EvalOK = Eval.evaluate(CO->
getCond(), EvalResult);
17832 bool ShouldVisitTrueExpr = !EvalOK || EvalResult;
17833 bool ShouldVisitFalseExpr = !EvalOK || !EvalResult;
17834 if (ShouldVisitTrueExpr) {
17835 Region = TrueRegion;
17838 if (ShouldVisitFalseExpr) {
17839 Region = FalseRegion;
17843 Region = OldRegion;
17844 Tree.merge(ConditionRegion);
17845 Tree.merge(TrueRegion);
17846 Tree.merge(FalseRegion);
17849 void VisitCallExpr(
const CallExpr *CE) {
17861 SequencedSubexpression Sequenced(*
this);
17866 SequenceTree::Seq CalleeRegion;
17867 SequenceTree::Seq OtherRegion;
17868 if (SemaRef.getLangOpts().CPlusPlus17) {
17869 CalleeRegion = Tree.allocate(Region);
17870 OtherRegion = Tree.allocate(Region);
17872 CalleeRegion = Region;
17873 OtherRegion = Region;
17875 SequenceTree::Seq OldRegion = Region;
17878 Region = CalleeRegion;
17880 SequencedSubexpression Sequenced(*this);
17881 Visit(CE->getCallee());
17883 Visit(CE->getCallee());
17887 Region = OtherRegion;
17891 Region = OldRegion;
17893 Tree.merge(CalleeRegion);
17894 Tree.merge(OtherRegion);
17912 return VisitCallExpr(CXXOCE);
17923 case OO_MinusEqual:
17925 case OO_SlashEqual:
17926 case OO_PercentEqual:
17927 case OO_CaretEqual:
17930 case OO_LessLessEqual:
17931 case OO_GreaterGreaterEqual:
17932 SequencingKind = RHSBeforeLHS;
17936 case OO_GreaterGreater:
17942 SequencingKind = LHSBeforeRHS;
17946 SequencingKind = LHSBeforeRest;
17950 SequencingKind = NoSequencing;
17954 if (SequencingKind == NoSequencing)
17955 return VisitCallExpr(CXXOCE);
17958 SequencedSubexpression Sequenced(*
this);
17961 assert(SemaRef.getLangOpts().CPlusPlus17 &&
17962 "Should only get there with C++17 and above!");
17963 assert((CXXOCE->getNumArgs() == 2 || CXXOCE->getOperator() == OO_Call) &&
17964 "Should only get there with an overloaded binary operator"
17965 " or an overloaded call operator!");
17967 if (SequencingKind == LHSBeforeRest) {
17968 assert(CXXOCE->getOperator() == OO_Call &&
17969 "We should only have an overloaded call operator here!");
17978 SequenceTree::Seq PostfixExprRegion = Tree.allocate(Region);
17979 SequenceTree::Seq ArgsRegion = Tree.allocate(Region);
17980 SequenceTree::Seq OldRegion = Region;
17982 assert(CXXOCE->getNumArgs() >= 1 &&
17983 "An overloaded call operator must have at least one argument"
17984 " for the postfix-expression!");
17985 const Expr *PostfixExpr = CXXOCE->getArgs()[0];
17986 llvm::ArrayRef<const Expr *> Args(CXXOCE->getArgs() + 1,
17987 CXXOCE->getNumArgs() - 1);
17991 Region = PostfixExprRegion;
17992 SequencedSubexpression Sequenced(*this);
17993 Visit(PostfixExpr);
17997 Region = ArgsRegion;
17998 for (const Expr *Arg : Args)
18001 Region = OldRegion;
18002 Tree.merge(PostfixExprRegion);
18003 Tree.merge(ArgsRegion);
18005 assert(CXXOCE->getNumArgs() == 2 &&
18006 "Should only have two arguments here!");
18007 assert((SequencingKind == LHSBeforeRHS ||
18008 SequencingKind == RHSBeforeLHS) &&
18009 "Unexpected sequencing kind!");
18013 const Expr *E1 = CXXOCE->getArg(0);
18014 const Expr *E2 = CXXOCE->getArg(1);
18015 if (SequencingKind == RHSBeforeLHS)
18018 return VisitSequencedExpressions(E1, E2);
18025 SequencedSubexpression Sequenced(*
this);
18028 return VisitExpr(CCE);
18031 SequenceExpressionsInOrder(
18037 return VisitExpr(ILE);
18040 SequenceExpressionsInOrder(ILE->
inits());
18052 SequenceTree::Seq
Parent = Region;
18053 for (
const Expr *E : ExpressionList) {
18057 Elts.push_back(Region);
18063 for (
unsigned I = 0; I < Elts.size(); ++I)
18064 Tree.merge(Elts[I]);
18068SequenceChecker::UsageInfo::UsageInfo() =
default;
18072void Sema::CheckUnsequencedOperations(
const Expr *E) {
18074 WorkList.push_back(E);
18075 while (!WorkList.empty()) {
18076 const Expr *Item = WorkList.pop_back_val();
18077 SequenceChecker(*
this, Item, WorkList);
18082 bool IsConstexpr) {
18084 IsConstexpr || isa<ConstantExpr>(E));
18085 CheckImplicitConversions(E, CheckLoc);
18087 CheckUnsequencedOperations(E);
18089 CheckForIntOverflow(E);
18103 if (
const auto *PointerTy = dyn_cast<PointerType>(PType)) {
18107 if (
const auto *ReferenceTy = dyn_cast<ReferenceType>(PType)) {
18111 if (
const auto *ParenTy = dyn_cast<ParenType>(PType)) {
18125 S.
Diag(Loc, diag::err_array_star_in_function_definition);
18134 bool CheckParameterNames) {
18135 bool HasInvalidParm =
false;
18137 assert(Param &&
"null in a parameter list");
18146 if (!Param->isInvalidDecl() &&
18148 diag::err_typecheck_decl_incomplete_type) ||
18150 diag::err_abstract_type_in_decl,
18152 Param->setInvalidDecl();
18153 HasInvalidParm =
true;
18158 if (CheckParameterNames && Param->getIdentifier() ==
nullptr &&
18162 Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c23);
18170 QualType PType = Param->getOriginalType();
18178 if (!Param->isInvalidDecl()) {
18180 if (!ClassDecl->isInvalidDecl() &&
18181 !ClassDecl->hasIrrelevantDestructor() &&
18182 !ClassDecl->isDependentContext() &&
18183 ClassDecl->isParamDestroyedInCallee()) {
18195 if (
const auto *
Attr = Param->getAttr<PassObjectSizeAttr>())
18196 if (!Param->getType().isConstQualified())
18197 Diag(Param->getLocation(), diag::err_attribute_pointers_only)
18201 if (
LangOpts.CPlusPlus && !Param->isInvalidDecl()) {
18206 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC->
getParent()))
18207 CheckShadowInheritedFields(Param->getLocation(), Param->getDeclName(),
18212 if (!Param->isInvalidDecl() &&
18214 Param->setInvalidDecl();
18215 HasInvalidParm =
true;
18216 Diag(Param->getLocation(), diag::err_wasm_table_as_function_parameter);
18220 return HasInvalidParm;
18223std::optional<std::pair<
18232static std::pair<CharUnits, CharUnits>
18240 if (
Base->isVirtual()) {
18247 BaseAlignment = std::min(BaseAlignment, NonVirtualAlignment);
18254 DerivedType =
Base->getType();
18257 return std::make_pair(BaseAlignment, Offset);
18261static std::optional<std::pair<CharUnits, CharUnits>>
18267 return std::nullopt;
18272 return std::nullopt;
18276 CharUnits Offset = EltSize * IdxRes->getExtValue();
18279 return std::make_pair(
P->first,
P->second + Offset);
18285 return std::make_pair(
18286 P->first.alignmentAtOffset(
P->second).alignmentAtOffset(EltSize),
18292std::optional<std::pair<
18300 case Stmt::CStyleCastExprClass:
18301 case Stmt::CXXStaticCastExprClass:
18302 case Stmt::ImplicitCastExprClass: {
18303 auto *CE = cast<CastExpr>(E);
18304 const Expr *From = CE->getSubExpr();
18305 switch (CE->getCastKind()) {
18310 case CK_UncheckedDerivedToBase:
18311 case CK_DerivedToBase: {
18321 case Stmt::ArraySubscriptExprClass: {
18322 auto *ASE = cast<ArraySubscriptExpr>(E);
18326 case Stmt::DeclRefExprClass: {
18327 if (
auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
18330 if (!VD->getType()->isReferenceType()) {
18332 if (VD->hasDependentAlignment())
18341 case Stmt::MemberExprClass: {
18342 auto *ME = cast<MemberExpr>(E);
18343 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
18347 std::optional<std::pair<CharUnits, CharUnits>>
P;
18356 return std::make_pair(
P->first,
18359 case Stmt::UnaryOperatorClass: {
18360 auto *UO = cast<UnaryOperator>(E);
18369 case Stmt::BinaryOperatorClass: {
18370 auto *BO = cast<BinaryOperator>(E);
18381 return std::nullopt;
18386std::optional<std::pair<
18395 case Stmt::CStyleCastExprClass:
18396 case Stmt::CXXStaticCastExprClass:
18397 case Stmt::ImplicitCastExprClass: {
18398 auto *CE = cast<CastExpr>(E);
18399 const Expr *From = CE->getSubExpr();
18400 switch (CE->getCastKind()) {
18405 case CK_ArrayToPointerDecay:
18407 case CK_UncheckedDerivedToBase:
18408 case CK_DerivedToBase: {
18418 case Stmt::CXXThisExprClass: {
18423 case Stmt::UnaryOperatorClass: {
18424 auto *UO = cast<UnaryOperator>(E);
18429 case Stmt::BinaryOperatorClass: {
18430 auto *BO = cast<BinaryOperator>(E);
18438 if (Opcode == BO_Add && !RHS->getType()->isIntegralOrEnumerationType())
18439 std::swap(LHS, RHS);
18449 return std::nullopt;
18454 std::optional<std::pair<CharUnits, CharUnits>>
P =
18458 return P->first.alignmentAtOffset(
P->second);
18478 if (!DestPtr)
return;
18484 if (DestAlign.
isOne())
return;
18488 if (!SrcPtr)
return;
18499 if (SrcAlign >= DestAlign)
return;
18504 <<
static_cast<unsigned>(DestAlign.
getQuantity())
18508void Sema::CheckArrayAccess(
const Expr *BaseExpr,
const Expr *IndexExpr,
18510 bool AllowOnePastEnd,
bool IndexNegated) {
18519 const Type *EffectiveType =
18526 StrictFlexArraysLevel =
getLangOpts().getStrictFlexArraysLevel();
18528 const Type *BaseType =
18530 bool IsUnboundedArray =
18532 Context, StrictFlexArraysLevel,
18542 llvm::APSInt index =
Result.Val.getInt();
18543 if (IndexNegated) {
18544 index.setIsUnsigned(
false);
18548 if (IsUnboundedArray) {
18551 if (index.isUnsigned() || !index.isNegative()) {
18553 unsigned AddrBits = ASTC.getTargetInfo().getPointerWidth(
18555 if (index.getBitWidth() < AddrBits)
18556 index = index.zext(AddrBits);
18557 std::optional<CharUnits> ElemCharUnits =
18558 ASTC.getTypeSizeInCharsIfKnown(EffectiveType);
18561 if (!ElemCharUnits || ElemCharUnits->isZero())
18563 llvm::APInt ElemBytes(index.getBitWidth(), ElemCharUnits->getQuantity());
18568 if (index.getActiveBits() <= AddrBits) {
18570 llvm::APInt Product(index);
18572 Product = Product.umul_ov(ElemBytes, Overflow);
18573 if (!Overflow && Product.getActiveBits() <= AddrBits)
18579 llvm::APInt MaxElems = llvm::APInt::getMaxValue(AddrBits);
18580 MaxElems = MaxElems.zext(std::max(AddrBits + 1, ElemBytes.getBitWidth()));
18582 ElemBytes = ElemBytes.zextOrTrunc(MaxElems.getBitWidth());
18583 MaxElems = MaxElems.udiv(ElemBytes);
18586 ASE ? diag::warn_array_index_exceeds_max_addressable_bounds
18587 : diag::warn_ptr_arith_exceeds_max_addressable_bounds;
18593 <<
toString(index, 10,
true) << AddrBits
18594 << (
unsigned)ASTC.toBits(*ElemCharUnits)
18597 << (
unsigned)MaxElems.getLimitedValue(~0
U)
18602 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18604 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18606 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18607 ND = ME->getMemberDecl();
18611 PDiag(diag::note_array_declared_here) << ND);
18616 if (index.isUnsigned() || !index.isNegative()) {
18626 llvm::APInt size = ArrayTy->
getSize();
18628 if (BaseType != EffectiveType) {
18636 if (!ptrarith_typesize)
18639 if (ptrarith_typesize != array_typesize) {
18641 uint64_t ratio = array_typesize / ptrarith_typesize;
18645 if (ptrarith_typesize * ratio == array_typesize)
18646 size *= llvm::APInt(size.getBitWidth(), ratio);
18650 if (size.getBitWidth() > index.getBitWidth())
18651 index = index.zext(size.getBitWidth());
18652 else if (size.getBitWidth() < index.getBitWidth())
18653 size = size.zext(index.getBitWidth());
18659 if (AllowOnePastEnd ? index.ule(size) : index.ult(size))
18676 unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds
18677 : diag::warn_ptr_arith_exceeds_bounds;
18678 unsigned CastMsg = (!ASE || BaseType == EffectiveType) ? 0 : 1;
18686 unsigned DiagID = diag::warn_array_index_precedes_bounds;
18688 DiagID = diag::warn_ptr_arith_precedes_bounds;
18689 if (index.isNegative()) index = -index;
18699 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18701 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18703 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18704 ND = ME->getMemberDecl();
18708 PDiag(diag::note_array_declared_here) << ND);
18711void Sema::CheckArrayAccess(
const Expr *
expr) {
18712 int AllowOnePastEnd = 0;
18714 expr =
expr->IgnoreParenImpCasts();
18715 switch (
expr->getStmtClass()) {
18716 case Stmt::ArraySubscriptExprClass: {
18719 AllowOnePastEnd > 0);
18723 case Stmt::MemberExprClass: {
18724 expr = cast<MemberExpr>(
expr)->getBase();
18727 case Stmt::ArraySectionExprClass: {
18733 nullptr, AllowOnePastEnd > 0);
18736 case Stmt::UnaryOperatorClass: {
18752 case Stmt::ConditionalOperatorClass: {
18755 CheckArrayAccess(lhs);
18757 CheckArrayAccess(rhs);
18760 case Stmt::CXXOperatorCallExprClass: {
18761 const auto *OCE = cast<CXXOperatorCallExpr>(
expr);
18762 for (
const auto *Arg : OCE->arguments())
18763 CheckArrayAccess(Arg);
18776struct RetainCycleOwner {
18780 bool Indirect =
false;
18782 RetainCycleOwner() =
default;
18784 void setLocsFrom(
Expr *e) {
18801 owner.Variable = var;
18803 owner.setLocsFrom(ref);
18811 switch (
cast->getCastKind()) {
18813 case CK_LValueBitCast:
18814 case CK_LValueToRValue:
18815 case CK_ARCReclaimReturnedObject:
18816 e =
cast->getSubExpr();
18833 if (ref->isFreeIvar()) owner.setLocsFrom(ref);
18834 owner.Indirect =
true;
18838 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) {
18839 VarDecl *var = dyn_cast<VarDecl>(ref->getDecl());
18840 if (!var)
return false;
18844 if (
MemberExpr *member = dyn_cast<MemberExpr>(e)) {
18845 if (member->isArrow())
return false;
18848 e = member->getBase();
18855 = dyn_cast<ObjCPropertyRefExpr>(pseudo->getSyntacticForm()
18857 if (!pre)
return false;
18860 if (!property->isRetaining() &&
18861 !(property->getPropertyIvarDecl() &&
18862 property->getPropertyIvarDecl()->getType()
18866 owner.Indirect =
true;
18869 if (!owner.Variable)
18875 e =
const_cast<Expr*
>(cast<OpaqueValueExpr>(pre->
getBase())
18876 ->getSourceExpr());
18890 Expr *Capturer =
nullptr;
18891 bool VarWillBeReased =
false;
18898 if (ref->
getDecl() == Variable && !Capturer)
18903 if (Capturer)
return;
18909 void VisitBlockExpr(
BlockExpr *block) {
18916 if (Capturer)
return;
18922 if (!Variable || VarWillBeReased || BinOp->
getOpcode() != BO_Assign)
18925 if (
const DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(LHS)) {
18926 if (DRE->
getDecl() != Variable)
18930 std::optional<llvm::APSInt>
Value;
18932 (RHS && (
Value = RHS->getIntegerConstantExpr(Context)) &&
18944 assert(owner.Variable && owner.Loc.isValid());
18951 if (
Cmd.isUnarySelector() &&
Cmd.getNameForSlot(0) ==
"copy") {
18952 e = ME->getInstanceReceiver();
18957 }
else if (
CallExpr *CE = dyn_cast<CallExpr>(e)) {
18962 if (FnI && FnI->
isStr(
"_Block_copy")) {
18969 BlockExpr *block = dyn_cast<BlockExpr>(e);
18973 FindCaptureVisitor visitor(S.
Context, owner.Variable);
18975 return visitor.VarWillBeReased ? nullptr : visitor.Capturer;
18979 RetainCycleOwner &owner) {
18981 assert(owner.Variable && owner.Loc.isValid());
18985 S.
Diag(owner.Loc, diag::note_arc_retain_cycle_owner)
18986 << owner.Indirect << owner.Range;
18995 str = str.ltrim(
'_');
18996 if (str.starts_with(
"set"))
18997 str = str.substr(3);
18998 else if (str.starts_with(
"add")) {
19000 if (sel.
getNumArgs() == 1 && str.starts_with(
"addOperationWithBlock"))
19002 str = str.substr(3);
19006 if (str.empty())
return true;
19010static std::optional<int>
19012 bool IsMutableArray = S.
NSAPIObj->isSubclassOfNSClass(
19013 Message->getReceiverInterface(),
19015 if (!IsMutableArray) {
19016 return std::nullopt;
19019 Selector Sel = Message->getSelector();
19021 std::optional<NSAPI::NSArrayMethodKind> MKOpt =
19022 S.
NSAPIObj->getNSArrayMethodKind(Sel);
19024 return std::nullopt;
19038 return std::nullopt;
19041 return std::nullopt;
19044static std::optional<int>
19046 bool IsMutableDictionary = S.
NSAPIObj->isSubclassOfNSClass(
19047 Message->getReceiverInterface(),
19049 if (!IsMutableDictionary) {
19050 return std::nullopt;
19053 Selector Sel = Message->getSelector();
19055 std::optional<NSAPI::NSDictionaryMethodKind> MKOpt =
19056 S.
NSAPIObj->getNSDictionaryMethodKind(Sel);
19058 return std::nullopt;
19070 return std::nullopt;
19073 return std::nullopt;
19078 bool IsMutableSet = S.
NSAPIObj->isSubclassOfNSClass(
19079 Message->getReceiverInterface(),
19082 bool IsMutableOrderedSet = S.
NSAPIObj->isSubclassOfNSClass(
19083 Message->getReceiverInterface(),
19085 if (!IsMutableSet && !IsMutableOrderedSet) {
19086 return std::nullopt;
19089 Selector Sel = Message->getSelector();
19091 std::optional<NSAPI::NSSetMethodKind> MKOpt =
19092 S.
NSAPIObj->getNSSetMethodKind(Sel);
19094 return std::nullopt;
19109 return std::nullopt;
19113 if (!Message->isInstanceMessage()) {
19117 std::optional<int> ArgOpt;
19125 int ArgIndex = *ArgOpt;
19127 Expr *Arg = Message->getArg(ArgIndex)->IgnoreImpCasts();
19133 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19134 if (ArgRE->isObjCSelfExpr()) {
19135 Diag(Message->getSourceRange().getBegin(),
19136 diag::warn_objc_circular_container)
19137 << ArgRE->getDecl() << StringRef(
"'super'");
19141 Expr *Receiver = Message->getInstanceReceiver()->IgnoreImpCasts();
19147 if (
DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {
19148 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19149 if (ReceiverRE->getDecl() == ArgRE->getDecl()) {
19151 Diag(Message->getSourceRange().getBegin(),
19152 diag::warn_objc_circular_container)
19154 if (!ArgRE->isObjCSelfExpr()) {
19156 diag::note_objc_circular_container_declared_here)
19161 }
else if (
ObjCIvarRefExpr *IvarRE = dyn_cast<ObjCIvarRefExpr>(Receiver)) {
19163 if (IvarRE->getDecl() == IvarArgRE->getDecl()) {
19165 Diag(Message->getSourceRange().getBegin(),
19166 diag::warn_objc_circular_container)
19169 diag::note_objc_circular_container_declared_here)
19184 RetainCycleOwner owner;
19197 for (
unsigned i = 0, e = msg->
getNumArgs(); i != e; ++i) {
19200 if (MD && MD->
parameters()[i]->hasAttr<NoEscapeAttr>())
19209 RetainCycleOwner owner;
19218 RetainCycleOwner Owner;
19232 Expr *RHS,
bool isProperty) {
19244 S.
Diag(Loc, diag::warn_arc_literal_assign)
19246 << (isProperty ? 0 : 1)
19254 Expr *RHS,
bool isProperty) {
19257 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19258 S.
Diag(Loc, diag::warn_arc_retained_assign)
19260 << (isProperty ? 0 : 1)
19264 RHS =
cast->getSubExpr();
19335 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19336 Diag(Loc, diag::warn_arc_retained_property_assign)
19340 RHS =
cast->getSubExpr();
19363 bool StmtLineInvalid;
19366 if (StmtLineInvalid)
19369 bool BodyLineInvalid;
19372 if (BodyLineInvalid)
19376 if (StmtLine != BodyLine)
19391 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19400 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19404 const Stmt *PossibleBody) {
19410 if (
const ForStmt *FS = dyn_cast<ForStmt>(S)) {
19411 StmtLoc = FS->getRParenLoc();
19412 Body = FS->getBody();
19413 DiagID = diag::warn_empty_for_body;
19414 }
else if (
const WhileStmt *WS = dyn_cast<WhileStmt>(S)) {
19415 StmtLoc = WS->getRParenLoc();
19416 Body = WS->getBody();
19417 DiagID = diag::warn_empty_while_body;
19422 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19445 bool ProbableTypo = isa<CompoundStmt>(PossibleBody);
19446 if (!ProbableTypo) {
19447 bool BodyColInvalid;
19450 if (BodyColInvalid)
19453 bool StmtColInvalid;
19456 if (StmtColInvalid)
19459 if (BodyCol > StmtCol)
19460 ProbableTypo =
true;
19463 if (ProbableTypo) {
19465 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19474 if (
Diags.
isIgnored(diag::warn_sizeof_pointer_expr_memaccess, OpLoc))
19486 if (
const auto *CE = dyn_cast<CallExpr>(RHSExpr);
19488 RHSExpr = CE->
getArg(0);
19489 else if (
const auto *CXXSCE = dyn_cast<CXXStaticCastExpr>(RHSExpr);
19490 CXXSCE && CXXSCE->isXValue())
19491 RHSExpr = CXXSCE->getSubExpr();
19495 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
19496 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
19499 if (LHSDeclRef && RHSDeclRef) {
19506 auto D =
Diag(OpLoc, diag::warn_self_move)
19522 const Expr *LHSBase = LHSExpr;
19523 const Expr *RHSBase = RHSExpr;
19524 const MemberExpr *LHSME = dyn_cast<MemberExpr>(LHSExpr);
19525 const MemberExpr *RHSME = dyn_cast<MemberExpr>(RHSExpr);
19526 if (!LHSME || !RHSME)
19529 while (LHSME && RHSME) {
19536 LHSME = dyn_cast<MemberExpr>(LHSBase);
19537 RHSME = dyn_cast<MemberExpr>(RHSBase);
19540 LHSDeclRef = dyn_cast<DeclRefExpr>(LHSBase);
19541 RHSDeclRef = dyn_cast<DeclRefExpr>(RHSBase);
19542 if (LHSDeclRef && RHSDeclRef) {
19549 Diag(OpLoc, diag::warn_self_move)
19555 if (isa<CXXThisExpr>(LHSBase) && isa<CXXThisExpr>(RHSBase))
19556 Diag(OpLoc, diag::warn_self_move)
19579 bool AreUnionMembers =
false) {
19580 [[maybe_unused]]
const Type *Field1Parent =
19582 [[maybe_unused]]
const Type *Field2Parent =
19587 "Can't evaluate layout compatibility between a struct field and a "
19590 (AreUnionMembers && Field1Parent->
isUnionType())) &&
19591 "AreUnionMembers should be 'true' for union fields (only).");
19604 if (Bits1 != Bits2)
19608 if (Field1->
hasAttr<clang::NoUniqueAddressAttr>() ||
19609 Field2->
hasAttr<clang::NoUniqueAddressAttr>())
19612 if (!AreUnionMembers &&
19624 if (
const CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(RD1)) {
19629 if (D1CXX->getNumBases() != D2CXX->
getNumBases())
19634 Base1 = D1CXX->bases_begin(),
19635 BaseEnd1 = D1CXX->bases_end(),
19638 ++Base1, ++Base2) {
19642 }
else if (
const CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(RD2)) {
19644 if (D2CXX->getNumBases() > 0)
19653 for ( ; Field1 != Field1End && Field2 != Field2End; ++Field1, ++Field2) {
19657 if (Field1 != Field1End || Field2 != Field2End)
19668 for (
auto *Field2 : RD2->
fields())
19669 UnmatchedFields.insert(Field2);
19671 for (
auto *Field1 : RD1->
fields()) {
19673 I = UnmatchedFields.begin(),
19674 E = UnmatchedFields.end();
19676 for ( ; I != E; ++I) {
19678 bool Result = UnmatchedFields.erase(*I);
19688 return UnmatchedFields.empty();
19714 if (
C.hasSameType(T1, T2))
19723 if (TC1 == Type::Enum) {
19725 cast<EnumType>(T1)->getDecl(),
19726 cast<EnumType>(T2)->getDecl());
19727 }
else if (TC1 == Type::Record) {
19732 cast<RecordType>(T1)->getDecl(),
19733 cast<RecordType>(T2)->getDecl());
19747 QualType BaseT =
Base->getType()->getCanonicalTypeUnqualified();
19778 const ValueDecl **VD, uint64_t *MagicValue,
19779 bool isConstantEvaluated) {
19787 case Stmt::UnaryOperatorClass: {
19796 case Stmt::DeclRefExprClass: {
19797 const DeclRefExpr *DRE = cast<DeclRefExpr>(TypeExpr);
19802 case Stmt::IntegerLiteralClass: {
19804 llvm::APInt MagicValueAPInt = IL->
getValue();
19805 if (MagicValueAPInt.getActiveBits() <= 64) {
19806 *MagicValue = MagicValueAPInt.getZExtValue();
19812 case Stmt::BinaryConditionalOperatorClass:
19813 case Stmt::ConditionalOperatorClass: {
19815 cast<AbstractConditionalOperator>(TypeExpr);
19818 isConstantEvaluated)) {
19828 case Stmt::BinaryOperatorClass: {
19831 TypeExpr = BO->
getRHS();
19861 const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
19864 bool isConstantEvaluated) {
19865 FoundWrongKind =
false;
19870 uint64_t MagicValue;
19872 if (!
FindTypeTagExpr(TypeExpr, Ctx, &VD, &MagicValue, isConstantEvaluated))
19876 if (TypeTagForDatatypeAttr *I = VD->
getAttr<TypeTagForDatatypeAttr>()) {
19877 if (I->getArgumentKind() != ArgumentKind) {
19878 FoundWrongKind =
true;
19881 TypeInfo.Type = I->getMatchingCType();
19882 TypeInfo.LayoutCompatible = I->getLayoutCompatible();
19883 TypeInfo.MustBeNull = I->getMustBeNull();
19894 MagicValues->find(std::make_pair(ArgumentKind, MagicValue));
19895 if (I == MagicValues->end())
19904 bool LayoutCompatible,
19906 if (!TypeTagForDatatypeMagicValues)
19907 TypeTagForDatatypeMagicValues.reset(
19908 new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);
19911 (*TypeTagForDatatypeMagicValues)[Magic] =
19927 return (T1Kind == BuiltinType::SChar && T2Kind == BuiltinType::Char_S) ||
19928 (T1Kind == BuiltinType::UChar && T2Kind == BuiltinType::Char_U) ||
19929 (T1Kind == BuiltinType::Char_U && T2Kind == BuiltinType::UChar) ||
19930 (T1Kind == BuiltinType::Char_S && T2Kind == BuiltinType::SChar);
19933void Sema::CheckArgumentWithTypeTag(
const ArgumentWithTypeTagAttr *
Attr,
19937 bool IsPointerAttr =
Attr->getIsPointer();
19940 unsigned TypeTagIdxAST =
Attr->getTypeTagIdx().getASTIndex();
19941 if (TypeTagIdxAST >= ExprArgs.size()) {
19942 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19943 << 0 <<
Attr->getTypeTagIdx().getSourceIndex();
19946 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
19947 bool FoundWrongKind;
19950 TypeTagForDatatypeMagicValues.get(), FoundWrongKind,
19952 if (FoundWrongKind)
19954 diag::warn_type_tag_for_datatype_wrong_kind)
19960 unsigned ArgumentIdxAST =
Attr->getArgumentIdx().getASTIndex();
19961 if (ArgumentIdxAST >= ExprArgs.size()) {
19962 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19963 << 1 <<
Attr->getArgumentIdx().getSourceIndex();
19966 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
19967 if (IsPointerAttr) {
19969 if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgumentExpr))
19970 if (ICE->getType()->isVoidPointerType() &&
19971 ICE->getCastKind() == CK_BitCast)
19972 ArgumentExpr = ICE->getSubExpr();
19985 diag::warn_type_safety_null_pointer_required)
19997 bool mismatch =
false;
20020 Diag(ArgumentExpr->
getExprLoc(), diag::warn_type_safety_type_mismatch)
20021 << ArgumentType << ArgumentKind
20022 <<
TypeInfo.LayoutCompatible << RequiredType
20029 MisalignedMembers.emplace_back(E, RD, MD, Alignment);
20033 for (MisalignedMember &m : MisalignedMembers) {
20039 Diag(m.E->getBeginLoc(), diag::warn_taking_address_of_packed_member)
20042 MisalignedMembers.clear();
20049 if (isa<UnaryOperator>(E) &&
20050 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
20051 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
20052 if (isa<MemberExpr>(Op)) {
20053 auto *MA = llvm::find(MisalignedMembers, MisalignedMember(Op));
20054 if (MA != MisalignedMembers.end() &&
20059 MisalignedMembers.erase(MA);
20068 const auto *ME = dyn_cast<MemberExpr>(E);
20080 bool AnyIsPacked =
false;
20082 QualType BaseType = ME->getBase()->getType();
20092 auto *FD = dyn_cast<FieldDecl>(MD);
20098 AnyIsPacked || (RD->
hasAttr<PackedAttr>() || MD->
hasAttr<PackedAttr>());
20099 ReverseMemberChain.push_back(FD);
20102 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParens());
20104 assert(TopME &&
"We did not compute a topmost MemberExpr!");
20111 const auto *DRE = dyn_cast<DeclRefExpr>(TopBase);
20115 if (!DRE && !isa<CXXThisExpr>(TopBase))
20122 if (ExpectedAlignment.
isOne())
20127 for (
const FieldDecl *FD : llvm::reverse(ReverseMemberChain))
20132 ReverseMemberChain.back()->getParent()->getTypeForDecl());
20136 if (DRE && !TopME->
isArrow()) {
20139 CompleteObjectAlignment =
20144 if (Offset % ExpectedAlignment != 0 ||
20147 CompleteObjectAlignment < ExpectedAlignment) {
20158 for (
FieldDecl *FDI : ReverseMemberChain) {
20159 if (FDI->hasAttr<PackedAttr>() ||
20160 FDI->getParent()->hasAttr<PackedAttr>()) {
20162 Alignment = std::min(
20168 assert(FD &&
"We did not find a packed FieldDecl!");
20169 Action(E, FD->
getParent(), FD, Alignment);
20173void Sema::CheckAddressOfPackedMember(
Expr *rhs) {
20174 using namespace std::placeholders;
20177 rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*
this), _1,
20181bool Sema::PrepareBuiltinElementwiseMathOneArgCall(
CallExpr *TheCall) {
20199bool Sema::BuiltinElementwiseMath(
CallExpr *TheCall) {
20213 TheCall->
setType(VecTy0->getElementType());
20237 diag::err_typecheck_call_different_arg_types)
20248bool Sema::BuiltinElementwiseTernaryMath(
CallExpr *TheCall,
20249 bool CheckForFloatArgs) {
20254 for (
int I = 0; I < 3; ++I) {
20258 Args[I] = Converted.
get();
20261 if (CheckForFloatArgs) {
20262 int ArgOrdinal = 1;
20263 for (
Expr *Arg : Args) {
20265 Arg->
getType(), ArgOrdinal++))
20269 int ArgOrdinal = 1;
20270 for (
Expr *Arg : Args) {
20277 for (
int I = 1; I < 3; ++I) {
20278 if (Args[0]->getType().getCanonicalType() !=
20279 Args[I]->getType().getCanonicalType()) {
20280 return Diag(Args[0]->getBeginLoc(),
20281 diag::err_typecheck_call_different_arg_types)
20282 << Args[0]->getType() << Args[I]->getType();
20285 TheCall->
setArg(I, Args[I]);
20288 TheCall->
setType(Args[0]->getType());
20292bool Sema::PrepareBuiltinReduceMathOneArgCall(
CallExpr *TheCall) {
20304bool Sema::BuiltinNonDeterministicValue(
CallExpr *TheCall) {
20313 << 1 << 0 << TyArg;
20327 Expr *Matrix = MatrixArg.
get();
20332 << 1 << 1 << Matrix->
getType();
20339 MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
20342 TheCall->
setType(ResultType);
20345 TheCall->
setArg(0, Matrix);
20350static std::optional<unsigned>
20353 std::optional<llvm::APSInt>
Value =
20360 uint64_t Dim =
Value->getZExtValue();
20379 unsigned PtrArgIdx = 0;
20385 bool ArgError =
false;
20392 PtrExpr = PtrConv.
get();
20393 TheCall->
setArg(0, PtrExpr);
20404 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20411 << PtrArgIdx + 1 << 2
20418 auto ApplyArgumentConversions = [
this](
Expr *E) {
20427 ExprResult RowsConv = ApplyArgumentConversions(RowsExpr);
20429 RowsExpr = RowsConv.
get();
20430 TheCall->
setArg(1, RowsExpr);
20432 RowsExpr =
nullptr;
20434 ExprResult ColumnsConv = ApplyArgumentConversions(ColumnsExpr);
20436 ColumnsExpr = ColumnsConv.
get();
20437 TheCall->
setArg(2, ColumnsExpr);
20439 ColumnsExpr =
nullptr;
20450 std::optional<unsigned> MaybeRows;
20454 std::optional<unsigned> MaybeColumns;
20459 ExprResult StrideConv = ApplyArgumentConversions(StrideExpr);
20462 StrideExpr = StrideConv.
get();
20463 TheCall->
setArg(3, StrideExpr);
20466 if (std::optional<llvm::APSInt>
Value =
20469 if (Stride < *MaybeRows) {
20471 diag::err_builtin_matrix_stride_too_small);
20477 if (ArgError || !MaybeRows || !MaybeColumns)
20490 unsigned PtrArgIdx = 1;
20495 bool ArgError =
false;
20501 MatrixExpr = MatrixConv.
get();
20502 TheCall->
setArg(0, MatrixExpr);
20512 << 1 << 1 << MatrixExpr->
getType();
20520 PtrExpr = PtrConv.
get();
20521 TheCall->
setArg(1, PtrExpr);
20532 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20537 Diag(PtrExpr->
getBeginLoc(), diag::err_builtin_matrix_store_to_const);
20544 diag::err_builtin_matrix_pointer_arg_mismatch)
20545 << ElementTy << MatrixTy->getElementType();
20560 StrideExpr = StrideConv.
get();
20561 TheCall->
setArg(2, StrideExpr);
20566 if (std::optional<llvm::APSInt>
Value =
20569 if (Stride < MatrixTy->getNumRows()) {
20571 diag::err_builtin_matrix_stride_too_small);
20588 const auto *ATy = dyn_cast<ArrayType>(ArgExpr->
getType());
20589 if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
20591 diag::err_wasm_builtin_arg_must_be_table_type)
20594 ElTy = ATy->getElementType();
20600 unsigned ArgIndex) {
20604 diag::err_wasm_builtin_arg_must_be_integer_type)
20612bool Sema::BuiltinWasmTableGet(
CallExpr *TheCall) {
20635bool Sema::BuiltinWasmTableSet(
CallExpr *TheCall) {
20653bool Sema::BuiltinWasmTableSize(
CallExpr *TheCall) {
20667bool Sema::BuiltinWasmTableGrow(
CallExpr *TheCall) {
20678 diag::err_wasm_builtin_arg_must_match_table_element_type)
20691bool Sema::BuiltinWasmTableFill(
CallExpr *TheCall) {
20705 diag::err_wasm_builtin_arg_must_match_table_element_type)
20718bool Sema::BuiltinWasmTableCopy(
CallExpr *TheCall) {
20733 diag::err_wasm_builtin_arg_must_match_table_element_type)
20737 for (
int I = 2; I <= 4; I++) {
20757 if (!Caller || !Caller->
hasAttr<EnforceTCBAttr>())
20762 llvm::StringSet<> CalleeTCBs;
20763 for (
const auto *A :
Callee->specific_attrs<EnforceTCBAttr>())
20764 CalleeTCBs.insert(A->getTCBName());
20765 for (
const auto *A :
Callee->specific_attrs<EnforceTCBLeafAttr>())
20766 CalleeTCBs.insert(A->getTCBName());
20770 for (
const auto *A : Caller->
specific_attrs<EnforceTCBAttr>()) {
20771 StringRef CallerTCB = A->getTCBName();
20772 if (CalleeTCBs.count(CallerTCB) == 0) {
20773 this->
Diag(CallExprLoc, diag::warn_tcb_enforcement_violation)
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
Provides definitions for the various language-specific address spaces.
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
static bool getTypeString(SmallStringEnc &Enc, const Decl *D, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
The XCore ABI includes a type information section that communicates symbol type information to the li...
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Target Target
Defines the clang::OpenCLOptions class.
Defines an enumeration for C++ overloaded operators.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool BuiltinReserveRWPipe(Sema &S, CallExpr *Call)
static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx, const ValueDecl **VD, uint64_t *MagicValue, bool isConstantEvaluated)
Given a type tag expression find the type tag itself.
static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth, bool InConstantContext, bool Approximate)
Pseudo-evaluate the given integer expression, estimating the range of values it might take.
static void CheckConditionalOperator(Sema &S, AbstractConditionalOperator *E, SourceLocation CC, QualType T)
static QualType getSizeOfArgType(const Expr *E)
If E is a sizeof expression, returns its argument type.
static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc)
static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, IdentifierInfo *FnName, SourceLocation FnLoc, SourceLocation RParenLoc)
Takes the expression passed to the size_t parameter of functions such as memcmp, strncat,...
static const CXXRecordDecl * getContainedDynamicClass(QualType T, bool &IsContained)
Determine whether the given type is or contains a dynamic class type (e.g., whether it has a vtable).
static ExprResult PointerAuthSignGenericData(Sema &S, CallExpr *Call)
static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext)
Diagnose an implicit cast from a floating point value to an integer value.
static void CheckFormatString(Sema &S, const FormatStringLiteral *FExpr, const Expr *OrigFormatExpr, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, bool inFunctionCall, Sema::VariadicCallType CallType, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, bool IgnoreStringsWithoutSpecifiers)
static ExprResult PointerAuthStrip(Sema &S, CallExpr *Call)
static bool considerVariable(VarDecl *var, Expr *ref, RetainCycleOwner &owner)
Consider whether capturing the given variable can possibly lead to a retain cycle.
static void CheckImplicitConversion(Sema &S, Expr *E, QualType T, SourceLocation CC, bool *ICContext=nullptr, bool IsListInit=false)
static bool IsSameFloatAfterCast(const llvm::APFloat &value, const llvm::fltSemantics &Src, const llvm::fltSemantics &Tgt)
Checks whether the given value, which currently has the given source semantics, has the same value wh...
static StringLiteralCheckType checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, Sema::VariadicCallType CallType, bool InFunctionCall, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset, bool IgnoreStringsWithoutSpecifiers=false)
static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth)
static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool)
static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T, SourceLocation CContext, unsigned diag, bool pruneControlFlow=false)
Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg)
OpenCL C v2.0, s6.13.17.2 - Checks that the block parameters are all local void*, which is a requirem...
static bool isX86_32Builtin(unsigned BuiltinID)
static void AnalyzeComparison(Sema &S, BinaryOperator *E)
Implements -Wsign-compare.
static void sumOffsets(llvm::APSInt &Offset, llvm::APSInt Addend, BinaryOperatorKind BinOpKind, bool AddendIsRight)
static std::pair< QualType, StringRef > shouldNotPrintDirectly(const ASTContext &Context, QualType IntendedTy, const Expr *E)
static QualType GetExprType(const Expr *E)
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromLValue(const Expr *E, ASTContext &Ctx)
This helper function takes an lvalue expression and returns the alignment of a VarDecl and a constant...
static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall, SourceLocation CC)
static bool OpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17.6 - Check the argument to the get_kernel_work_group_size and get_kernel_prefe...
static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant)
static AbsoluteValueKind getAbsoluteValueKind(QualType T)
bool CheckNoDoubleVectors(Sema *S, CallExpr *TheCall)
static bool isKnownToHaveUnsignedValue(Expr *E)
static ExprResult BuiltinDumpStruct(Sema &S, CallExpr *TheCall)
static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout structs are layout-compatible.
bool CheckUnsignedIntRepresentation(Sema *S, CallExpr *TheCall)
bool CheckVectorElementCallArgs(Sema *S, CallExpr *TheCall)
static unsigned RFT(unsigned t, bool shift=false, bool ForceQuad=false)
static bool hasArmZAState(const FunctionDecl *FD)
static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntType)
Diagnose integer type and any valid implicit conversion to it.
static bool isValidOrderingForOp(int64_t Ordering, AtomicExpr::AtomicOp Op)
static bool BuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall, Scope::ScopeFlags NeededScopeFlags, unsigned DiagID)
static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E)
Analyze the given compound assignment for the possible losing of floating-point precision.
static bool doesExprLikelyComputeSize(const Expr *SizeofExpr)
Detect if SizeofExpr is likely to calculate the sizeof an object.
static bool isObjCSignedCharBool(Sema &S, QualType Ty)
static bool OpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID, CallExpr *Call)
static bool BuiltinPreserveAI(Sema &S, CallExpr *TheCall)
Check the number of arguments and set the result type to the argument type.
bool CheckFloatOrHalfRepresentations(Sema *S, CallExpr *TheCall)
static bool isValidBPFPreserveTypeInfoArg(Expr *Arg)
static bool CheckForReference(Sema &SemaRef, const Expr *E, const PartialDiagnostic &PD)
static bool checkMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static const UnaryExprOrTypeTraitExpr * getAsSizeOfExpr(const Expr *E)
static bool BuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID)
Check that the value argument for __builtin_is_aligned(value, alignment) and __builtin_aligned_{up,...
static bool BuiltinRWPipe(Sema &S, CallExpr *Call)
static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC)
Check conversion of given expression to boolean.
static bool checkPointerAuthValue(Sema &S, Expr *&Arg, PointerAuthOpKind OpKind)
static Expr * findCapturingExpr(Sema &S, Expr *e, RetainCycleOwner &owner)
Check whether the given argument is a block which captures a variable.
static bool checkArgCountAtLeast(Sema &S, CallExpr *Call, unsigned MinArgCount)
Checks that a call expression's argument count is at least the desired number.
static void CheckMemaccessSize(Sema &S, unsigned BId, const CallExpr *Call)
Diagnose cases like 'memset(buf, sizeof(buf), 0)', which should have the last two arguments transpose...
static bool checkPointerAuthEnabled(Sema &S, Expr *E)
static std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range)
static const Expr * getStrlenExprArg(const Expr *E)
static void checkObjCDictionaryLiteral(Sema &S, QualType TargetType, ObjCDictionaryLiteral *DictionaryLiteral)
Check an Objective-C dictionary literal being converted to the given target type.
static void checkArmStreamingBuiltin(Sema &S, CallExpr *TheCall, const FunctionDecl *FD, ArmStreamingType BuiltinType)
static bool isConstantSizeArrayWithMoreThanOneElement(QualType Ty, ASTContext &Context)
static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall, const TargetInfo *AuxTI, unsigned BuiltinID)
BuiltinCpu{Supports|Is} - Handle __builtin_cpu_{supports|is}(char *).
static bool isBlockPointer(Expr *Arg)
static bool isSetterLikeSelector(Selector sel)
Check for a keyword selector that starts with the word 'add' or 'set'.
static bool CheckWasmBuiltinArgIsTable(Sema &S, CallExpr *E, unsigned ArgIndex, QualType &ElTy)
Checks the argument at the given index is a WebAssembly table and if it is, sets ElTy to the element ...
static std::optional< int > GetNSMutableDictionaryArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static void adornObjCBoolConversionDiagWithTernaryFixit(Sema &S, Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder)
static bool OpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different overload formats specified ...
static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall, Expr *BlockArg, unsigned NumNonVarArgs)
OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all 'local void*' parameter of passed blo...
static bool BuiltinCommitRWPipe(Sema &S, CallExpr *Call)
static bool IsSameCharType(QualType T1, QualType T2)
bool CheckAllArgsHaveFloatRepresentation(Sema *S, CallExpr *TheCall)
static OpenCLAccessAttr * getOpenCLArgAccess(const Decl *D)
Returns OpenCL access qual.
static bool CheckNonNullExpr(Sema &S, const Expr *Expr)
Checks if a the given expression evaluates to null.
static bool isArgumentExpandedFromMacro(SourceManager &SM, SourceLocation CallLoc, SourceLocation ArgLoc)
Check if the ArgLoc originated from a macro passed to the call at CallLoc.
static const IntegerLiteral * getIntegerLiteral(Expr *E)
static ArmStreamingType getArmStreamingFnType(const FunctionDecl *FD)
static const Expr * maybeConstEvalStringLiteral(ASTContext &Context, const Expr *E)
static bool IsStdFunction(const FunctionDecl *FDecl, const char(&Str)[StrLen])
static void AnalyzeAssignment(Sema &S, BinaryOperator *E)
Analyze the given simple or compound assignment for warning-worthy operations.
static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_function_start is a function.
static bool BuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall)
static bool ShouldDiagnoseEmptyStmtBody(const SourceManager &SourceMgr, SourceLocation StmtLoc, const NullStmt *Body)
static std::pair< CharUnits, CharUnits > getDerivedToBaseAlignmentAndOffset(const CastExpr *CE, QualType DerivedType, CharUnits BaseAlignment, CharUnits Offset, ASTContext &Ctx)
Compute the alignment and offset of the base class object given the derived-to-base cast expression a...
static void diagnoseArrayStarInParamType(Sema &S, QualType PType, SourceLocation Loc)
static ArmSMEState getSMEState(unsigned BuiltinID)
static unsigned changeAbsFunction(unsigned AbsKind, AbsoluteValueKind ValueKind)
static void CheckConditionalOperand(Sema &S, Expr *E, QualType T, SourceLocation CC, bool &ICContext)
static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2)
Check if two types are layout-compatible in C++11 sense.
static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool isValidBPFPreserveFieldInfoArg(Expr *Arg)
static bool checkUnsafeAssignLiteral(Sema &S, SourceLocation Loc, Expr *RHS, bool isProperty)
static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall)
static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx)
Returns true if pipe element type is different from the pointer.
static ExprResult PointerAuthBlendDiscriminator(Sema &S, CallExpr *Call)
static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc)
Analyzes an attempt to assign the given value to a bitfield.
static int classifyConstantValue(Expr *Constant)
static bool IsInAnyMacroBody(const SourceManager &SM, SourceLocation Loc)
static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range, unsigned AbsKind, QualType ArgType)
static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call)
Returns true if pipe element type is different from the pointer.
static bool checkPointerAuthKey(Sema &S, Expr *&Arg)
static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty)
static bool BuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID)
static unsigned getAbsoluteValueFunctionKind(const FunctionDecl *FDecl)
static void diagnoseRetainCycle(Sema &S, Expr *capturer, RetainCycleOwner &owner)
static llvm::SmallPtrSet< MemberKind *, 1 > CXXRecordMembersNamed(StringRef Name, Sema &S, QualType Ty)
static QualType getNeonEltType(NeonTypeFlags Flags, ASTContext &Context, bool IsPolyUnsigned, bool IsInt64Long)
getNeonEltType - Return the QualType corresponding to the elements of the vector type specified by th...
static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool CheckBuiltinTargetInSupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ArchType > SupportedArchs)
static void CheckNonNullArguments(Sema &S, const NamedDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< const Expr * > Args, SourceLocation CallSiteLoc)
static unsigned getLargerAbsoluteValueFunction(unsigned AbsFunction)
static bool findRetainCycleOwner(Sema &S, Expr *e, RetainCycleOwner &owner)
static bool hasArmZT0State(const FunctionDecl *FD)
static analyze_format_string::ArgType::MatchKind handleFormatSignedness(analyze_format_string::ArgType::MatchKind Match, DiagnosticsEngine &Diags, SourceLocation Loc)
static std::optional< int > GetNSSetArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool referToTheSameDecl(const Expr *E1, const Expr *E2)
Check if two expressions refer to the same declaration.
static bool OpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall)
static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall)
Checks that __builtin_{clzg,ctzg} was called with a first argument, which is an unsigned integer,...
static bool requiresParensToAddCast(const Expr *E)
static ExprResult PointerAuthAuthAndResign(Sema &S, CallExpr *Call)
static const Expr * ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx)
static void checkObjCCollectionLiteralElement(Sema &S, QualType TargetElementType, Expr *Element, unsigned ElementKind)
Check a single element within a collection literal against the target element type.
static bool BuiltinPipePackets(Sema &S, CallExpr *Call)
static bool CheckWasmBuiltinArgIsInteger(Sema &S, CallExpr *E, unsigned ArgIndex)
Checks the argument at the given index is an integer.
static std::optional< unsigned > getAndVerifyMatrixDimension(Expr *Expr, StringRef Name, Sema &S)
static bool checkArgCountRange(Sema &S, CallExpr *Call, unsigned MinArgCount, unsigned MaxArgCount)
Checks that a call expression's argument count is in the desired range.
static bool convertArgumentToType(Sema &S, Expr *&Value, QualType Ty)
static bool ProcessFormatStringLiteral(const Expr *FormatExpr, StringRef &FormatStrRef, size_t &StrLen, ASTContext &Context)
static bool checkArgCount(Sema &S, CallExpr *Call, unsigned DesiredArgCount)
Checks that a call expression's argument count is the desired number.
static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall)
Checks that __builtin_popcountg was called with a single argument, which is an unsigned integer.
void SetElementTypeAsReturnType(Sema *S, CallExpr *TheCall, QualType ReturnType)
static const Expr * getSizeOfExprArg(const Expr *E)
If E is a sizeof expression, returns its argument expression, otherwise returns NULL.
static void DiagnoseIntInBoolContext(Sema &S, Expr *E)
static bool CheckBuiltinTargetNotInUnsupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ObjectFormatType > UnsupportedObjectFormatTypes)
static bool BuiltinAddressof(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_addressof is a glvalue, and set the result type to the correspon...
static CharUnits getPresumedAlignmentOfPointer(const Expr *E, Sema &S)
static ExprResult PointerAuthSignOrAuth(Sema &S, CallExpr *Call, PointerAuthOpKind OpKind)
static std::optional< int > GetNSMutableArrayArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn)
Check that the user is calling the appropriate va_start builtin for the target and calling convention...
static bool IsEnumConstOrFromMacro(Sema &S, Expr *E)
static bool CheckInvalidVLENandLMUL(const TargetInfo &TI, CallExpr *TheCall, Sema &S, QualType Type, int EGW)
static bool GetMatchingCType(const IdentifierInfo *ArgumentKind, const Expr *TypeExpr, const ASTContext &Ctx, const llvm::DenseMap< Sema::TypeTagMagicValue, Sema::TypeTagData > *MagicValues, bool &FoundWrongKind, Sema::TypeTagData &TypeInfo, bool isConstantEvaluated)
Retrieve the C type corresponding to type tag TypeExpr.
static void checkObjCArrayLiteral(Sema &S, QualType TargetType, ObjCArrayLiteral *ArrayLiteral)
Check an Objective-C array literal being converted to the given target type.
static bool isLayoutCompatibleUnion(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout unions are layout-compatible.
static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str, unsigned &Mask)
DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str, advancing the pointer ov...
static QualType getAbsoluteValueArgumentType(ASTContext &Context, unsigned AbsType)
static void DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, const NamedDecl *FDecl, Expr **Args, unsigned NumArgs)
Diagnose use of s directive in an NSString which is being passed as formatting string to formatting m...
static bool isNonNullType(QualType type)
Determine whether the given type has a non-null nullability annotation.
static constexpr unsigned short combineFAPK(Sema::FormatArgumentPassingKind A, Sema::FormatArgumentPassingKind B)
static bool BuiltinAnnotation(Sema &S, CallExpr *TheCall)
Check that the first argument to __builtin_annotation is an integer and the second argument is a non-...
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromPtr(const Expr *E, ASTContext &Ctx)
This helper function takes a pointer expression and returns the alignment of a VarDecl and a constant...
static bool IsShiftedByte(llvm::APSInt Value)
static unsigned getBestAbsFunction(ASTContext &Context, QualType ArgType, unsigned AbsFunctionKind)
static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex)
checkBuiltinArgument - Given a call to a builtin function, perform normal type-checking on the given ...
static void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E)
Analyze the operands of the given comparison.
static bool isPPC_64Builtin(unsigned BuiltinID)
static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call)
static bool isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE)
Return true if ICE is an implicit argument promotion of an arithmetic type.
static bool isValidBPFPreserveEnumValueArg(Expr *Arg)
static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC, bool IsListInit=false)
AnalyzeImplicitConversions - Find and report any interesting implicit conversions in the given expres...
static bool HasEnumType(Expr *E)
static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall, unsigned Start, unsigned End)
static std::optional< std::pair< CharUnits, CharUnits > > getAlignmentAndOffsetFromBinAddOrSub(const Expr *PtrE, const Expr *IntE, bool IsSub, ASTContext &Ctx)
Compute the alignment and offset of a binary additive operator.
static bool checkFPMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static bool checkArgCountAtMost(Sema &S, CallExpr *Call, unsigned MaxArgCount)
Checks that a call expression's argument count is at most the desired number.
static bool BuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall)
static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam=nullptr)
bool CheckArgsTypesAreCorrect(Sema *S, CallExpr *TheCall, QualType ExpectedType, llvm::function_ref< bool(clang::QualType PassedType)> Check)
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Provides definitions for the atomic synchronization scopes.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
__DEVICE__ int min(int __a, int __b)
__device__ __2f16 float __ockl_bool s
llvm::APInt getValue() const
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
APSInt & getComplexIntImag()
bool isComplexInt() const
bool isComplexFloat() const
APValue & getVectorElt(unsigned I)
unsigned getVectorLength() const
APSInt & getComplexIntReal()
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
bool isAddrLabelDiff() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getIntWidth(QualType T) const
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
QualType getRecordType(const RecordDecl *Decl) const
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
Builtin::Context & BuiltinInfo
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const
Compare the rank of two floating point types as above, but compare equal if both types have the same ...
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
llvm::APFixedPoint getFixedPointMin(QualType Ty) const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getWebAssemblyExternrefType() const
Return a WebAssembly externref type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CanQualType OCLClkEventTy
const clang::PrintingPolicy & getPrintingPolicy() const
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType OCLReserveIDTy
CanQualType UnsignedShortTy
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
CanQualType getNSIntegerType() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
QualType DecodeTypeStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequireICE, bool AllowTypeModifiers) const
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
CanQualType getNSUIntegerType() const
uint64_t getCharWidth() const
Return the size of the character type, in bits.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getNonVirtualAlignment() const
getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
SourceLocation getQuestionLoc() const
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
Expr * getBase()
Get base of the array section.
Expr * getLowerBound()
Get lower bound of array section.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getRBracketLoc() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
std::unique_ptr< AtomicScopeModel > getScopeModel() const
Get atomic scope model.
SourceLocation getBeginLoc() const LLVM_READONLY
Attr - This represents one attribute.
const char * getSpelling() const
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isLogicalOp(Opcode Opc)
SourceLocation getOperatorLoc() const
SourceLocation getExprLoc() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
bool isEqualityOp() const
static bool isAdditiveOp(Opcode Opc)
static bool isEqualityOp(Opcode Opc)
A fixed int type of a specified bitwidth.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
bool capturesVariable(const VarDecl *var) const
const ParmVarDecl * getParamDecl(unsigned i) const
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
const BlockDecl * getBlockDecl() const
QualType getPointeeType() const
This class is used for builtin types like 'int'.
bool isFloatingPoint() const
bool isSignedInteger() const
bool isUnsignedInteger() const
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
unsigned getAuxBuiltinID(unsigned ID) const
Return real builtin ID (i.e.
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Represents a base class of a C++ class.
Represents a call to a C++ constructor.
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
A call to an overloaded operator written using operator syntax.
SourceLocation getExprLoc() const LLVM_READONLY
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents a list-initialization with parenthesis.
ArrayRef< Expr * > getInitExprs()
Represents a C++ struct/union/class.
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
base_class_iterator bases_begin()
bool isDynamicClass() const
Represents a C++ nested-name-specifier or a global scope specifier.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
bool isCallToStdMove() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
Expr ** getArgs()
Retrieve the call arguments.
SourceLocation getRParenLoc() const
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
static CharSourceRange getTokenRange(SourceRange R)
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
bool isOne() const
isOne - Test whether the quantity equals one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
void setExprNeedsCleanups(bool SideEffects)
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
ConditionalOperator - The ?: ternary operator.
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
llvm::APInt getSize() const
Return the constant array size as an APInt.
Represents a concrete matrix type with constant number of rows and columns.
static constexpr unsigned getMaxElementsPerDimension()
Returns the maximum number of elements per dimension.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Expr * getOperand() const
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
bool isInStdNamespace() const
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
RAII class that determines when any errors have occurred between the time the instance was created an...
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Concrete class used by the front-end to report problems and issues.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
An instance of this object exists for each enum constant that is defined.
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
bool isComplete() const
Returns true if this can be considered a complete type.
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EvaluatedExprVisitor - This class visits 'Expr *'s.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
@ SE_AllowSideEffects
Allow any unmodeled side effect.
@ SE_NoSideEffects
Strictly evaluate the expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const
If the current Expr is a pointer, this will try to statically determine the strlen of the string poin...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFixedPoint - Return true if this is a constant which we can fold and convert to a fixed poi...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImplicitAsWritten() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_NotNull
Expression is not a Null pointer constant.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
QualType getEnumCoercedType(const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant ...
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool isFlexibleArrayMemberLike(ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
void EvaluateForOverflow(const ASTContext &Ctx) const
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getBitWidthValue(const ASTContext &Ctx) const
Computes the bit width of this field, if this is a bit field.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
llvm::APFloat getValue() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Represents a function declaration or definition.
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool hasCXXExplicitFunctionObjectParameter() const
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
unsigned getAArch64SMEAttributes() const
Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
ArrayRef< QualType > getParamTypes() const
FunctionType - C99 6.7.5.3 - Function Declarators.
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
QualType getReturnType() const
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Describes an C or C++ initializer list.
ArrayRef< Expr * > inits()
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
StrictFlexArraysLevelKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
static StringRef getImmediateMacroName(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
static StringRef getImmediateMacroNameForDiagnostics(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
static bool isValidElementType(QualType T)
Valid elements types are the following:
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
@ ClassId_NSMutableOrderedSet
@ ClassId_NSMutableDictionary
NSSetMethodKind
Enumerates the NSMutableSet/NSOrderedSet methods used to apply some checks.
@ NSOrderedSet_setObjectAtIndex
@ NSOrderedSet_replaceObjectAtIndexWithObject
@ NSOrderedSet_setObjectAtIndexedSubscript
@ NSOrderedSet_insertObjectAtIndex
NSDictionaryMethodKind
Enumerates the NSDictionary/NSMutableDictionary methods used to generate literals and to apply some c...
@ NSMutableDict_setValueForKey
@ NSMutableDict_setObjectForKey
@ NSMutableDict_setObjectForKeyedSubscript
NSArrayMethodKind
Enumerates the NSArray/NSMutableArray methods used to generate literals and to apply some checks.
@ NSMutableArr_setObjectAtIndexedSubscript
@ NSMutableArr_insertObjectAtIndex
@ NSMutableArr_replaceObjectAtIndex
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
Flags to identify the types for overloaded Neon builtins.
EltType getEltType() const
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NullStmt - This is the null statement ";": C99 6.8.3p3.
bool hasLeadingEmptyMacro() const
SourceLocation getSemiLoc() const
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Represents an ObjC class declaration.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
SourceLocation getSuperLoc() const
Retrieve the location of the 'super' keyword for a class or instance message to 'super',...
Selector getSelector() const
@ SuperInstance
The receiver is the instance of the superclass object.
@ Instance
The receiver is an object instance.
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
const ObjCMethodDecl * getMethodDecl() const
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver.
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
ArrayRef< ParmVarDecl * > parameters() const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Represents a pointer to an Objective C object.
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
Represents one property declaration in an Objective-C interface.
ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
ObjCPropertyDecl * getExplicitProperty() const
const Expr * getBase() const
bool isImplicitProperty() const
SourceLocation getLocation() const
bool isSuperReceiver() const
ObjCStringLiteral, used for Objective-C string literals i.e.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parethesized expression, e.g.
Represents a parameter to a function.
QualType getElementType() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
PrimitiveDefaultInitializeKind
QualType withoutLocalFastQualifiers() const
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool isConstant(const ASTContext &Ctx) const
QualType withVolatile() const
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void removeLocalVolatile()
bool isConstQualified() const
Determine whether this type is const-qualified.
const Type * getTypePtrOrNull() const
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
bool hasUnaligned() const
Represents a struct/union/class.
field_iterator field_end() const
field_range fields() const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Scope - A scope is a transient data structure that is used while parsing the program.
ScopeFlags
ScopeFlags - These are bitfields that are or'd together when creating a scope, which defines the sort...
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
@ SEHExceptScope
This scope corresponds to an SEH except.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isUnarySelector() const
unsigned getNumArgs() const
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Sema - This implements semantic analysis and AST building for C.
const FieldDecl * getSelfAssignmentClassMemberCandidate(const ValueDecl *SelfAssigned)
Returns a field in a CXXRecordDecl that has the same name as the decl SelfAssigned when inside a CXXM...
bool IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base, const TypeSourceInfo *Derived)
bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, const Expr *ThisArg, ArrayRef< const Expr * > Args, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any non-ArgDependent DiagnoseIf...
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupAnyName
Look up any declaration with any name.
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
bool isValidPointerAttrType(QualType T, bool RefOkay=false)
Determine if type T is a valid subject for a nonnull and similar attributes.
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
bool FormatStringHasSArg(const StringLiteral *FExpr)
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, bool IsVariadic, FormatStringInfo *FSI)
Given a FunctionDecl's FormatAttr, attempts to populate the FomatStringInfo parameter with the Format...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void RefersToMemberWithReducedAlignment(Expr *E, llvm::function_ref< void(Expr *, RecordDecl *, FieldDecl *, CharUnits)> Action)
This function calls Action when it determines that E designates a misaligned member due to the packed...
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
ExprResult tryConvertExprToType(Expr *E, QualType Ty)
Try to convert an expression E to type Ty.
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
DiagnosticsEngine & getDiagnostics() const
static FormatStringType GetFormatStringType(const FormatAttr *Format)
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
bool BuiltinVectorToScalarMath(CallExpr *TheCall)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
bool CheckHLSLBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool IsLayoutCompatible(QualType T1, QualType T2) const
const LangOptions & getLangOpts() const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange)
CheckCastAlign - Implements -Wcast-align, which warns when a pointer cast increases the alignment req...
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
const LangOptions & LangOpts
static const uint64_t MaximumAlignment
ExprResult ConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
ConvertVectorExpr - Handle __builtin_convertvector.
bool checkConstantPointerAuthKey(Expr *keyExpr, unsigned &key)
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx)
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
void popCodeSynthesisContext()
void DiagnoseMisalignedMembers()
Diagnoses the current set of gathered accesses.
sema::FunctionScopeInfo * getCurFunction() const
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
std::pair< const IdentifierInfo *, uint64_t > TypeTagMagicValue
A pair of ArgumentKind identifier and magic value.
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)
Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...
void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)
Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...
ExprResult DefaultLvalueConversion(Expr *E)
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
bool BuiltinVectorMath(CallExpr *TheCall, QualType &Res)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
FormatArgumentPassingKind
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ ACK_Comparison
A comparison.
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
bool isConstantEvaluatedContext() const
ExprResult BuiltinShuffleVector(CallExpr *TheCall)
BuiltinShuffleVector - Handle __builtin_shufflevector.
QualType GetSignedVectorType(QualType V)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceManager & SourceMgr
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
ExprResult BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder=AtomicArgumentOrder::API)
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto)
CheckFunctionCall - Check a direct function call for various correctness and safety properties not st...
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
unsigned getPresumedLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isWrittenInSameFile(SourceLocation Loc1, SourceLocation Loc2) const
Returns true if the spelling locations for both SourceLocations are part of the same file buffer.
unsigned getPresumedColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getLength() const
StringLiteralKind getKind() const
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
unsigned getByteLength() const
StringRef getString() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getCharByteWidth() const
Exposes information about the current target.
virtual bool validatePointerAuthKey(const llvm::APSInt &value) const
Determine whether the given pointer-authentication key is valid.
virtual bool supportsCpuSupports() const
virtual bool validateCpuIs(StringRef Name) const
virtual bool supportsCpuInit() const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
IntType getInt64Type() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
IntType getSizeType() const
IntType getIntPtrType() const
uint32_t getARMCDECoprocMask() const
For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.
virtual bool validateCpuSupports(StringRef Name) const
virtual bool supportsCpuIs() const
const llvm::fltSemantics & getLongDoubleFormat() const
virtual bool checkArithmeticFenceSupported() const
Controls if __arithmetic_fence is supported in the targeted backend.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool hasSjLjLowering() const
Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
@ Type
The template argument is a type.
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isFloat16Type() const
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isFunctionPointerType() const
bool isPointerType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isFloat32Type() const
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
const BuiltinType * getAsPlaceholderType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
QualType getCanonicalTypeInternal() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isAtomicType() const
bool isFunctionProtoType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isBFloat16Type() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isStructureOrClassType() const
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isSizelessVectorType() const
Returns true for all scalable vector types.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
SourceLocation getBeginLoc() const LLVM_READONLY
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
Represents a variable declaration or definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Represents a GCC generic vector type.
unsigned getNumElements() const
WhileStmt - This represents a 'while' stmt.
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
Defines the clang::TargetInfo interface.
__inline void unsigned int _2
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
ComparisonResult
Indicates the result of a tentative comparison.
uint32_t Literal
Literals are represented as positive integers.
uint32_t Variable
Boolean variables are represented as positive integers.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
@ After
Like System, but searched after the system directories.
@ FixIt
Parse and apply any fixits to the source.
bool GT(InterpState &S, CodePtr OpPC)
bool NE(InterpState &S, CodePtr OpPC)
bool LE(InterpState &S, CodePtr OpPC)
bool InRange(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
bool EQ(InterpState &S, CodePtr OpPC)
bool GE(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ NonNull
Values of this type can never be null.
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Result
The result type of a method or function.
LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
for(const auto &A :T->param_types())
const FunctionProtoType * T
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ Success
Template argument deduction was successful.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecVector
is AltiVec vector
@ Generic
not a target-specific vector type
U cast(CodeGen::Address addr)
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Other
Other implicit parameter.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Extra information about a function prototype.
unsigned AArch64SMEAttributes
Describes how types, statements, expressions, and declarations should be printed.
unsigned AnonymousTagLocations
When printing an anonymous tag name, also print the location of that entity (e.g.,...
unsigned Indentation
The number of spaces to use to indent each line.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
unsigned NumCallArgs
The number of expressions in CallArgs.
const Expr *const * CallArgs
The list of argument expressions in a synthesized call.
@ BuildingBuiltinDumpStructCall
We are building an implied call from __builtin_dump_struct.