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>())
3525 llvm::StringMap<bool> CallerFeatureMap;
3534 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3540 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3546 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3555 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZA());
3562 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZT0());
3566 switch (BuiltinID) {
3569#define GET_SME_BUILTIN_GET_STATE
3570#include "clang/Basic/arm_sme_builtins_za_state.inc"
3571#undef GET_SME_BUILTIN_GET_STATE
3575bool Sema::CheckSMEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3579 switch (BuiltinID) {
3580#define GET_SME_STREAMING_ATTRS
3581#include "clang/Basic/arm_sme_streaming_attrs.inc"
3582#undef GET_SME_STREAMING_ATTRS
3590 diag::warn_attribute_arm_za_builtin_no_za_state)
3595 diag::warn_attribute_arm_zt0_builtin_no_zt0_state)
3602 switch (BuiltinID) {
3605#define GET_SME_IMMEDIATE_CHECK
3606#include "clang/Basic/arm_sme_sema_rangechecks.inc"
3607#undef GET_SME_IMMEDIATE_CHECK
3610 return ParseSVEImmChecks(TheCall, ImmChecks);
3613bool Sema::CheckSVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3617 switch (BuiltinID) {
3618#define GET_SVE_STREAMING_ATTRS
3619#include "clang/Basic/arm_sve_streaming_attrs.inc"
3620#undef GET_SVE_STREAMING_ATTRS
3628 switch (BuiltinID) {
3631#define GET_SVE_IMMEDIATE_CHECK
3632#include "clang/Basic/arm_sve_sema_rangechecks.inc"
3633#undef GET_SVE_IMMEDIATE_CHECK
3636 return ParseSVEImmChecks(TheCall, ImmChecks);
3639bool Sema::CheckNeonBuiltinFunctionCall(
const TargetInfo &TI,
3640 unsigned BuiltinID,
CallExpr *TheCall) {
3643 switch (BuiltinID) {
3646#define GET_NEON_BUILTINS
3647#define TARGET_BUILTIN(id, ...) case NEON::BI##id:
3648#define BUILTIN(id, ...) case NEON::BI##id:
3649#include "clang/Basic/arm_neon.inc"
3652#undef TARGET_BUILTIN
3654#undef GET_NEON_BUILTINS
3662 bool HasConstPtr =
false;
3663 switch (BuiltinID) {
3664#define GET_NEON_OVERLOAD_CHECK
3665#include "clang/Basic/arm_neon.inc"
3666#include "clang/Basic/arm_fp16.inc"
3667#undef GET_NEON_OVERLOAD_CHECK
3674 if (BuiltinConstantArg(TheCall, ImmArg,
Result))
3677 TV =
Result.getLimitedValue(64);
3678 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3683 if (PtrArgNum >= 0) {
3687 Arg = ICE->getSubExpr();
3691 llvm::Triple::ArchType Arch = TI.
getTriple().getArch();
3692 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3693 Arch == llvm::Triple::aarch64_32 ||
3694 Arch == llvm::Triple::aarch64_be;
3712 unsigned i = 0, l = 0, u = 0;
3713 switch (BuiltinID) {
3716 #define GET_NEON_IMMEDIATE_CHECK
3717 #include "clang/Basic/arm_neon.inc"
3718 #include "clang/Basic/arm_fp16.inc"
3719 #undef GET_NEON_IMMEDIATE_CHECK
3722 return BuiltinConstantArgRange(TheCall, i, l, u + l);
3725bool Sema::CheckMVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3726 switch (BuiltinID) {
3729 #include "clang/Basic/arm_mve_builtin_sema.inc"
3733bool Sema::CheckCDEBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3736 switch (BuiltinID) {
3739#include "clang/Basic/arm_cde_builtin_sema.inc"
3745 return CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
true);
3748bool Sema::CheckARMCoprocessorImmediate(
const TargetInfo &TI,
3749 const Expr *CoprocArg,
bool WantCDE) {
3758 int64_t CoprocNo = CoprocNoAP.getExtValue();
3759 assert(CoprocNo >= 0 &&
"Coprocessor immediate must be non-negative");
3762 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3764 if (IsCDECoproc != WantCDE)
3771bool Sema::CheckARMBuiltinExclusiveCall(
unsigned BuiltinID,
CallExpr *TheCall,
3772 unsigned MaxWidth) {
3773 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3774 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3775 BuiltinID == ARM::BI__builtin_arm_strex ||
3776 BuiltinID == ARM::BI__builtin_arm_stlex ||
3777 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3778 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3779 BuiltinID == AArch64::BI__builtin_arm_strex ||
3780 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3781 "unexpected ARM builtin");
3782 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3783 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3784 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3785 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3797 Expr *PointerArg = TheCall->
getArg(IsLdrex ? 0 : 1);
3801 PointerArg = PointerArgRes.
get();
3821 CastNeeded = CK_BitCast;
3822 Diag(DRE->
getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3832 PointerArg = PointerArgRes.
get();
3834 TheCall->
setArg(IsLdrex ? 0 : 1, PointerArg);
3839 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3846 assert(MaxWidth == 64 &&
"Diagnostic unexpectedly inaccurate");
3847 Diag(DRE->
getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3886bool Sema::CheckARMBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3888 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3889 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3890 BuiltinID == ARM::BI__builtin_arm_strex ||
3891 BuiltinID == ARM::BI__builtin_arm_stlex) {
3892 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3895 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3896 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3897 BuiltinConstantArgRange(TheCall, 2, 0, 1);
3900 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3901 BuiltinID == ARM::BI__builtin_arm_wsr64)
3902 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3,
false);
3904 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3905 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3906 BuiltinID == ARM::BI__builtin_arm_wsr ||
3907 BuiltinID == ARM::BI__builtin_arm_wsrp)
3908 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3910 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3912 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3914 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3920 switch (BuiltinID) {
3921 default:
return false;
3922 case ARM::BI__builtin_arm_ssat:
3923 return BuiltinConstantArgRange(TheCall, 1, 1, 32);
3924 case ARM::BI__builtin_arm_usat:
3925 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
3926 case ARM::BI__builtin_arm_ssat16:
3927 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
3928 case ARM::BI__builtin_arm_usat16:
3929 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
3930 case ARM::BI__builtin_arm_vcvtr_f:
3931 case ARM::BI__builtin_arm_vcvtr_d:
3932 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
3933 case ARM::BI__builtin_arm_dmb:
3934 case ARM::BI__builtin_arm_dsb:
3935 case ARM::BI__builtin_arm_isb:
3936 case ARM::BI__builtin_arm_dbg:
3937 return BuiltinConstantArgRange(TheCall, 0, 0, 15);
3938 case ARM::BI__builtin_arm_cdp:
3939 case ARM::BI__builtin_arm_cdp2:
3940 case ARM::BI__builtin_arm_mcr:
3941 case ARM::BI__builtin_arm_mcr2:
3942 case ARM::BI__builtin_arm_mrc:
3943 case ARM::BI__builtin_arm_mrc2:
3944 case ARM::BI__builtin_arm_mcrr:
3945 case ARM::BI__builtin_arm_mcrr2:
3946 case ARM::BI__builtin_arm_mrrc:
3947 case ARM::BI__builtin_arm_mrrc2:
3948 case ARM::BI__builtin_arm_ldc:
3949 case ARM::BI__builtin_arm_ldcl:
3950 case ARM::BI__builtin_arm_ldc2:
3951 case ARM::BI__builtin_arm_ldc2l:
3952 case ARM::BI__builtin_arm_stc:
3953 case ARM::BI__builtin_arm_stcl:
3954 case ARM::BI__builtin_arm_stc2:
3955 case ARM::BI__builtin_arm_stc2l:
3956 return BuiltinConstantArgRange(TheCall, 0, 0, 15) ||
3957 CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
3962bool Sema::CheckAArch64BuiltinFunctionCall(
const TargetInfo &TI,
3965 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3966 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3967 BuiltinID == AArch64::BI__builtin_arm_strex ||
3968 BuiltinID == AArch64::BI__builtin_arm_stlex) {
3969 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
3972 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
3973 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3974 BuiltinConstantArgRange(TheCall, 2, 0, 3) ||
3975 BuiltinConstantArgRange(TheCall, 3, 0, 1) ||
3976 BuiltinConstantArgRange(TheCall, 4, 0, 1);
3979 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
3980 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
3981 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
3982 BuiltinID == AArch64::BI__builtin_arm_wsr128)
3983 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3986 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
3987 BuiltinID == AArch64::BI__builtin_arm_addg ||
3988 BuiltinID == AArch64::BI__builtin_arm_gmi ||
3989 BuiltinID == AArch64::BI__builtin_arm_ldg ||
3990 BuiltinID == AArch64::BI__builtin_arm_stg ||
3991 BuiltinID == AArch64::BI__builtin_arm_subp) {
3992 return BuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
3995 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
3996 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
3997 BuiltinID == AArch64::BI__builtin_arm_wsr ||
3998 BuiltinID == AArch64::BI__builtin_arm_wsrp)
3999 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
4004 if (BuiltinID == AArch64::BI_ReadStatusReg ||
4005 BuiltinID == AArch64::BI_WriteStatusReg)
4006 return BuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
4008 if (BuiltinID == AArch64::BI__getReg)
4009 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
4011 if (BuiltinID == AArch64::BI__break)
4012 return BuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
4014 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
4017 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
4020 if (CheckSMEBuiltinFunctionCall(BuiltinID, TheCall))
4025 unsigned i = 0, l = 0, u = 0;
4026 switch (BuiltinID) {
4027 default:
return false;
4028 case AArch64::BI__builtin_arm_dmb:
4029 case AArch64::BI__builtin_arm_dsb:
4030 case AArch64::BI__builtin_arm_isb: l = 0; u = 15;
break;
4031 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535;
break;
4034 return BuiltinConstantArgRange(TheCall, i, l, u + l);
4071 if (!RT->getDecl()->getDeclName().isEmpty())
4074 if (!ET->getDecl()->getDeclName().isEmpty())
4090 const auto *UO = dyn_cast<UnaryOperator>(Arg->
IgnoreParens());
4094 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
4097 if (CE->getCastKind() != CK_IntegralToPointer &&
4098 CE->getCastKind() != CK_NullToPointer)
4102 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
4107 dyn_cast<EnumConstantDecl>(DR->getDecl());
4118 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
4121bool Sema::CheckBPFBuiltinFunctionCall(
unsigned BuiltinID,
4123 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
4124 BuiltinID == BPF::BI__builtin_btf_type_id ||
4125 BuiltinID == BPF::BI__builtin_preserve_type_info ||
4126 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
4127 "unexpected BPF builtin");
4137 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
4138 kind = diag::err_preserve_field_info_not_const;
4139 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
4140 kind = diag::err_btf_type_id_not_const;
4141 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
4142 kind = diag::err_preserve_type_info_not_const;
4144 kind = diag::err_preserve_enum_value_not_const;
4150 Arg = TheCall->
getArg(0);
4151 bool InvalidArg =
false;
4152 bool ReturnUnsignedInt =
true;
4153 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
4156 kind = diag::err_preserve_field_info_not_field;
4158 }
else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
4161 kind = diag::err_preserve_type_info_invalid;
4163 }
else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
4166 kind = diag::err_preserve_enum_value_invalid;
4168 ReturnUnsignedInt =
false;
4169 }
else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
4170 ReturnUnsignedInt =
false;
4178 if (ReturnUnsignedInt)
4185bool Sema::CheckHexagonBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4198 { Hexagon::BI__builtin_circ_ldd, {{ 3,
true, 4, 3 }} },
4199 { Hexagon::BI__builtin_circ_ldw, {{ 3,
true, 4, 2 }} },
4200 { Hexagon::BI__builtin_circ_ldh, {{ 3,
true, 4, 1 }} },
4201 { Hexagon::BI__builtin_circ_lduh, {{ 3,
true, 4, 1 }} },
4202 { Hexagon::BI__builtin_circ_ldb, {{ 3,
true, 4, 0 }} },
4203 { Hexagon::BI__builtin_circ_ldub, {{ 3,
true, 4, 0 }} },
4204 { Hexagon::BI__builtin_circ_std, {{ 3,
true, 4, 3 }} },
4205 { Hexagon::BI__builtin_circ_stw, {{ 3,
true, 4, 2 }} },
4206 { Hexagon::BI__builtin_circ_sth, {{ 3,
true, 4, 1 }} },
4207 { Hexagon::BI__builtin_circ_sthhi, {{ 3,
true, 4, 1 }} },
4208 { Hexagon::BI__builtin_circ_stb, {{ 3,
true, 4, 0 }} },
4210 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1,
true, 4, 0 }} },
4211 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1,
true, 4, 0 }} },
4212 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1,
true, 4, 1 }} },
4213 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1,
true, 4, 1 }} },
4214 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1,
true, 4, 2 }} },
4215 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1,
true, 4, 3 }} },
4216 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1,
true, 4, 0 }} },
4217 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1,
true, 4, 1 }} },
4218 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1,
true, 4, 1 }} },
4219 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1,
true, 4, 2 }} },
4220 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1,
true, 4, 3 }} },
4222 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1,
true, 8, 0 }} },
4223 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1,
false, 16, 0 }} },
4224 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1,
false, 16, 0 }} },
4225 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0,
true, 8, 0 }} },
4226 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1,
false, 5, 0 }} },
4227 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1,
false, 8, 0 }} },
4228 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1,
true, 8, 0 }} },
4229 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1,
false, 5, 0 }} },
4230 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1,
false, 5, 0 }} },
4231 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1,
false, 5, 0 }} },
4232 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1,
false, 8, 0 }} },
4233 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1,
true, 8, 0 }} },
4234 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1,
false, 7, 0 }} },
4235 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1,
true, 8, 0 }} },
4236 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1,
true, 8, 0 }} },
4237 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1,
false, 7, 0 }} },
4238 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1,
true, 8, 0 }} },
4239 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1,
true, 8, 0 }} },
4240 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1,
false, 7, 0 }} },
4241 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1,
false, 6, 0 }} },
4242 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2,
true, 8, 0 }} },
4243 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1,
false, 6, 0 }} },
4244 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1,
false, 5, 0 }} },
4245 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0,
false, 10, 0 }} },
4246 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0,
false, 10, 0 }} },
4247 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1,
false, 5, 0 }} },
4248 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0,
false, 10, 0 }} },
4249 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0,
false, 10, 0 }} },
4250 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2,
false, 6, 0 }} },
4251 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1,
false, 6, 2 }} },
4252 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2,
false, 3, 0 }} },
4253 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2,
false, 6, 0 }} },
4254 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2,
false, 6, 0 }} },
4255 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1,
false, 6, 0 }} },
4256 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2,
false, 6, 0 }} },
4257 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2,
false, 6, 0 }} },
4258 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2,
false, 6, 0 }} },
4259 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2,
false, 5, 0 }} },
4260 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2,
false, 5, 0 }} },
4261 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1,
false, 5, 0 }} },
4262 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2,
false, 5, 0 }} },
4263 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2,
false, 5, 0 }} },
4264 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1,
false, 5, 0 }} },
4265 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2,
false, 5, 0 }} },
4266 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1,
false, 4, 0 }} },
4267 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1,
false, 5, 0 }} },
4268 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2,
false, 6, 0 }} },
4269 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2,
false, 6, 0 }} },
4270 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1,
false, 6, 0 }} },
4271 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2,
false, 6, 0 }} },
4272 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2,
false, 6, 0 }} },
4273 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
4274 {{ 1,
false, 6, 0 }} },
4275 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1,
false, 6, 0 }} },
4276 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2,
false, 5, 0 }} },
4277 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2,
false, 5, 0 }} },
4278 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1,
false, 5, 0 }} },
4279 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2,
false, 5, 0 }} },
4280 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2,
false, 5, 0 }} },
4281 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
4282 {{ 1,
false, 5, 0 }} },
4283 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1,
false, 5, 0 }} },
4284 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1,
false, 5, 0 }} },
4285 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1,
false, 4, 0 }} },
4286 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1,
false, 5, 0 }} },
4287 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1,
false, 5, 0 }} },
4288 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1,
false, 5, 0 },
4289 { 2,
false, 5, 0 }} },
4290 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1,
false, 6, 0 },
4291 { 2,
false, 6, 0 }} },
4292 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2,
false, 5, 0 },
4293 { 3,
false, 5, 0 }} },
4294 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2,
false, 6, 0 },
4295 { 3,
false, 6, 0 }} },
4296 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2,
false, 6, 0 }} },
4297 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2,
false, 6, 0 }} },
4298 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1,
false, 6, 0 }} },
4299 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2,
false, 6, 0 }} },
4300 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2,
false, 6, 0 }} },
4301 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2,
false, 6, 0 }} },
4302 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2,
false, 5, 0 }} },
4303 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2,
false, 5, 0 }} },
4304 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1,
false, 5, 0 }} },
4305 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2,
false, 5, 0 }} },
4306 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2,
false, 5, 0 }} },
4307 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2,
false, 5, 0 }} },
4308 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1,
false, 4, 0 }} },
4309 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1,
false, 5, 0 }} },
4310 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1,
false, 5, 0 }} },
4311 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
4312 {{ 2,
false, 4, 0 },
4313 { 3,
false, 5, 0 }} },
4314 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
4315 {{ 2,
false, 4, 0 },
4316 { 3,
false, 5, 0 }} },
4317 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
4318 {{ 2,
false, 4, 0 },
4319 { 3,
false, 5, 0 }} },
4320 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
4321 {{ 2,
false, 4, 0 },
4322 { 3,
false, 5, 0 }} },
4323 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1,
false, 5, 0 }} },
4324 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1,
false, 5, 0 }} },
4325 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2,
false, 3, 0 }} },
4326 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2,
false, 3, 0 }} },
4327 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2,
false, 5, 0 }} },
4328 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2,
false, 5, 0 }} },
4329 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2,
false, 5, 0 }} },
4330 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2,
false, 5, 0 }} },
4331 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1,
true , 6, 0 }} },
4332 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1,
true, 6, 0 }} },
4333 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1,
false, 5, 0 },
4334 { 2,
false, 5, 0 }} },
4335 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1,
false, 6, 0 },
4336 { 2,
false, 6, 0 }} },
4337 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0,
true, 6, 0 }} },
4338 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1,
false, 5, 0 }} },
4339 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2,
false, 5, 0 }} },
4340 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2,
false, 5, 0 }} },
4341 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2,
false, 5, 0 }} },
4342 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2,
false, 5, 0 }} },
4343 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3,
false, 2, 0 }} },
4344 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2,
false, 2, 0 }} },
4345 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
4346 {{ 1,
false, 4, 0 }} },
4347 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1,
false, 4, 0 }} },
4348 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
4349 {{ 1,
false, 4, 0 }} },
4350 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1,
false, 6, 0 }} },
4351 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2,
false, 6, 0 }} },
4352 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2,
false, 6, 0 }} },
4353 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2,
false, 6, 0 }} },
4354 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2,
false, 6, 0 }} },
4355 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2,
false, 6, 0 }} },
4356 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1,
false, 5, 0 }} },
4357 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2,
false, 5, 0 }} },
4358 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2,
false, 5, 0 }} },
4359 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2,
false, 5, 0 }} },
4360 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2,
false, 5, 0 }} },
4361 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2,
false, 5, 0 }} },
4362 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2,
false, 3, 0 }} },
4363 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2,
false, 3, 0 }} },
4364 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2,
false, 3, 0 }} },
4365 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2,
false, 3, 0 }} },
4366 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2,
false, 1, 0 }} },
4367 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2,
false, 1, 0 }} },
4368 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3,
false, 1, 0 }} },
4369 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
4370 {{ 3,
false, 1, 0 }} },
4371 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2,
false, 1, 0 }} },
4372 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2,
false, 1, 0 }} },
4373 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3,
false, 1, 0 }} },
4374 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
4375 {{ 3,
false, 1, 0 }} },
4376 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2,
false, 1, 0 }} },
4377 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2,
false, 1, 0 }} },
4378 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3,
false, 1, 0 }} },
4379 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
4380 {{ 3,
false, 1, 0 }} },
4382 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2,
false, 2, 0 }} },
4383 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
4384 {{ 2,
false, 2, 0 }} },
4385 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
4386 {{ 3,
false, 2, 0 }} },
4387 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
4388 {{ 3,
false, 2, 0 }} },
4389 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2,
false, 2, 0 }} },
4390 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
4391 {{ 2,
false, 2, 0 }} },
4392 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
4393 {{ 3,
false, 2, 0 }} },
4394 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
4395 {{ 3,
false, 2, 0 }} },
4396 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2,
false, 3, 0 }} },
4397 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2,
false, 3, 0 }} },
4398 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3,
false, 3, 0 }} },
4399 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
4400 {{ 3,
false, 3, 0 }} },
4401 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2,
false, 3, 0 }} },
4402 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2,
false, 3, 0 }} },
4403 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3,
false, 3, 0 }} },
4404 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
4405 {{ 3,
false, 3, 0 }} },
4410 static const bool SortOnce =
4413 return LHS.BuiltinID < RHS.BuiltinID;
4419 Infos, [=](
const BuiltinInfo &BI) {
return BI.BuiltinID < BuiltinID; });
4420 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
4425 for (
const ArgInfo &A : F->Infos) {
4427 if (A.BitWidth == 0)
4430 int32_t
Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
4431 int32_t
Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
4433 Error |= BuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4435 unsigned M = 1 << A.Align;
4438 Error |= BuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4439 Error |= BuiltinConstantArgMultiple(TheCall, A.OpNum, M);
4445bool Sema::CheckHexagonBuiltinFunctionCall(
unsigned BuiltinID,
4447 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
4450bool Sema::CheckLoongArchBuiltinFunctionCall(
const TargetInfo &TI,
4453 switch (BuiltinID) {
4457 case LoongArch::BI__builtin_loongarch_cacop_d:
4458 case LoongArch::BI__builtin_loongarch_cacop_w: {
4459 BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
4460 BuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12), llvm::maxIntN(12));
4463 case LoongArch::BI__builtin_loongarch_break:
4464 case LoongArch::BI__builtin_loongarch_dbar:
4465 case LoongArch::BI__builtin_loongarch_ibar:
4466 case LoongArch::BI__builtin_loongarch_syscall:
4468 return BuiltinConstantArgRange(TheCall, 0, 0, 32767);
4469 case LoongArch::BI__builtin_loongarch_csrrd_w:
4470 case LoongArch::BI__builtin_loongarch_csrrd_d:
4471 return BuiltinConstantArgRange(TheCall, 0, 0, 16383);
4472 case LoongArch::BI__builtin_loongarch_csrwr_w:
4473 case LoongArch::BI__builtin_loongarch_csrwr_d:
4474 return BuiltinConstantArgRange(TheCall, 1, 0, 16383);
4475 case LoongArch::BI__builtin_loongarch_csrxchg_w:
4476 case LoongArch::BI__builtin_loongarch_csrxchg_d:
4477 return BuiltinConstantArgRange(TheCall, 2, 0, 16383);
4478 case LoongArch::BI__builtin_loongarch_lddir_d:
4479 case LoongArch::BI__builtin_loongarch_ldpte_d:
4480 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4481 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
4482 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
4483 return BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
4486 case LoongArch::BI__builtin_lsx_vbitclri_b:
4487 case LoongArch::BI__builtin_lsx_vbitrevi_b:
4488 case LoongArch::BI__builtin_lsx_vbitseti_b:
4489 case LoongArch::BI__builtin_lsx_vsat_b:
4490 case LoongArch::BI__builtin_lsx_vsat_bu:
4491 case LoongArch::BI__builtin_lsx_vslli_b:
4492 case LoongArch::BI__builtin_lsx_vsrai_b:
4493 case LoongArch::BI__builtin_lsx_vsrari_b:
4494 case LoongArch::BI__builtin_lsx_vsrli_b:
4495 case LoongArch::BI__builtin_lsx_vsllwil_h_b:
4496 case LoongArch::BI__builtin_lsx_vsllwil_hu_bu:
4497 case LoongArch::BI__builtin_lsx_vrotri_b:
4498 case LoongArch::BI__builtin_lsx_vsrlri_b:
4499 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4500 case LoongArch::BI__builtin_lsx_vbitclri_h:
4501 case LoongArch::BI__builtin_lsx_vbitrevi_h:
4502 case LoongArch::BI__builtin_lsx_vbitseti_h:
4503 case LoongArch::BI__builtin_lsx_vsat_h:
4504 case LoongArch::BI__builtin_lsx_vsat_hu:
4505 case LoongArch::BI__builtin_lsx_vslli_h:
4506 case LoongArch::BI__builtin_lsx_vsrai_h:
4507 case LoongArch::BI__builtin_lsx_vsrari_h:
4508 case LoongArch::BI__builtin_lsx_vsrli_h:
4509 case LoongArch::BI__builtin_lsx_vsllwil_w_h:
4510 case LoongArch::BI__builtin_lsx_vsllwil_wu_hu:
4511 case LoongArch::BI__builtin_lsx_vrotri_h:
4512 case LoongArch::BI__builtin_lsx_vsrlri_h:
4513 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4514 case LoongArch::BI__builtin_lsx_vssrarni_b_h:
4515 case LoongArch::BI__builtin_lsx_vssrarni_bu_h:
4516 case LoongArch::BI__builtin_lsx_vssrani_b_h:
4517 case LoongArch::BI__builtin_lsx_vssrani_bu_h:
4518 case LoongArch::BI__builtin_lsx_vsrarni_b_h:
4519 case LoongArch::BI__builtin_lsx_vsrlni_b_h:
4520 case LoongArch::BI__builtin_lsx_vsrlrni_b_h:
4521 case LoongArch::BI__builtin_lsx_vssrlni_b_h:
4522 case LoongArch::BI__builtin_lsx_vssrlni_bu_h:
4523 case LoongArch::BI__builtin_lsx_vssrlrni_b_h:
4524 case LoongArch::BI__builtin_lsx_vssrlrni_bu_h:
4525 case LoongArch::BI__builtin_lsx_vsrani_b_h:
4526 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4527 case LoongArch::BI__builtin_lsx_vslei_bu:
4528 case LoongArch::BI__builtin_lsx_vslei_hu:
4529 case LoongArch::BI__builtin_lsx_vslei_wu:
4530 case LoongArch::BI__builtin_lsx_vslei_du:
4531 case LoongArch::BI__builtin_lsx_vslti_bu:
4532 case LoongArch::BI__builtin_lsx_vslti_hu:
4533 case LoongArch::BI__builtin_lsx_vslti_wu:
4534 case LoongArch::BI__builtin_lsx_vslti_du:
4535 case LoongArch::BI__builtin_lsx_vmaxi_bu:
4536 case LoongArch::BI__builtin_lsx_vmaxi_hu:
4537 case LoongArch::BI__builtin_lsx_vmaxi_wu:
4538 case LoongArch::BI__builtin_lsx_vmaxi_du:
4539 case LoongArch::BI__builtin_lsx_vmini_bu:
4540 case LoongArch::BI__builtin_lsx_vmini_hu:
4541 case LoongArch::BI__builtin_lsx_vmini_wu:
4542 case LoongArch::BI__builtin_lsx_vmini_du:
4543 case LoongArch::BI__builtin_lsx_vaddi_bu:
4544 case LoongArch::BI__builtin_lsx_vaddi_hu:
4545 case LoongArch::BI__builtin_lsx_vaddi_wu:
4546 case LoongArch::BI__builtin_lsx_vaddi_du:
4547 case LoongArch::BI__builtin_lsx_vbitclri_w:
4548 case LoongArch::BI__builtin_lsx_vbitrevi_w:
4549 case LoongArch::BI__builtin_lsx_vbitseti_w:
4550 case LoongArch::BI__builtin_lsx_vsat_w:
4551 case LoongArch::BI__builtin_lsx_vsat_wu:
4552 case LoongArch::BI__builtin_lsx_vslli_w:
4553 case LoongArch::BI__builtin_lsx_vsrai_w:
4554 case LoongArch::BI__builtin_lsx_vsrari_w:
4555 case LoongArch::BI__builtin_lsx_vsrli_w:
4556 case LoongArch::BI__builtin_lsx_vsllwil_d_w:
4557 case LoongArch::BI__builtin_lsx_vsllwil_du_wu:
4558 case LoongArch::BI__builtin_lsx_vsrlri_w:
4559 case LoongArch::BI__builtin_lsx_vrotri_w:
4560 case LoongArch::BI__builtin_lsx_vsubi_bu:
4561 case LoongArch::BI__builtin_lsx_vsubi_hu:
4562 case LoongArch::BI__builtin_lsx_vbsrl_v:
4563 case LoongArch::BI__builtin_lsx_vbsll_v:
4564 case LoongArch::BI__builtin_lsx_vsubi_wu:
4565 case LoongArch::BI__builtin_lsx_vsubi_du:
4566 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4567 case LoongArch::BI__builtin_lsx_vssrarni_h_w:
4568 case LoongArch::BI__builtin_lsx_vssrarni_hu_w:
4569 case LoongArch::BI__builtin_lsx_vssrani_h_w:
4570 case LoongArch::BI__builtin_lsx_vssrani_hu_w:
4571 case LoongArch::BI__builtin_lsx_vsrarni_h_w:
4572 case LoongArch::BI__builtin_lsx_vsrani_h_w:
4573 case LoongArch::BI__builtin_lsx_vfrstpi_b:
4574 case LoongArch::BI__builtin_lsx_vfrstpi_h:
4575 case LoongArch::BI__builtin_lsx_vsrlni_h_w:
4576 case LoongArch::BI__builtin_lsx_vsrlrni_h_w:
4577 case LoongArch::BI__builtin_lsx_vssrlni_h_w:
4578 case LoongArch::BI__builtin_lsx_vssrlni_hu_w:
4579 case LoongArch::BI__builtin_lsx_vssrlrni_h_w:
4580 case LoongArch::BI__builtin_lsx_vssrlrni_hu_w:
4581 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4582 case LoongArch::BI__builtin_lsx_vbitclri_d:
4583 case LoongArch::BI__builtin_lsx_vbitrevi_d:
4584 case LoongArch::BI__builtin_lsx_vbitseti_d:
4585 case LoongArch::BI__builtin_lsx_vsat_d:
4586 case LoongArch::BI__builtin_lsx_vsat_du:
4587 case LoongArch::BI__builtin_lsx_vslli_d:
4588 case LoongArch::BI__builtin_lsx_vsrai_d:
4589 case LoongArch::BI__builtin_lsx_vsrli_d:
4590 case LoongArch::BI__builtin_lsx_vsrari_d:
4591 case LoongArch::BI__builtin_lsx_vrotri_d:
4592 case LoongArch::BI__builtin_lsx_vsrlri_d:
4593 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4594 case LoongArch::BI__builtin_lsx_vssrarni_w_d:
4595 case LoongArch::BI__builtin_lsx_vssrarni_wu_d:
4596 case LoongArch::BI__builtin_lsx_vssrani_w_d:
4597 case LoongArch::BI__builtin_lsx_vssrani_wu_d:
4598 case LoongArch::BI__builtin_lsx_vsrarni_w_d:
4599 case LoongArch::BI__builtin_lsx_vsrlni_w_d:
4600 case LoongArch::BI__builtin_lsx_vsrlrni_w_d:
4601 case LoongArch::BI__builtin_lsx_vssrlni_w_d:
4602 case LoongArch::BI__builtin_lsx_vssrlni_wu_d:
4603 case LoongArch::BI__builtin_lsx_vssrlrni_w_d:
4604 case LoongArch::BI__builtin_lsx_vssrlrni_wu_d:
4605 case LoongArch::BI__builtin_lsx_vsrani_w_d:
4606 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4607 case LoongArch::BI__builtin_lsx_vssrarni_d_q:
4608 case LoongArch::BI__builtin_lsx_vssrarni_du_q:
4609 case LoongArch::BI__builtin_lsx_vssrani_d_q:
4610 case LoongArch::BI__builtin_lsx_vssrani_du_q:
4611 case LoongArch::BI__builtin_lsx_vsrarni_d_q:
4612 case LoongArch::BI__builtin_lsx_vssrlni_d_q:
4613 case LoongArch::BI__builtin_lsx_vssrlni_du_q:
4614 case LoongArch::BI__builtin_lsx_vssrlrni_d_q:
4615 case LoongArch::BI__builtin_lsx_vssrlrni_du_q:
4616 case LoongArch::BI__builtin_lsx_vsrani_d_q:
4617 case LoongArch::BI__builtin_lsx_vsrlrni_d_q:
4618 case LoongArch::BI__builtin_lsx_vsrlni_d_q:
4619 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4620 case LoongArch::BI__builtin_lsx_vseqi_b:
4621 case LoongArch::BI__builtin_lsx_vseqi_h:
4622 case LoongArch::BI__builtin_lsx_vseqi_w:
4623 case LoongArch::BI__builtin_lsx_vseqi_d:
4624 case LoongArch::BI__builtin_lsx_vslti_b:
4625 case LoongArch::BI__builtin_lsx_vslti_h:
4626 case LoongArch::BI__builtin_lsx_vslti_w:
4627 case LoongArch::BI__builtin_lsx_vslti_d:
4628 case LoongArch::BI__builtin_lsx_vslei_b:
4629 case LoongArch::BI__builtin_lsx_vslei_h:
4630 case LoongArch::BI__builtin_lsx_vslei_w:
4631 case LoongArch::BI__builtin_lsx_vslei_d:
4632 case LoongArch::BI__builtin_lsx_vmaxi_b:
4633 case LoongArch::BI__builtin_lsx_vmaxi_h:
4634 case LoongArch::BI__builtin_lsx_vmaxi_w:
4635 case LoongArch::BI__builtin_lsx_vmaxi_d:
4636 case LoongArch::BI__builtin_lsx_vmini_b:
4637 case LoongArch::BI__builtin_lsx_vmini_h:
4638 case LoongArch::BI__builtin_lsx_vmini_w:
4639 case LoongArch::BI__builtin_lsx_vmini_d:
4640 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4641 case LoongArch::BI__builtin_lsx_vandi_b:
4642 case LoongArch::BI__builtin_lsx_vnori_b:
4643 case LoongArch::BI__builtin_lsx_vori_b:
4644 case LoongArch::BI__builtin_lsx_vshuf4i_b:
4645 case LoongArch::BI__builtin_lsx_vshuf4i_h:
4646 case LoongArch::BI__builtin_lsx_vshuf4i_w:
4647 case LoongArch::BI__builtin_lsx_vxori_b:
4648 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4649 case LoongArch::BI__builtin_lsx_vbitseli_b:
4650 case LoongArch::BI__builtin_lsx_vshuf4i_d:
4651 case LoongArch::BI__builtin_lsx_vextrins_b:
4652 case LoongArch::BI__builtin_lsx_vextrins_h:
4653 case LoongArch::BI__builtin_lsx_vextrins_w:
4654 case LoongArch::BI__builtin_lsx_vextrins_d:
4655 case LoongArch::BI__builtin_lsx_vpermi_w:
4656 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4657 case LoongArch::BI__builtin_lsx_vpickve2gr_b:
4658 case LoongArch::BI__builtin_lsx_vpickve2gr_bu:
4659 case LoongArch::BI__builtin_lsx_vreplvei_b:
4660 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4661 case LoongArch::BI__builtin_lsx_vinsgr2vr_b:
4662 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4663 case LoongArch::BI__builtin_lsx_vpickve2gr_h:
4664 case LoongArch::BI__builtin_lsx_vpickve2gr_hu:
4665 case LoongArch::BI__builtin_lsx_vreplvei_h:
4666 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4667 case LoongArch::BI__builtin_lsx_vinsgr2vr_h:
4668 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4669 case LoongArch::BI__builtin_lsx_vpickve2gr_w:
4670 case LoongArch::BI__builtin_lsx_vpickve2gr_wu:
4671 case LoongArch::BI__builtin_lsx_vreplvei_w:
4672 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4673 case LoongArch::BI__builtin_lsx_vinsgr2vr_w:
4674 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4675 case LoongArch::BI__builtin_lsx_vpickve2gr_d:
4676 case LoongArch::BI__builtin_lsx_vpickve2gr_du:
4677 case LoongArch::BI__builtin_lsx_vreplvei_d:
4678 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4679 case LoongArch::BI__builtin_lsx_vinsgr2vr_d:
4680 return BuiltinConstantArgRange(TheCall, 2, 0, 1);
4681 case LoongArch::BI__builtin_lsx_vstelm_b:
4682 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4683 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4684 case LoongArch::BI__builtin_lsx_vstelm_h:
4685 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4686 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4687 case LoongArch::BI__builtin_lsx_vstelm_w:
4688 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4689 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4690 case LoongArch::BI__builtin_lsx_vstelm_d:
4691 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4692 BuiltinConstantArgRange(TheCall, 3, 0, 1);
4693 case LoongArch::BI__builtin_lsx_vldrepl_b:
4694 case LoongArch::BI__builtin_lsx_vld:
4695 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4696 case LoongArch::BI__builtin_lsx_vldrepl_h:
4697 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4698 case LoongArch::BI__builtin_lsx_vldrepl_w:
4699 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4700 case LoongArch::BI__builtin_lsx_vldrepl_d:
4701 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4702 case LoongArch::BI__builtin_lsx_vst:
4703 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4704 case LoongArch::BI__builtin_lsx_vldi:
4705 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4706 case LoongArch::BI__builtin_lsx_vrepli_b:
4707 case LoongArch::BI__builtin_lsx_vrepli_h:
4708 case LoongArch::BI__builtin_lsx_vrepli_w:
4709 case LoongArch::BI__builtin_lsx_vrepli_d:
4710 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4713 case LoongArch::BI__builtin_lasx_xvbitclri_b:
4714 case LoongArch::BI__builtin_lasx_xvbitrevi_b:
4715 case LoongArch::BI__builtin_lasx_xvbitseti_b:
4716 case LoongArch::BI__builtin_lasx_xvsat_b:
4717 case LoongArch::BI__builtin_lasx_xvsat_bu:
4718 case LoongArch::BI__builtin_lasx_xvslli_b:
4719 case LoongArch::BI__builtin_lasx_xvsrai_b:
4720 case LoongArch::BI__builtin_lasx_xvsrari_b:
4721 case LoongArch::BI__builtin_lasx_xvsrli_b:
4722 case LoongArch::BI__builtin_lasx_xvsllwil_h_b:
4723 case LoongArch::BI__builtin_lasx_xvsllwil_hu_bu:
4724 case LoongArch::BI__builtin_lasx_xvrotri_b:
4725 case LoongArch::BI__builtin_lasx_xvsrlri_b:
4726 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4727 case LoongArch::BI__builtin_lasx_xvbitclri_h:
4728 case LoongArch::BI__builtin_lasx_xvbitrevi_h:
4729 case LoongArch::BI__builtin_lasx_xvbitseti_h:
4730 case LoongArch::BI__builtin_lasx_xvsat_h:
4731 case LoongArch::BI__builtin_lasx_xvsat_hu:
4732 case LoongArch::BI__builtin_lasx_xvslli_h:
4733 case LoongArch::BI__builtin_lasx_xvsrai_h:
4734 case LoongArch::BI__builtin_lasx_xvsrari_h:
4735 case LoongArch::BI__builtin_lasx_xvsrli_h:
4736 case LoongArch::BI__builtin_lasx_xvsllwil_w_h:
4737 case LoongArch::BI__builtin_lasx_xvsllwil_wu_hu:
4738 case LoongArch::BI__builtin_lasx_xvrotri_h:
4739 case LoongArch::BI__builtin_lasx_xvsrlri_h:
4740 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4741 case LoongArch::BI__builtin_lasx_xvssrarni_b_h:
4742 case LoongArch::BI__builtin_lasx_xvssrarni_bu_h:
4743 case LoongArch::BI__builtin_lasx_xvssrani_b_h:
4744 case LoongArch::BI__builtin_lasx_xvssrani_bu_h:
4745 case LoongArch::BI__builtin_lasx_xvsrarni_b_h:
4746 case LoongArch::BI__builtin_lasx_xvsrlni_b_h:
4747 case LoongArch::BI__builtin_lasx_xvsrlrni_b_h:
4748 case LoongArch::BI__builtin_lasx_xvssrlni_b_h:
4749 case LoongArch::BI__builtin_lasx_xvssrlni_bu_h:
4750 case LoongArch::BI__builtin_lasx_xvssrlrni_b_h:
4751 case LoongArch::BI__builtin_lasx_xvssrlrni_bu_h:
4752 case LoongArch::BI__builtin_lasx_xvsrani_b_h:
4753 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4754 case LoongArch::BI__builtin_lasx_xvslei_bu:
4755 case LoongArch::BI__builtin_lasx_xvslei_hu:
4756 case LoongArch::BI__builtin_lasx_xvslei_wu:
4757 case LoongArch::BI__builtin_lasx_xvslei_du:
4758 case LoongArch::BI__builtin_lasx_xvslti_bu:
4759 case LoongArch::BI__builtin_lasx_xvslti_hu:
4760 case LoongArch::BI__builtin_lasx_xvslti_wu:
4761 case LoongArch::BI__builtin_lasx_xvslti_du:
4762 case LoongArch::BI__builtin_lasx_xvmaxi_bu:
4763 case LoongArch::BI__builtin_lasx_xvmaxi_hu:
4764 case LoongArch::BI__builtin_lasx_xvmaxi_wu:
4765 case LoongArch::BI__builtin_lasx_xvmaxi_du:
4766 case LoongArch::BI__builtin_lasx_xvmini_bu:
4767 case LoongArch::BI__builtin_lasx_xvmini_hu:
4768 case LoongArch::BI__builtin_lasx_xvmini_wu:
4769 case LoongArch::BI__builtin_lasx_xvmini_du:
4770 case LoongArch::BI__builtin_lasx_xvaddi_bu:
4771 case LoongArch::BI__builtin_lasx_xvaddi_hu:
4772 case LoongArch::BI__builtin_lasx_xvaddi_wu:
4773 case LoongArch::BI__builtin_lasx_xvaddi_du:
4774 case LoongArch::BI__builtin_lasx_xvbitclri_w:
4775 case LoongArch::BI__builtin_lasx_xvbitrevi_w:
4776 case LoongArch::BI__builtin_lasx_xvbitseti_w:
4777 case LoongArch::BI__builtin_lasx_xvsat_w:
4778 case LoongArch::BI__builtin_lasx_xvsat_wu:
4779 case LoongArch::BI__builtin_lasx_xvslli_w:
4780 case LoongArch::BI__builtin_lasx_xvsrai_w:
4781 case LoongArch::BI__builtin_lasx_xvsrari_w:
4782 case LoongArch::BI__builtin_lasx_xvsrli_w:
4783 case LoongArch::BI__builtin_lasx_xvsllwil_d_w:
4784 case LoongArch::BI__builtin_lasx_xvsllwil_du_wu:
4785 case LoongArch::BI__builtin_lasx_xvsrlri_w:
4786 case LoongArch::BI__builtin_lasx_xvrotri_w:
4787 case LoongArch::BI__builtin_lasx_xvsubi_bu:
4788 case LoongArch::BI__builtin_lasx_xvsubi_hu:
4789 case LoongArch::BI__builtin_lasx_xvsubi_wu:
4790 case LoongArch::BI__builtin_lasx_xvsubi_du:
4791 case LoongArch::BI__builtin_lasx_xvbsrl_v:
4792 case LoongArch::BI__builtin_lasx_xvbsll_v:
4793 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4794 case LoongArch::BI__builtin_lasx_xvssrarni_h_w:
4795 case LoongArch::BI__builtin_lasx_xvssrarni_hu_w:
4796 case LoongArch::BI__builtin_lasx_xvssrani_h_w:
4797 case LoongArch::BI__builtin_lasx_xvssrani_hu_w:
4798 case LoongArch::BI__builtin_lasx_xvsrarni_h_w:
4799 case LoongArch::BI__builtin_lasx_xvsrani_h_w:
4800 case LoongArch::BI__builtin_lasx_xvfrstpi_b:
4801 case LoongArch::BI__builtin_lasx_xvfrstpi_h:
4802 case LoongArch::BI__builtin_lasx_xvsrlni_h_w:
4803 case LoongArch::BI__builtin_lasx_xvsrlrni_h_w:
4804 case LoongArch::BI__builtin_lasx_xvssrlni_h_w:
4805 case LoongArch::BI__builtin_lasx_xvssrlni_hu_w:
4806 case LoongArch::BI__builtin_lasx_xvssrlrni_h_w:
4807 case LoongArch::BI__builtin_lasx_xvssrlrni_hu_w:
4808 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4809 case LoongArch::BI__builtin_lasx_xvbitclri_d:
4810 case LoongArch::BI__builtin_lasx_xvbitrevi_d:
4811 case LoongArch::BI__builtin_lasx_xvbitseti_d:
4812 case LoongArch::BI__builtin_lasx_xvsat_d:
4813 case LoongArch::BI__builtin_lasx_xvsat_du:
4814 case LoongArch::BI__builtin_lasx_xvslli_d:
4815 case LoongArch::BI__builtin_lasx_xvsrai_d:
4816 case LoongArch::BI__builtin_lasx_xvsrli_d:
4817 case LoongArch::BI__builtin_lasx_xvsrari_d:
4818 case LoongArch::BI__builtin_lasx_xvrotri_d:
4819 case LoongArch::BI__builtin_lasx_xvsrlri_d:
4820 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4821 case LoongArch::BI__builtin_lasx_xvssrarni_w_d:
4822 case LoongArch::BI__builtin_lasx_xvssrarni_wu_d:
4823 case LoongArch::BI__builtin_lasx_xvssrani_w_d:
4824 case LoongArch::BI__builtin_lasx_xvssrani_wu_d:
4825 case LoongArch::BI__builtin_lasx_xvsrarni_w_d:
4826 case LoongArch::BI__builtin_lasx_xvsrlni_w_d:
4827 case LoongArch::BI__builtin_lasx_xvsrlrni_w_d:
4828 case LoongArch::BI__builtin_lasx_xvssrlni_w_d:
4829 case LoongArch::BI__builtin_lasx_xvssrlni_wu_d:
4830 case LoongArch::BI__builtin_lasx_xvssrlrni_w_d:
4831 case LoongArch::BI__builtin_lasx_xvssrlrni_wu_d:
4832 case LoongArch::BI__builtin_lasx_xvsrani_w_d:
4833 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4834 case LoongArch::BI__builtin_lasx_xvssrarni_d_q:
4835 case LoongArch::BI__builtin_lasx_xvssrarni_du_q:
4836 case LoongArch::BI__builtin_lasx_xvssrani_d_q:
4837 case LoongArch::BI__builtin_lasx_xvssrani_du_q:
4838 case LoongArch::BI__builtin_lasx_xvsrarni_d_q:
4839 case LoongArch::BI__builtin_lasx_xvssrlni_d_q:
4840 case LoongArch::BI__builtin_lasx_xvssrlni_du_q:
4841 case LoongArch::BI__builtin_lasx_xvssrlrni_d_q:
4842 case LoongArch::BI__builtin_lasx_xvssrlrni_du_q:
4843 case LoongArch::BI__builtin_lasx_xvsrani_d_q:
4844 case LoongArch::BI__builtin_lasx_xvsrlni_d_q:
4845 case LoongArch::BI__builtin_lasx_xvsrlrni_d_q:
4846 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4847 case LoongArch::BI__builtin_lasx_xvseqi_b:
4848 case LoongArch::BI__builtin_lasx_xvseqi_h:
4849 case LoongArch::BI__builtin_lasx_xvseqi_w:
4850 case LoongArch::BI__builtin_lasx_xvseqi_d:
4851 case LoongArch::BI__builtin_lasx_xvslti_b:
4852 case LoongArch::BI__builtin_lasx_xvslti_h:
4853 case LoongArch::BI__builtin_lasx_xvslti_w:
4854 case LoongArch::BI__builtin_lasx_xvslti_d:
4855 case LoongArch::BI__builtin_lasx_xvslei_b:
4856 case LoongArch::BI__builtin_lasx_xvslei_h:
4857 case LoongArch::BI__builtin_lasx_xvslei_w:
4858 case LoongArch::BI__builtin_lasx_xvslei_d:
4859 case LoongArch::BI__builtin_lasx_xvmaxi_b:
4860 case LoongArch::BI__builtin_lasx_xvmaxi_h:
4861 case LoongArch::BI__builtin_lasx_xvmaxi_w:
4862 case LoongArch::BI__builtin_lasx_xvmaxi_d:
4863 case LoongArch::BI__builtin_lasx_xvmini_b:
4864 case LoongArch::BI__builtin_lasx_xvmini_h:
4865 case LoongArch::BI__builtin_lasx_xvmini_w:
4866 case LoongArch::BI__builtin_lasx_xvmini_d:
4867 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4868 case LoongArch::BI__builtin_lasx_xvandi_b:
4869 case LoongArch::BI__builtin_lasx_xvnori_b:
4870 case LoongArch::BI__builtin_lasx_xvori_b:
4871 case LoongArch::BI__builtin_lasx_xvshuf4i_b:
4872 case LoongArch::BI__builtin_lasx_xvshuf4i_h:
4873 case LoongArch::BI__builtin_lasx_xvshuf4i_w:
4874 case LoongArch::BI__builtin_lasx_xvxori_b:
4875 case LoongArch::BI__builtin_lasx_xvpermi_d:
4876 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4877 case LoongArch::BI__builtin_lasx_xvbitseli_b:
4878 case LoongArch::BI__builtin_lasx_xvshuf4i_d:
4879 case LoongArch::BI__builtin_lasx_xvextrins_b:
4880 case LoongArch::BI__builtin_lasx_xvextrins_h:
4881 case LoongArch::BI__builtin_lasx_xvextrins_w:
4882 case LoongArch::BI__builtin_lasx_xvextrins_d:
4883 case LoongArch::BI__builtin_lasx_xvpermi_q:
4884 case LoongArch::BI__builtin_lasx_xvpermi_w:
4885 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4886 case LoongArch::BI__builtin_lasx_xvrepl128vei_b:
4887 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4888 case LoongArch::BI__builtin_lasx_xvrepl128vei_h:
4889 case LoongArch::BI__builtin_lasx_xvpickve2gr_w:
4890 case LoongArch::BI__builtin_lasx_xvpickve2gr_wu:
4891 case LoongArch::BI__builtin_lasx_xvpickve_w_f:
4892 case LoongArch::BI__builtin_lasx_xvpickve_w:
4893 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4894 case LoongArch::BI__builtin_lasx_xvinsgr2vr_w:
4895 case LoongArch::BI__builtin_lasx_xvinsve0_w:
4896 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4897 case LoongArch::BI__builtin_lasx_xvrepl128vei_w:
4898 case LoongArch::BI__builtin_lasx_xvpickve2gr_d:
4899 case LoongArch::BI__builtin_lasx_xvpickve2gr_du:
4900 case LoongArch::BI__builtin_lasx_xvpickve_d_f:
4901 case LoongArch::BI__builtin_lasx_xvpickve_d:
4902 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4903 case LoongArch::BI__builtin_lasx_xvinsve0_d:
4904 case LoongArch::BI__builtin_lasx_xvinsgr2vr_d:
4905 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4906 case LoongArch::BI__builtin_lasx_xvstelm_b:
4907 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4908 BuiltinConstantArgRange(TheCall, 3, 0, 31);
4909 case LoongArch::BI__builtin_lasx_xvstelm_h:
4910 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4911 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4912 case LoongArch::BI__builtin_lasx_xvstelm_w:
4913 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4914 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4915 case LoongArch::BI__builtin_lasx_xvstelm_d:
4916 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4917 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4918 case LoongArch::BI__builtin_lasx_xvrepl128vei_d:
4919 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4920 case LoongArch::BI__builtin_lasx_xvldrepl_b:
4921 case LoongArch::BI__builtin_lasx_xvld:
4922 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4923 case LoongArch::BI__builtin_lasx_xvldrepl_h:
4924 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4925 case LoongArch::BI__builtin_lasx_xvldrepl_w:
4926 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4927 case LoongArch::BI__builtin_lasx_xvldrepl_d:
4928 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4929 case LoongArch::BI__builtin_lasx_xvst:
4930 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4931 case LoongArch::BI__builtin_lasx_xvldi:
4932 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4933 case LoongArch::BI__builtin_lasx_xvrepli_b:
4934 case LoongArch::BI__builtin_lasx_xvrepli_h:
4935 case LoongArch::BI__builtin_lasx_xvrepli_w:
4936 case LoongArch::BI__builtin_lasx_xvrepli_d:
4937 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4942bool Sema::CheckMipsBuiltinFunctionCall(
const TargetInfo &TI,
4943 unsigned BuiltinID,
CallExpr *TheCall) {
4944 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
4945 CheckMipsBuiltinArgument(BuiltinID, TheCall);
4948bool Sema::CheckMipsBuiltinCpu(
const TargetInfo &TI,
unsigned BuiltinID,
4951 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
4952 BuiltinID <= Mips::BI__builtin_mips_lwx) {
4954 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_dsp);
4957 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
4958 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
4961 diag::err_mips_builtin_requires_dspr2);
4964 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
4965 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
4967 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_msa);
4982bool Sema::CheckMipsBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4983 unsigned i = 0, l = 0, u = 0, m = 0;
4984 switch (BuiltinID) {
4985 default:
return false;
4986 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63;
break;
4987 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63;
break;
4988 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31;
break;
4989 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3;
break;
4990 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31;
break;
4991 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31;
break;
4992 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31;
break;
4996 case Mips::BI__builtin_msa_bclri_b:
4997 case Mips::BI__builtin_msa_bnegi_b:
4998 case Mips::BI__builtin_msa_bseti_b:
4999 case Mips::BI__builtin_msa_sat_s_b:
5000 case Mips::BI__builtin_msa_sat_u_b:
5001 case Mips::BI__builtin_msa_slli_b:
5002 case Mips::BI__builtin_msa_srai_b:
5003 case Mips::BI__builtin_msa_srari_b:
5004 case Mips::BI__builtin_msa_srli_b:
5005 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7;
break;
5006 case Mips::BI__builtin_msa_binsli_b:
5007 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7;
break;
5009 case Mips::BI__builtin_msa_bclri_h:
5010 case Mips::BI__builtin_msa_bnegi_h:
5011 case Mips::BI__builtin_msa_bseti_h:
5012 case Mips::BI__builtin_msa_sat_s_h:
5013 case Mips::BI__builtin_msa_sat_u_h:
5014 case Mips::BI__builtin_msa_slli_h:
5015 case Mips::BI__builtin_msa_srai_h:
5016 case Mips::BI__builtin_msa_srari_h:
5017 case Mips::BI__builtin_msa_srli_h:
5018 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15;
break;
5019 case Mips::BI__builtin_msa_binsli_h:
5020 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15;
break;
5024 case Mips::BI__builtin_msa_cfcmsa:
5025 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31;
break;
5026 case Mips::BI__builtin_msa_clei_u_b:
5027 case Mips::BI__builtin_msa_clei_u_h:
5028 case Mips::BI__builtin_msa_clei_u_w:
5029 case Mips::BI__builtin_msa_clei_u_d:
5030 case Mips::BI__builtin_msa_clti_u_b:
5031 case Mips::BI__builtin_msa_clti_u_h:
5032 case Mips::BI__builtin_msa_clti_u_w:
5033 case Mips::BI__builtin_msa_clti_u_d:
5034 case Mips::BI__builtin_msa_maxi_u_b:
5035 case Mips::BI__builtin_msa_maxi_u_h:
5036 case Mips::BI__builtin_msa_maxi_u_w:
5037 case Mips::BI__builtin_msa_maxi_u_d:
5038 case Mips::BI__builtin_msa_mini_u_b:
5039 case Mips::BI__builtin_msa_mini_u_h:
5040 case Mips::BI__builtin_msa_mini_u_w:
5041 case Mips::BI__builtin_msa_mini_u_d:
5042 case Mips::BI__builtin_msa_addvi_b:
5043 case Mips::BI__builtin_msa_addvi_h:
5044 case Mips::BI__builtin_msa_addvi_w:
5045 case Mips::BI__builtin_msa_addvi_d:
5046 case Mips::BI__builtin_msa_bclri_w:
5047 case Mips::BI__builtin_msa_bnegi_w:
5048 case Mips::BI__builtin_msa_bseti_w:
5049 case Mips::BI__builtin_msa_sat_s_w:
5050 case Mips::BI__builtin_msa_sat_u_w:
5051 case Mips::BI__builtin_msa_slli_w:
5052 case Mips::BI__builtin_msa_srai_w:
5053 case Mips::BI__builtin_msa_srari_w:
5054 case Mips::BI__builtin_msa_srli_w:
5055 case Mips::BI__builtin_msa_srlri_w:
5056 case Mips::BI__builtin_msa_subvi_b:
5057 case Mips::BI__builtin_msa_subvi_h:
5058 case Mips::BI__builtin_msa_subvi_w:
5059 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31;
break;
5060 case Mips::BI__builtin_msa_binsli_w:
5061 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31;
break;
5063 case Mips::BI__builtin_msa_bclri_d:
5064 case Mips::BI__builtin_msa_bnegi_d:
5065 case Mips::BI__builtin_msa_bseti_d:
5066 case Mips::BI__builtin_msa_sat_s_d:
5067 case Mips::BI__builtin_msa_sat_u_d:
5068 case Mips::BI__builtin_msa_slli_d:
5069 case Mips::BI__builtin_msa_srai_d:
5070 case Mips::BI__builtin_msa_srari_d:
5071 case Mips::BI__builtin_msa_srli_d:
5072 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63;
break;
5073 case Mips::BI__builtin_msa_binsli_d:
5074 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63;
break;
5076 case Mips::BI__builtin_msa_ceqi_b:
5077 case Mips::BI__builtin_msa_ceqi_h:
5078 case Mips::BI__builtin_msa_ceqi_w:
5079 case Mips::BI__builtin_msa_ceqi_d:
5080 case Mips::BI__builtin_msa_clti_s_b:
5081 case Mips::BI__builtin_msa_clti_s_h:
5082 case Mips::BI__builtin_msa_clti_s_w:
5083 case Mips::BI__builtin_msa_clti_s_d:
5084 case Mips::BI__builtin_msa_clei_s_b:
5085 case Mips::BI__builtin_msa_clei_s_h:
5086 case Mips::BI__builtin_msa_clei_s_w:
5087 case Mips::BI__builtin_msa_clei_s_d:
5088 case Mips::BI__builtin_msa_maxi_s_b:
5089 case Mips::BI__builtin_msa_maxi_s_h:
5090 case Mips::BI__builtin_msa_maxi_s_w:
5091 case Mips::BI__builtin_msa_maxi_s_d:
5092 case Mips::BI__builtin_msa_mini_s_b:
5093 case Mips::BI__builtin_msa_mini_s_h:
5094 case Mips::BI__builtin_msa_mini_s_w:
5095 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15;
break;
5097 case Mips::BI__builtin_msa_andi_b:
5098 case Mips::BI__builtin_msa_nori_b:
5099 case Mips::BI__builtin_msa_ori_b:
5100 case Mips::BI__builtin_msa_shf_b:
5101 case Mips::BI__builtin_msa_shf_h:
5102 case Mips::BI__builtin_msa_shf_w:
5103 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255;
break;
5104 case Mips::BI__builtin_msa_bseli_b:
5105 case Mips::BI__builtin_msa_bmnzi_b:
5106 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255;
break;
5109 case Mips::BI__builtin_msa_copy_s_b:
5110 case Mips::BI__builtin_msa_copy_u_b:
5111 case Mips::BI__builtin_msa_insve_b:
5112 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15;
break;
5113 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15;
break;
5115 case Mips::BI__builtin_msa_copy_s_h:
5116 case Mips::BI__builtin_msa_copy_u_h:
5117 case Mips::BI__builtin_msa_insve_h:
5118 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7;
break;
5119 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7;
break;
5121 case Mips::BI__builtin_msa_copy_s_w:
5122 case Mips::BI__builtin_msa_copy_u_w:
5123 case Mips::BI__builtin_msa_insve_w:
5124 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3;
break;
5125 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3;
break;
5127 case Mips::BI__builtin_msa_copy_s_d:
5128 case Mips::BI__builtin_msa_copy_u_d:
5129 case Mips::BI__builtin_msa_insve_d:
5130 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1;
break;
5131 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1;
break;
5134 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255;
break;
5135 case Mips::BI__builtin_msa_ldi_h:
5136 case Mips::BI__builtin_msa_ldi_w:
5137 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511;
break;
5138 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1;
break;
5139 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2;
break;
5140 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5141 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5142 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5143 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5144 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1;
break;
5145 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2;
break;
5146 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5147 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5148 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5149 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5153 return BuiltinConstantArgRange(TheCall, i, l, u);
5155 return BuiltinConstantArgRange(TheCall, i, l, u) ||
5156 BuiltinConstantArgMultiple(TheCall, i, m);
5167 bool RequireICE =
false;
5175 unsigned size = strtoul(Str, &End, 10);
5176 assert(End != Str &&
"Missing constant parameter constraint");
5179 return Context.
IntTy;
5183 unsigned size = strtoul(Str, &End, 10);
5184 assert(End != Str &&
"Missing PowerPC MMA type size");
5188 #define PPC_VECTOR_TYPE(typeName, Id, size) \
5189 case size: Type = Context.Id##Ty; break;
5190 #include "clang/Basic/PPCTypes.def"
5191 default: llvm_unreachable(
"Invalid PowerPC MMA vector type");
5193 bool CheckVectorArgs =
false;
5194 while (!CheckVectorArgs) {
5203 CheckVectorArgs =
true;
5211 return Context.
DecodeTypeStr(--Str, Context, Error, RequireICE,
true);
5217 switch (BuiltinID) {
5218 case PPC::BI__builtin_divde:
5219 case PPC::BI__builtin_divdeu:
5220 case PPC::BI__builtin_bpermd:
5221 case PPC::BI__builtin_pdepd:
5222 case PPC::BI__builtin_pextd:
5223 case PPC::BI__builtin_ppc_ldarx:
5224 case PPC::BI__builtin_ppc_stdcx:
5225 case PPC::BI__builtin_ppc_tdw:
5226 case PPC::BI__builtin_ppc_trapd:
5227 case PPC::BI__builtin_ppc_cmpeqb:
5228 case PPC::BI__builtin_ppc_setb:
5229 case PPC::BI__builtin_ppc_mulhd:
5230 case PPC::BI__builtin_ppc_mulhdu:
5231 case PPC::BI__builtin_ppc_maddhd:
5232 case PPC::BI__builtin_ppc_maddhdu:
5233 case PPC::BI__builtin_ppc_maddld:
5234 case PPC::BI__builtin_ppc_load8r:
5235 case PPC::BI__builtin_ppc_store8r:
5236 case PPC::BI__builtin_ppc_insert_exp:
5237 case PPC::BI__builtin_ppc_extract_sig:
5238 case PPC::BI__builtin_ppc_addex:
5239 case PPC::BI__builtin_darn:
5240 case PPC::BI__builtin_darn_raw:
5241 case PPC::BI__builtin_ppc_compare_and_swaplp:
5242 case PPC::BI__builtin_ppc_fetch_and_addlp:
5243 case PPC::BI__builtin_ppc_fetch_and_andlp:
5244 case PPC::BI__builtin_ppc_fetch_and_orlp:
5245 case PPC::BI__builtin_ppc_fetch_and_swaplp:
5255bool Sema::ValueIsRunOfOnes(
CallExpr *TheCall,
unsigned ArgNum) {
5263 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
5267 if (
Result.isShiftedMask() || (~
Result).isShiftedMask())
5271 diag::err_argument_not_contiguous_bit_field)
5275bool Sema::CheckPPCBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
5277 unsigned i = 0, l = 0, u = 0;
5282 return Diag(TheCall->
getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
5285 switch (BuiltinID) {
5286 default:
return false;
5287 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
5288 case PPC::BI__builtin_altivec_crypto_vshasigmad:
5289 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
5290 BuiltinConstantArgRange(TheCall, 2, 0, 15);
5291 case PPC::BI__builtin_altivec_dss:
5292 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
5293 case PPC::BI__builtin_tbegin:
5294 case PPC::BI__builtin_tend:
5295 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5296 case PPC::BI__builtin_tsr:
5297 return BuiltinConstantArgRange(TheCall, 0, 0, 7);
5298 case PPC::BI__builtin_tabortwc:
5299 case PPC::BI__builtin_tabortdc:
5300 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5301 case PPC::BI__builtin_tabortwci:
5302 case PPC::BI__builtin_tabortdci:
5303 return BuiltinConstantArgRange(TheCall, 0, 0, 31) ||
5304 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5308 case PPC::BI__builtin_unpack_longdouble:
5309 if (BuiltinConstantArgRange(TheCall, 1, 0, 1))
5312 case PPC::BI__builtin_pack_longdouble:
5314 return Diag(TheCall->
getBeginLoc(), diag::err_ppc_builtin_requires_abi)
5317 case PPC::BI__builtin_altivec_dst:
5318 case PPC::BI__builtin_altivec_dstt:
5319 case PPC::BI__builtin_altivec_dstst:
5320 case PPC::BI__builtin_altivec_dststt:
5321 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
5322 case PPC::BI__builtin_vsx_xxpermdi:
5323 case PPC::BI__builtin_vsx_xxsldwi:
5324 return BuiltinVSX(TheCall);
5325 case PPC::BI__builtin_unpack_vector_int128:
5326 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5327 case PPC::BI__builtin_altivec_vgnb:
5328 return BuiltinConstantArgRange(TheCall, 1, 2, 7);
5329 case PPC::BI__builtin_vsx_xxeval:
5330 return BuiltinConstantArgRange(TheCall, 3, 0, 255);
5331 case PPC::BI__builtin_altivec_vsldbi:
5332 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5333 case PPC::BI__builtin_altivec_vsrdbi:
5334 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5335 case PPC::BI__builtin_vsx_xxpermx:
5336 return BuiltinConstantArgRange(TheCall, 3, 0, 7);
5337 case PPC::BI__builtin_ppc_tw:
5338 case PPC::BI__builtin_ppc_tdw:
5339 return BuiltinConstantArgRange(TheCall, 2, 1, 31);
5340 case PPC::BI__builtin_ppc_cmprb:
5341 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5344 case PPC::BI__builtin_ppc_rlwnm:
5345 return ValueIsRunOfOnes(TheCall, 2);
5346 case PPC::BI__builtin_ppc_rlwimi:
5347 return BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5348 ValueIsRunOfOnes(TheCall, 3);
5349 case PPC::BI__builtin_ppc_rldimi:
5350 return BuiltinConstantArgRange(TheCall, 2, 0, 63) ||
5351 ValueIsRunOfOnes(TheCall, 3);
5352 case PPC::BI__builtin_ppc_addex: {
5353 if (BuiltinConstantArgRange(TheCall, 2, 0, 3))
5363 case PPC::BI__builtin_ppc_mtfsb0:
5364 case PPC::BI__builtin_ppc_mtfsb1:
5365 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5366 case PPC::BI__builtin_ppc_mtfsf:
5367 return BuiltinConstantArgRange(TheCall, 0, 0, 255);
5368 case PPC::BI__builtin_ppc_mtfsfi:
5369 return BuiltinConstantArgRange(TheCall, 0, 0, 7) ||
5370 BuiltinConstantArgRange(TheCall, 1, 0, 15);
5371 case PPC::BI__builtin_ppc_alignx:
5372 return BuiltinConstantArgPower2(TheCall, 0);
5373 case PPC::BI__builtin_ppc_rdlam:
5374 return ValueIsRunOfOnes(TheCall, 2);
5375 case PPC::BI__builtin_vsx_ldrmb:
5376 case PPC::BI__builtin_vsx_strmb:
5377 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
5378 case PPC::BI__builtin_altivec_vcntmbb:
5379 case PPC::BI__builtin_altivec_vcntmbh:
5380 case PPC::BI__builtin_altivec_vcntmbw:
5381 case PPC::BI__builtin_altivec_vcntmbd:
5382 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5383 case PPC::BI__builtin_vsx_xxgenpcvbm:
5384 case PPC::BI__builtin_vsx_xxgenpcvhm:
5385 case PPC::BI__builtin_vsx_xxgenpcvwm:
5386 case PPC::BI__builtin_vsx_xxgenpcvdm:
5387 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
5388 case PPC::BI__builtin_ppc_test_data_class: {
5396 diag::err_ppc_invalid_test_data_class_type);
5397 return BuiltinConstantArgRange(TheCall, 1, 0, 127);
5399 case PPC::BI__builtin_ppc_maxfe:
5400 case PPC::BI__builtin_ppc_minfe:
5401 case PPC::BI__builtin_ppc_maxfl:
5402 case PPC::BI__builtin_ppc_minfl:
5403 case PPC::BI__builtin_ppc_maxfs:
5404 case PPC::BI__builtin_ppc_minfs: {
5406 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
5407 BuiltinID == PPC::BI__builtin_ppc_minfe))
5408 return Diag(TheCall->
getBeginLoc(), diag::err_target_unsupported_type)
5413 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
5414 BuiltinID == PPC::BI__builtin_ppc_minfl)
5416 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
5417 BuiltinID == PPC::BI__builtin_ppc_minfs)
5419 for (
unsigned I = 0, E = TheCall->
getNumArgs(); I < E; ++I)
5422 diag::err_typecheck_convert_incompatible)
5426#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
5427 case PPC::BI__builtin_##Name: \
5428 return BuiltinPPCMMACall(TheCall, BuiltinID, Types);
5429#include "clang/Basic/BuiltinsPPC.def"
5431 return BuiltinConstantArgRange(TheCall, i, l, u);
5440 QualType CoreType =
Type.getCanonicalType().getUnqualifiedType();
5441#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
5443#include
"clang/Basic/PPCTypes.def"
5445 Diag(
TypeLoc, diag::err_ppc_invalid_use_mma_type);
5461 for (
unsigned i = 1; i < TheCall->
getNumArgs(); ++i) {
5465 if (VecTyA ==
nullptr && VecTyB ==
nullptr)
5468 if (VecTyA && VecTyB) {
5469 bool retValue =
false;
5470 if (VecTyA->getElementType() != VecTyB->getElementType()) {
5474 diag::err_vec_builtin_incompatible_vector)
5479 if (VecTyA->getNumElements() != VecTyB->getNumElements()) {
5483 S->
Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
5495 S->
Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
5505 for (
unsigned i = 0; i < TheCall->
getNumArgs(); ++i) {
5507 if (Check(PassedType)) {
5510 ExpectedType, VecTyA->getNumElements(), VecTyA->getVectorKind());
5512 diag::err_typecheck_convert_incompatible)
5522 return !PassedType->hasFloatingRepresentation();
5525 checkAllFloatTypes);
5542 if (
const auto *VecTy = PassedType->getAs<
VectorType>())
5543 return VecTy->getElementType()->isDoubleType();
5552 return !PassedType->hasUnsignedIntegerRepresentation();
5555 checkAllUnsignedTypes);
5570 switch (BuiltinID) {
5571 case Builtin::BI__builtin_hlsl_elementwise_all:
5572 case Builtin::BI__builtin_hlsl_elementwise_any: {
5577 case Builtin::BI__builtin_hlsl_elementwise_clamp: {
5582 if (BuiltinElementwiseTernaryMath(
5588 case Builtin::BI__builtin_hlsl_dot: {
5599 case Builtin::BI__builtin_hlsl_elementwise_rcp: {
5602 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5606 case Builtin::BI__builtin_hlsl_elementwise_rsqrt:
5607 case Builtin::BI__builtin_hlsl_elementwise_frac: {
5610 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5614 case Builtin::BI__builtin_hlsl_elementwise_isinf: {
5617 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5622 case Builtin::BI__builtin_hlsl_lerp: {
5627 if (BuiltinElementwiseTernaryMath(TheCall))
5633 case Builtin::BI__builtin_hlsl_mad: {
5638 if (BuiltinElementwiseTernaryMath(
5646 case Builtin::BI__builtin_elementwise_bitreverse: {
5651 case Builtin::BI__builtin_elementwise_ceil:
5652 case Builtin::BI__builtin_elementwise_cos:
5653 case Builtin::BI__builtin_elementwise_exp:
5654 case Builtin::BI__builtin_elementwise_exp2:
5655 case Builtin::BI__builtin_elementwise_floor:
5656 case Builtin::BI__builtin_elementwise_log:
5657 case Builtin::BI__builtin_elementwise_log2:
5658 case Builtin::BI__builtin_elementwise_log10:
5659 case Builtin::BI__builtin_elementwise_pow:
5660 case Builtin::BI__builtin_elementwise_roundeven:
5661 case Builtin::BI__builtin_elementwise_sin:
5662 case Builtin::BI__builtin_elementwise_sqrt:
5663 case Builtin::BI__builtin_elementwise_trunc: {
5672bool Sema::CheckAMDGCNBuiltinFunctionCall(
unsigned BuiltinID,
5675 unsigned OrderIndex, ScopeIndex;
5676 switch (BuiltinID) {
5677 case AMDGPU::BI__builtin_amdgcn_get_fpenv:
5678 case AMDGPU::BI__builtin_amdgcn_set_fpenv:
5680 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
5681 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
5682 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
5683 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
5687 case AMDGPU::BI__builtin_amdgcn_fence:
5696 auto ArgExpr = Arg.
get();
5699 if (!ArgExpr->EvaluateAsInt(ArgResult,
Context))
5700 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
5701 << ArgExpr->getType();
5702 auto Ord = ArgResult.
Val.
getInt().getZExtValue();
5706 if (!llvm::isValidAtomicOrderingCABI(Ord))
5707 return Diag(ArgExpr->getBeginLoc(),
5708 diag::warn_atomic_op_has_invalid_memory_order)
5709 << 0 << ArgExpr->getSourceRange();
5710 switch (
static_cast<llvm::AtomicOrderingCABI
>(Ord)) {
5711 case llvm::AtomicOrderingCABI::relaxed:
5712 case llvm::AtomicOrderingCABI::consume:
5713 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
5714 return Diag(ArgExpr->getBeginLoc(),
5715 diag::warn_atomic_op_has_invalid_memory_order)
5716 << 0 << ArgExpr->getSourceRange();
5718 case llvm::AtomicOrderingCABI::acquire:
5719 case llvm::AtomicOrderingCABI::release:
5720 case llvm::AtomicOrderingCABI::acq_rel:
5721 case llvm::AtomicOrderingCABI::seq_cst:
5725 Arg = TheCall->
getArg(ScopeIndex);
5726 ArgExpr = Arg.
get();
5729 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1,
Context))
5730 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
5731 << ArgExpr->getType();
5736bool Sema::CheckRISCVLMUL(
CallExpr *TheCall,
unsigned ArgNum) {
5745 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
5749 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
5752 return Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
5758 assert((EGW == 128 || EGW == 256) &&
"EGW can only be 128 or 256 bits");
5764 unsigned MinElemCount = Info.
EC.getKnownMinValue();
5766 unsigned EGS = EGW / ElemSize;
5769 if (EGS <= MinElemCount)
5773 assert(EGS % MinElemCount == 0);
5774 unsigned VScaleFactor = EGS / MinElemCount;
5776 unsigned MinRequiredVLEN = VScaleFactor * llvm::RISCV::RVVBitsPerBlock;
5777 std::string RequiredExt =
"zvl" + std::to_string(MinRequiredVLEN) +
"b";
5780 diag::err_riscv_type_requires_extension) <<
Type << RequiredExt;
5785bool Sema::CheckRISCVBuiltinFunctionCall(
const TargetInfo &TI,
5790 switch (BuiltinID) {
5793 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
5794 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
5795 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
5796 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
5797 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
5798 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
5799 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
5800 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
5801 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
5802 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
5803 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
5804 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
5805 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
5806 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
5807 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
5808 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
5809 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
5810 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
5811 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
5812 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
5813 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
5814 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
5815 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
5816 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
5817 case RISCVVector::BI__builtin_rvv_vmulh_vv:
5818 case RISCVVector::BI__builtin_rvv_vmulh_vx:
5819 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
5820 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
5821 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
5822 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
5823 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
5824 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
5825 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
5826 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
5827 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
5828 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
5829 case RISCVVector::BI__builtin_rvv_vsmul_vv:
5830 case RISCVVector::BI__builtin_rvv_vsmul_vx:
5831 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
5832 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
5833 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
5834 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
5835 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
5836 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
5837 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
5838 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
5839 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
5840 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
5846 diag::err_riscv_builtin_requires_extension)
5853 switch (BuiltinID) {
5854 case RISCVVector::BI__builtin_rvv_vsetvli:
5855 return BuiltinConstantArgRange(TheCall, 1, 0, 3) ||
5856 CheckRISCVLMUL(TheCall, 2);
5857 case RISCVVector::BI__builtin_rvv_vsetvlimax:
5858 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5859 CheckRISCVLMUL(TheCall, 1);
5860 case RISCVVector::BI__builtin_rvv_vget_v: {
5871 MaxIndex = (VecInfo.
EC.getKnownMinValue() * VecInfo.
NumVectors) /
5872 (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors);
5873 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5875 case RISCVVector::BI__builtin_rvv_vset_v: {
5886 MaxIndex = (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors) /
5888 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5891 case RISCVVector::BI__builtin_rvv_vaeskf1_vi_tu:
5892 case RISCVVector::BI__builtin_rvv_vaeskf2_vi_tu:
5893 case RISCVVector::BI__builtin_rvv_vaeskf2_vi:
5894 case RISCVVector::BI__builtin_rvv_vsm4k_vi_tu: {
5899 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5901 case RISCVVector::BI__builtin_rvv_vsm3c_vi_tu:
5902 case RISCVVector::BI__builtin_rvv_vsm3c_vi: {
5905 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5907 case RISCVVector::BI__builtin_rvv_vaeskf1_vi:
5908 case RISCVVector::BI__builtin_rvv_vsm4k_vi: {
5911 BuiltinConstantArgRange(TheCall, 1, 0, 31);
5913 case RISCVVector::BI__builtin_rvv_vaesdf_vv:
5914 case RISCVVector::BI__builtin_rvv_vaesdf_vs:
5915 case RISCVVector::BI__builtin_rvv_vaesdm_vv:
5916 case RISCVVector::BI__builtin_rvv_vaesdm_vs:
5917 case RISCVVector::BI__builtin_rvv_vaesef_vv:
5918 case RISCVVector::BI__builtin_rvv_vaesef_vs:
5919 case RISCVVector::BI__builtin_rvv_vaesem_vv:
5920 case RISCVVector::BI__builtin_rvv_vaesem_vs:
5921 case RISCVVector::BI__builtin_rvv_vaesz_vs:
5922 case RISCVVector::BI__builtin_rvv_vsm4r_vv:
5923 case RISCVVector::BI__builtin_rvv_vsm4r_vs:
5924 case RISCVVector::BI__builtin_rvv_vaesdf_vv_tu:
5925 case RISCVVector::BI__builtin_rvv_vaesdf_vs_tu:
5926 case RISCVVector::BI__builtin_rvv_vaesdm_vv_tu:
5927 case RISCVVector::BI__builtin_rvv_vaesdm_vs_tu:
5928 case RISCVVector::BI__builtin_rvv_vaesef_vv_tu:
5929 case RISCVVector::BI__builtin_rvv_vaesef_vs_tu:
5930 case RISCVVector::BI__builtin_rvv_vaesem_vv_tu:
5931 case RISCVVector::BI__builtin_rvv_vaesem_vs_tu:
5932 case RISCVVector::BI__builtin_rvv_vaesz_vs_tu:
5933 case RISCVVector::BI__builtin_rvv_vsm4r_vv_tu:
5934 case RISCVVector::BI__builtin_rvv_vsm4r_vs_tu: {
5940 case RISCVVector::BI__builtin_rvv_vsha2ch_vv:
5941 case RISCVVector::BI__builtin_rvv_vsha2cl_vv:
5942 case RISCVVector::BI__builtin_rvv_vsha2ms_vv:
5943 case RISCVVector::BI__builtin_rvv_vsha2ch_vv_tu:
5944 case RISCVVector::BI__builtin_rvv_vsha2cl_vv_tu:
5945 case RISCVVector::BI__builtin_rvv_vsha2ms_vv_tu: {
5952 if (ElemSize == 64 && !TI.
hasFeature(
"zvknhb"))
5954 diag::err_riscv_builtin_requires_extension)
5962 case RISCVVector::BI__builtin_rvv_sf_vc_i_se:
5964 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5965 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5966 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5967 BuiltinConstantArgRange(TheCall, 3, -16, 15) ||
5968 CheckRISCVLMUL(TheCall, 5);
5969 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
5971 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5972 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5973 BuiltinConstantArgRange(TheCall, 3, -16, 15);
5974 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
5975 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
5977 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5978 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5979 BuiltinConstantArgRange(TheCall, 2, -16, 15);
5980 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
5981 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
5983 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5984 BuiltinConstantArgRange(TheCall, 2, -16, 15);
5985 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
5986 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
5987 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
5988 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
5989 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
5990 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
5992 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5993 BuiltinConstantArgRange(TheCall, 3, -16, 15);
5994 case RISCVVector::BI__builtin_rvv_sf_vc_x_se:
5996 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5997 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5998 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5999 CheckRISCVLMUL(TheCall, 5);
6000 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
6001 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
6003 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
6004 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
6006 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6007 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6008 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
6009 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
6010 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
6011 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
6013 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
6014 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
6015 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
6016 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
6018 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
6019 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
6020 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
6021 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
6022 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
6023 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
6024 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
6025 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
6027 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
6028 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
6030 return BuiltinConstantArgRange(TheCall, 0, 0, 1) ||
6031 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6032 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
6033 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
6034 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
6035 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
6036 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
6037 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
6039 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
6040 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
6042 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
6044 case RISCV::BI__builtin_riscv_aes32dsi:
6045 case RISCV::BI__builtin_riscv_aes32dsmi:
6046 case RISCV::BI__builtin_riscv_aes32esi:
6047 case RISCV::BI__builtin_riscv_aes32esmi:
6048 case RISCV::BI__builtin_riscv_sm4ks:
6049 case RISCV::BI__builtin_riscv_sm4ed:
6050 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6052 case RISCV::BI__builtin_riscv_aes64ks1i:
6053 return BuiltinConstantArgRange(TheCall, 1, 0, 10);
6055 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
6056 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
6057 case RISCVVector::BI__builtin_rvv_vaadd_vv:
6058 case RISCVVector::BI__builtin_rvv_vaadd_vx:
6059 case RISCVVector::BI__builtin_rvv_vasubu_vv:
6060 case RISCVVector::BI__builtin_rvv_vasubu_vx:
6061 case RISCVVector::BI__builtin_rvv_vasub_vv:
6062 case RISCVVector::BI__builtin_rvv_vasub_vx:
6063 case RISCVVector::BI__builtin_rvv_vsmul_vv:
6064 case RISCVVector::BI__builtin_rvv_vsmul_vx:
6065 case RISCVVector::BI__builtin_rvv_vssra_vv:
6066 case RISCVVector::BI__builtin_rvv_vssra_vx:
6067 case RISCVVector::BI__builtin_rvv_vssrl_vv:
6068 case RISCVVector::BI__builtin_rvv_vssrl_vx:
6069 case RISCVVector::BI__builtin_rvv_vnclip_wv:
6070 case RISCVVector::BI__builtin_rvv_vnclip_wx:
6071 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
6072 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
6073 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6074 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
6075 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
6076 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
6077 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
6078 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
6079 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
6080 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
6081 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
6082 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
6083 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
6084 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
6085 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
6086 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
6087 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
6088 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
6089 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
6090 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
6091 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
6092 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
6093 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
6094 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
6095 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
6096 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
6097 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
6098 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
6099 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
6100 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
6101 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
6102 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
6103 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
6104 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
6105 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
6106 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
6107 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
6108 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
6109 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
6110 return BuiltinConstantArgRange(TheCall, 3, 0, 3);
6111 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
6112 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
6113 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
6114 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
6115 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
6116 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
6117 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
6118 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
6119 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
6120 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
6121 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
6122 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
6123 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
6124 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
6125 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
6126 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
6127 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
6128 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
6129 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
6130 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
6131 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
6132 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
6133 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
6134 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
6135 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
6136 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
6137 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
6138 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
6139 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
6140 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
6141 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
6142 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
6143 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
6144 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
6145 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
6146 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
6147 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
6148 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
6149 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
6150 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
6151 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
6152 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
6153 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
6154 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
6155 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
6156 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
6157 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
6158 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
6159 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
6160 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
6161 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
6162 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
6163 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
6164 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
6165 return BuiltinConstantArgRange(TheCall, 4, 0, 3);
6166 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
6167 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
6168 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
6169 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
6170 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
6171 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
6172 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
6173 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
6174 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
6175 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
6176 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
6177 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
6178 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
6179 return BuiltinConstantArgRange(TheCall, 1, 0, 4);
6180 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
6181 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
6182 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
6183 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
6184 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
6185 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
6186 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
6187 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
6188 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
6189 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
6190 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
6191 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
6192 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
6193 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
6194 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
6195 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
6196 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
6197 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
6198 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
6199 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
6200 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
6201 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
6202 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
6203 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
6204 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
6205 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
6206 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
6207 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
6208 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
6209 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
6210 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
6211 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
6212 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
6213 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
6214 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
6215 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
6216 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
6217 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
6218 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
6219 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
6220 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
6221 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
6222 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
6223 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
6224 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
6225 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
6226 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
6227 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
6228 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
6229 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
6230 return BuiltinConstantArgRange(TheCall, 2, 0, 4);
6231 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
6232 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
6233 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
6234 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
6235 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
6236 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
6237 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
6238 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
6239 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
6240 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
6241 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
6242 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
6243 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
6244 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
6245 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
6246 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
6247 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
6248 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
6249 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
6250 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
6251 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
6252 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
6253 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
6254 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
6255 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
6256 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
6257 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
6258 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
6259 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
6260 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
6261 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
6262 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
6263 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
6264 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
6265 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
6266 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
6267 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
6268 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
6269 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
6270 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
6271 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
6272 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
6273 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
6274 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
6275 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
6276 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
6277 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
6278 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
6279 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
6280 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
6281 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
6282 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
6283 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
6284 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
6285 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
6286 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
6287 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
6288 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
6289 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
6290 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
6291 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
6292 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
6293 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
6294 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
6295 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
6296 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
6297 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
6298 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
6299 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
6300 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
6301 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
6302 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
6303 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
6304 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
6305 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
6306 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
6307 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
6308 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
6309 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
6310 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
6311 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
6312 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
6313 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
6314 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
6315 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
6316 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
6317 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
6318 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
6319 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
6320 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
6321 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
6322 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
6323 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
6324 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
6325 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
6326 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
6327 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
6328 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
6329 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
6330 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
6331 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
6332 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
6333 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
6334 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
6335 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
6336 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
6337 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
6338 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
6339 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
6340 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
6341 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
6342 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
6343 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
6344 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
6345 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
6346 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
6347 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
6348 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
6349 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
6350 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
6351 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
6352 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
6353 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
6354 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
6355 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
6356 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
6357 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
6358 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
6359 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
6360 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
6361 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
6362 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
6363 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
6364 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
6365 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
6366 return BuiltinConstantArgRange(TheCall, 3, 0, 4);
6367 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
6368 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
6369 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
6370 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
6371 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
6372 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
6373 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
6374 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
6375 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
6376 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
6377 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
6378 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
6379 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
6380 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
6381 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
6382 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
6383 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
6384 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
6385 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
6386 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
6387 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
6388 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
6389 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
6390 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
6391 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
6392 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
6393 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
6394 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
6395 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
6396 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
6397 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
6398 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
6399 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
6400 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
6401 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
6402 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
6403 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
6404 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
6405 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
6406 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
6407 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
6408 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
6409 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
6410 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
6411 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
6412 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
6413 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
6414 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
6415 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
6416 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
6417 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
6418 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
6419 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
6420 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
6421 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
6422 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
6423 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
6424 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
6425 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
6426 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
6427 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
6428 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
6429 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
6430 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
6431 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
6432 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
6433 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
6434 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
6435 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
6436 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
6437 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
6438 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
6439 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
6440 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
6441 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
6442 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
6443 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
6444 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
6445 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
6446 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
6447 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
6448 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
6449 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
6450 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
6451 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
6452 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
6453 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
6454 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
6455 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
6456 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
6457 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
6458 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
6459 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
6460 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
6461 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
6462 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
6463 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
6464 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
6465 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
6466 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
6467 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
6468 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
6469 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
6470 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
6471 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
6472 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
6473 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
6474 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
6475 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
6476 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
6477 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
6478 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
6479 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
6480 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
6481 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
6482 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
6483 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
6484 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
6485 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
6486 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
6487 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
6488 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
6489 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
6490 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
6491 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
6492 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
6493 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
6494 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
6495 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
6496 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
6497 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
6498 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
6499 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
6500 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
6501 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
6502 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
6503 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
6504 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
6505 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
6506 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
6507 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
6508 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
6509 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
6510 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
6511 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
6512 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
6513 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
6514 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
6515 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
6516 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
6517 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
6518 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
6519 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
6520 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
6521 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
6522 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
6523 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
6524 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
6525 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
6526 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
6527 return BuiltinConstantArgRange(TheCall, 4, 0, 4);
6528 case RISCV::BI__builtin_riscv_ntl_load:
6529 case RISCV::BI__builtin_riscv_ntl_store:
6532 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
6533 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
6534 "Unexpected RISC-V nontemporal load/store builtin!");
6535 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
6536 unsigned NumArgs = IsStore ? 3 : 2;
6547 BuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
6556 PointerArg = PointerArgResult.
get();
6560 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
6571 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
6596bool Sema::CheckSystemZBuiltinFunctionCall(
unsigned BuiltinID,
6598 if (BuiltinID == SystemZ::BI__builtin_tabort) {
6600 if (std::optional<llvm::APSInt> AbortCode =
6602 if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
6603 return Diag(Arg->
getBeginLoc(), diag::err_systemz_invalid_tabort_code)
6609 unsigned i = 0, l = 0, u = 0;
6610 switch (BuiltinID) {
6611 default:
return false;
6612 case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15;
break;
6613 case SystemZ::BI__builtin_s390_verimb:
6614 case SystemZ::BI__builtin_s390_verimh:
6615 case SystemZ::BI__builtin_s390_verimf:
6616 case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255;
break;
6617 case SystemZ::BI__builtin_s390_vfaeb:
6618 case SystemZ::BI__builtin_s390_vfaeh:
6619 case SystemZ::BI__builtin_s390_vfaef:
6620 case SystemZ::BI__builtin_s390_vfaebs:
6621 case SystemZ::BI__builtin_s390_vfaehs:
6622 case SystemZ::BI__builtin_s390_vfaefs:
6623 case SystemZ::BI__builtin_s390_vfaezb:
6624 case SystemZ::BI__builtin_s390_vfaezh:
6625 case SystemZ::BI__builtin_s390_vfaezf:
6626 case SystemZ::BI__builtin_s390_vfaezbs:
6627 case SystemZ::BI__builtin_s390_vfaezhs:
6628 case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15;
break;
6629 case SystemZ::BI__builtin_s390_vfisb:
6630 case SystemZ::BI__builtin_s390_vfidb:
6631 return BuiltinConstantArgRange(TheCall, 1, 0, 15) ||
6632 BuiltinConstantArgRange(TheCall, 2, 0, 15);
6633 case SystemZ::BI__builtin_s390_vftcisb:
6634 case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095;
break;
6635 case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15;
break;
6636 case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15;
break;
6637 case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15;
break;
6638 case SystemZ::BI__builtin_s390_vstrcb:
6639 case SystemZ::BI__builtin_s390_vstrch:
6640 case SystemZ::BI__builtin_s390_vstrcf:
6641 case SystemZ::BI__builtin_s390_vstrczb:
6642 case SystemZ::BI__builtin_s390_vstrczh:
6643 case SystemZ::BI__builtin_s390_vstrczf:
6644 case SystemZ::BI__builtin_s390_vstrcbs:
6645 case SystemZ::BI__builtin_s390_vstrchs:
6646 case SystemZ::BI__builtin_s390_vstrcfs:
6647 case SystemZ::BI__builtin_s390_vstrczbs:
6648 case SystemZ::BI__builtin_s390_vstrczhs:
6649 case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15;
break;
6650 case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15;
break;
6651 case SystemZ::BI__builtin_s390_vfminsb:
6652 case SystemZ::BI__builtin_s390_vfmaxsb:
6653 case SystemZ::BI__builtin_s390_vfmindb:
6654 case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15;
break;
6655 case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7;
break;
6656 case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7;
break;
6657 case SystemZ::BI__builtin_s390_vclfnhs:
6658 case SystemZ::BI__builtin_s390_vclfnls:
6659 case SystemZ::BI__builtin_s390_vcfn:
6660 case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15;
break;
6661 case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15;
break;
6663 return BuiltinConstantArgRange(TheCall, i, l, u);
6666bool Sema::CheckWebAssemblyBuiltinFunctionCall(
const TargetInfo &TI,
6669 switch (BuiltinID) {
6670 case WebAssembly::BI__builtin_wasm_ref_null_extern:
6671 return BuiltinWasmRefNullExtern(TheCall);
6672 case WebAssembly::BI__builtin_wasm_ref_null_func:
6673 return BuiltinWasmRefNullFunc(TheCall);
6674 case WebAssembly::BI__builtin_wasm_table_get:
6675 return BuiltinWasmTableGet(TheCall);
6676 case WebAssembly::BI__builtin_wasm_table_set:
6677 return BuiltinWasmTableSet(TheCall);
6678 case WebAssembly::BI__builtin_wasm_table_size:
6679 return BuiltinWasmTableSize(TheCall);
6680 case WebAssembly::BI__builtin_wasm_table_grow:
6681 return BuiltinWasmTableGrow(TheCall);
6682 case WebAssembly::BI__builtin_wasm_table_fill:
6683 return BuiltinWasmTableFill(TheCall);
6684 case WebAssembly::BI__builtin_wasm_table_copy:
6685 return BuiltinWasmTableCopy(TheCall);
6692 const llvm::StringMap<bool> &FeatureMap) {
6696 unsigned MinElts = Info.
EC.getKnownMinValue();
6699 !FeatureMap.lookup(
"zve64d"))
6700 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64d";
6705 !FeatureMap.lookup(
"zve64x"))
6706 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64x";
6708 !FeatureMap.lookup(
"zvfhmin"))
6709 Diag(Loc, diag::err_riscv_type_requires_extension, D)
6710 << Ty <<
"zvfh or zvfhmin";
6712 !FeatureMap.lookup(
"experimental-zvfbfmin"))
6713 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zvfbfmin";
6715 !FeatureMap.lookup(
"zve32f"))
6716 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32f";
6719 else if (!FeatureMap.lookup(
"zve32x"))
6720 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32x";
6723bool Sema::CheckNVPTXBuiltinFunctionCall(
const TargetInfo &TI,
6726 switch (BuiltinID) {
6727 case NVPTX::BI__nvvm_cp_async_ca_shared_global_4:
6728 case NVPTX::BI__nvvm_cp_async_ca_shared_global_8:
6729 case NVPTX::BI__nvvm_cp_async_ca_shared_global_16:
6730 case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
6738bool Sema::CheckX86BuiltinRoundingOrSAE(
unsigned BuiltinID,
CallExpr *TheCall) {
6742 unsigned ArgNum = 0;
6743 switch (BuiltinID) {
6746 case X86::BI__builtin_ia32_vcvttsd2si32:
6747 case X86::BI__builtin_ia32_vcvttsd2si64:
6748 case X86::BI__builtin_ia32_vcvttsd2usi32:
6749 case X86::BI__builtin_ia32_vcvttsd2usi64:
6750 case X86::BI__builtin_ia32_vcvttss2si32:
6751 case X86::BI__builtin_ia32_vcvttss2si64:
6752 case X86::BI__builtin_ia32_vcvttss2usi32:
6753 case X86::BI__builtin_ia32_vcvttss2usi64:
6754 case X86::BI__builtin_ia32_vcvttsh2si32:
6755 case X86::BI__builtin_ia32_vcvttsh2si64:
6756 case X86::BI__builtin_ia32_vcvttsh2usi32:
6757 case X86::BI__builtin_ia32_vcvttsh2usi64:
6760 case X86::BI__builtin_ia32_maxpd512:
6761 case X86::BI__builtin_ia32_maxps512:
6762 case X86::BI__builtin_ia32_minpd512:
6763 case X86::BI__builtin_ia32_minps512:
6764 case X86::BI__builtin_ia32_maxph512:
6765 case X86::BI__builtin_ia32_minph512:
6768 case X86::BI__builtin_ia32_vcvtph2pd512_mask:
6769 case X86::BI__builtin_ia32_vcvtph2psx512_mask:
6770 case X86::BI__builtin_ia32_cvtps2pd512_mask:
6771 case X86::BI__builtin_ia32_cvttpd2dq512_mask:
6772 case X86::BI__builtin_ia32_cvttpd2qq512_mask:
6773 case X86::BI__builtin_ia32_cvttpd2udq512_mask:
6774 case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
6775 case X86::BI__builtin_ia32_cvttps2dq512_mask:
6776 case X86::BI__builtin_ia32_cvttps2qq512_mask:
6777 case X86::BI__builtin_ia32_cvttps2udq512_mask:
6778 case X86::BI__builtin_ia32_cvttps2uqq512_mask:
6779 case X86::BI__builtin_ia32_vcvttph2w512_mask:
6780 case X86::BI__builtin_ia32_vcvttph2uw512_mask:
6781 case X86::BI__builtin_ia32_vcvttph2dq512_mask:
6782 case X86::BI__builtin_ia32_vcvttph2udq512_mask:
6783 case X86::BI__builtin_ia32_vcvttph2qq512_mask:
6784 case X86::BI__builtin_ia32_vcvttph2uqq512_mask:
6785 case X86::BI__builtin_ia32_exp2pd_mask:
6786 case X86::BI__builtin_ia32_exp2ps_mask:
6787 case X86::BI__builtin_ia32_getexppd512_mask:
6788 case X86::BI__builtin_ia32_getexpps512_mask:
6789 case X86::BI__builtin_ia32_getexpph512_mask:
6790 case X86::BI__builtin_ia32_rcp28pd_mask:
6791 case X86::BI__builtin_ia32_rcp28ps_mask:
6792 case X86::BI__builtin_ia32_rsqrt28pd_mask:
6793 case X86::BI__builtin_ia32_rsqrt28ps_mask:
6794 case X86::BI__builtin_ia32_vcomisd:
6795 case X86::BI__builtin_ia32_vcomiss:
6796 case X86::BI__builtin_ia32_vcomish:
6797 case X86::BI__builtin_ia32_vcvtph2ps512_mask:
6800 case X86::BI__builtin_ia32_cmppd512_mask:
6801 case X86::BI__builtin_ia32_cmpps512_mask:
6802 case X86::BI__builtin_ia32_cmpsd_mask:
6803 case X86::BI__builtin_ia32_cmpss_mask:
6804 case X86::BI__builtin_ia32_cmpsh_mask:
6805 case X86::BI__builtin_ia32_vcvtsh2sd_round_mask:
6806 case X86::BI__builtin_ia32_vcvtsh2ss_round_mask:
6807 case X86::BI__builtin_ia32_cvtss2sd_round_mask:
6808 case X86::BI__builtin_ia32_getexpsd128_round_mask:
6809 case X86::BI__builtin_ia32_getexpss128_round_mask:
6810 case X86::BI__builtin_ia32_getexpsh128_round_mask:
6811 case X86::BI__builtin_ia32_getmantpd512_mask:
6812 case X86::BI__builtin_ia32_getmantps512_mask:
6813 case X86::BI__builtin_ia32_getmantph512_mask:
6814 case X86::BI__builtin_ia32_maxsd_round_mask:
6815 case X86::BI__builtin_ia32_maxss_round_mask:
6816 case X86::BI__builtin_ia32_maxsh_round_mask:
6817 case X86::BI__builtin_ia32_minsd_round_mask:
6818 case X86::BI__builtin_ia32_minss_round_mask:
6819 case X86::BI__builtin_ia32_minsh_round_mask:
6820 case X86::BI__builtin_ia32_rcp28sd_round_mask:
6821 case X86::BI__builtin_ia32_rcp28ss_round_mask:
6822 case X86::BI__builtin_ia32_reducepd512_mask:
6823 case X86::BI__builtin_ia32_reduceps512_mask:
6824 case X86::BI__builtin_ia32_reduceph512_mask:
6825 case X86::BI__builtin_ia32_rndscalepd_mask:
6826 case X86::BI__builtin_ia32_rndscaleps_mask:
6827 case X86::BI__builtin_ia32_rndscaleph_mask:
6828 case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
6829 case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
6832 case X86::BI__builtin_ia32_fixupimmpd512_mask:
6833 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
6834 case X86::BI__builtin_ia32_fixupimmps512_mask:
6835 case X86::BI__builtin_ia32_fixupimmps512_maskz:
6836 case X86::BI__builtin_ia32_fixupimmsd_mask:
6837 case X86::BI__builtin_ia32_fixupimmsd_maskz:
6838 case X86::BI__builtin_ia32_fixupimmss_mask:
6839 case X86::BI__builtin_ia32_fixupimmss_maskz:
6840 case X86::BI__builtin_ia32_getmantsd_round_mask:
6841 case X86::BI__builtin_ia32_getmantss_round_mask:
6842 case X86::BI__builtin_ia32_getmantsh_round_mask:
6843 case X86::BI__builtin_ia32_rangepd512_mask:
6844 case X86::BI__builtin_ia32_rangeps512_mask:
6845 case X86::BI__builtin_ia32_rangesd128_round_mask:
6846 case X86::BI__builtin_ia32_rangess128_round_mask:
6847 case X86::BI__builtin_ia32_reducesd_mask:
6848 case X86::BI__builtin_ia32_reducess_mask:
6849 case X86::BI__builtin_ia32_reducesh_mask:
6850 case X86::BI__builtin_ia32_rndscalesd_round_mask:
6851 case X86::BI__builtin_ia32_rndscaless_round_mask:
6852 case X86::BI__builtin_ia32_rndscalesh_round_mask:
6855 case X86::BI__builtin_ia32_vcvtsd2si64:
6856 case X86::BI__builtin_ia32_vcvtsd2si32:
6857 case X86::BI__builtin_ia32_vcvtsd2usi32:
6858 case X86::BI__builtin_ia32_vcvtsd2usi64:
6859 case X86::BI__builtin_ia32_vcvtss2si32:
6860 case X86::BI__builtin_ia32_vcvtss2si64:
6861 case X86::BI__builtin_ia32_vcvtss2usi32:
6862 case X86::BI__builtin_ia32_vcvtss2usi64:
6863 case X86::BI__builtin_ia32_vcvtsh2si32:
6864 case X86::BI__builtin_ia32_vcvtsh2si64:
6865 case X86::BI__builtin_ia32_vcvtsh2usi32:
6866 case X86::BI__builtin_ia32_vcvtsh2usi64:
6867 case X86::BI__builtin_ia32_sqrtpd512:
6868 case X86::BI__builtin_ia32_sqrtps512:
6869 case X86::BI__builtin_ia32_sqrtph512:
6873 case X86::BI__builtin_ia32_addph512:
6874 case X86::BI__builtin_ia32_divph512:
6875 case X86::BI__builtin_ia32_mulph512:
6876 case X86::BI__builtin_ia32_subph512:
6877 case X86::BI__builtin_ia32_addpd512:
6878 case X86::BI__builtin_ia32_addps512:
6879 case X86::BI__builtin_ia32_divpd512:
6880 case X86::BI__builtin_ia32_divps512:
6881 case X86::BI__builtin_ia32_mulpd512:
6882 case X86::BI__builtin_ia32_mulps512:
6883 case X86::BI__builtin_ia32_subpd512:
6884 case X86::BI__builtin_ia32_subps512:
6885 case X86::BI__builtin_ia32_cvtsi2sd64:
6886 case X86::BI__builtin_ia32_cvtsi2ss32:
6887 case X86::BI__builtin_ia32_cvtsi2ss64:
6888 case X86::BI__builtin_ia32_cvtusi2sd64:
6889 case X86::BI__builtin_ia32_cvtusi2ss32:
6890 case X86::BI__builtin_ia32_cvtusi2ss64:
6891 case X86::BI__builtin_ia32_vcvtusi2sh:
6892 case X86::BI__builtin_ia32_vcvtusi642sh:
6893 case X86::BI__builtin_ia32_vcvtsi2sh:
6894 case X86::BI__builtin_ia32_vcvtsi642sh:
6898 case X86::BI__builtin_ia32_cvtdq2ps512_mask:
6899 case X86::BI__builtin_ia32_cvtudq2ps512_mask:
6900 case X86::BI__builtin_ia32_vcvtpd2ph512_mask:
6901 case X86::BI__builtin_ia32_vcvtps2phx512_mask:
6902 case X86::BI__builtin_ia32_cvtpd2ps512_mask:
6903 case X86::BI__builtin_ia32_cvtpd2dq512_mask:
6904 case X86::BI__builtin_ia32_cvtpd2qq512_mask:
6905 case X86::BI__builtin_ia32_cvtpd2udq512_mask:
6906 case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
6907 case X86::BI__builtin_ia32_cvtps2dq512_mask:
6908 case X86::BI__builtin_ia32_cvtps2qq512_mask:
6909 case X86::BI__builtin_ia32_cvtps2udq512_mask:
6910 case X86::BI__builtin_ia32_cvtps2uqq512_mask:
6911 case X86::BI__builtin_ia32_cvtqq2pd512_mask:
6912 case X86::BI__builtin_ia32_cvtqq2ps512_mask:
6913 case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
6914 case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
6915 case X86::BI__builtin_ia32_vcvtdq2ph512_mask:
6916 case X86::BI__builtin_ia32_vcvtudq2ph512_mask:
6917 case X86::BI__builtin_ia32_vcvtw2ph512_mask:
6918 case X86::BI__builtin_ia32_vcvtuw2ph512_mask:
6919 case X86::BI__builtin_ia32_vcvtph2w512_mask:
6920 case X86::BI__builtin_ia32_vcvtph2uw512_mask:
6921 case X86::BI__builtin_ia32_vcvtph2dq512_mask:
6922 case X86::BI__builtin_ia32_vcvtph2udq512_mask:
6923 case X86::BI__builtin_ia32_vcvtph2qq512_mask:
6924 case X86::BI__builtin_ia32_vcvtph2uqq512_mask:
6925 case X86::BI__builtin_ia32_vcvtqq2ph512_mask:
6926 case X86::BI__builtin_ia32_vcvtuqq2ph512_mask:
6930 case X86::BI__builtin_ia32_addsh_round_mask:
6931 case X86::BI__builtin_ia32_addss_round_mask:
6932 case X86::BI__builtin_ia32_addsd_round_mask:
6933 case X86::BI__builtin_ia32_divsh_round_mask:
6934 case X86::BI__builtin_ia32_divss_round_mask:
6935 case X86::BI__builtin_ia32_divsd_round_mask:
6936 case X86::BI__builtin_ia32_mulsh_round_mask:
6937 case X86::BI__builtin_ia32_mulss_round_mask:
6938 case X86::BI__builtin_ia32_mulsd_round_mask:
6939 case X86::BI__builtin_ia32_subsh_round_mask:
6940 case X86::BI__builtin_ia32_subss_round_mask:
6941 case X86::BI__builtin_ia32_subsd_round_mask:
6942 case X86::BI__builtin_ia32_scalefph512_mask:
6943 case X86::BI__builtin_ia32_scalefpd512_mask:
6944 case X86::BI__builtin_ia32_scalefps512_mask:
6945 case X86::BI__builtin_ia32_scalefsd_round_mask:
6946 case X86::BI__builtin_ia32_scalefss_round_mask:
6947 case X86::BI__builtin_ia32_scalefsh_round_mask:
6948 case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
6949 case X86::BI__builtin_ia32_vcvtss2sh_round_mask:
6950 case X86::BI__builtin_ia32_vcvtsd2sh_round_mask:
6951 case X86::BI__builtin_ia32_sqrtsd_round_mask:
6952 case X86::BI__builtin_ia32_sqrtss_round_mask:
6953 case X86::BI__builtin_ia32_sqrtsh_round_mask:
6954 case X86::BI__builtin_ia32_vfmaddsd3_mask:
6955 case X86::BI__builtin_ia32_vfmaddsd3_maskz:
6956 case X86::BI__builtin_ia32_vfmaddsd3_mask3:
6957 case X86::BI__builtin_ia32_vfmaddss3_mask:
6958 case X86::BI__builtin_ia32_vfmaddss3_maskz:
6959 case X86::BI__builtin_ia32_vfmaddss3_mask3:
6960 case X86::BI__builtin_ia32_vfmaddsh3_mask:
6961 case X86::BI__builtin_ia32_vfmaddsh3_maskz:
6962 case X86::BI__builtin_ia32_vfmaddsh3_mask3:
6963 case X86::BI__builtin_ia32_vfmaddpd512_mask:
6964 case X86::BI__builtin_ia32_vfmaddpd512_maskz:
6965 case X86::BI__builtin_ia32_vfmaddpd512_mask3:
6966 case X86::BI__builtin_ia32_vfmsubpd512_mask3:
6967 case X86::BI__builtin_ia32_vfmaddps512_mask:
6968 case X86::BI__builtin_ia32_vfmaddps512_maskz:
6969 case X86::BI__builtin_ia32_vfmaddps512_mask3:
6970 case X86::BI__builtin_ia32_vfmsubps512_mask3:
6971 case X86::BI__builtin_ia32_vfmaddph512_mask:
6972 case X86::BI__builtin_ia32_vfmaddph512_maskz:
6973 case X86::BI__builtin_ia32_vfmaddph512_mask3:
6974 case X86::BI__builtin_ia32_vfmsubph512_mask3:
6975 case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
6976 case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
6977 case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
6978 case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
6979 case X86::BI__builtin_ia32_vfmaddsubps512_mask:
6980 case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
6981 case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
6982 case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
6983 case X86::BI__builtin_ia32_vfmaddsubph512_mask:
6984 case X86::BI__builtin_ia32_vfmaddsubph512_maskz:
6985 case X86::BI__builtin_ia32_vfmaddsubph512_mask3:
6986 case X86::BI__builtin_ia32_vfmsubaddph512_mask3:
6987 case X86::BI__builtin_ia32_vfmaddcsh_mask:
6988 case X86::BI__builtin_ia32_vfmaddcsh_round_mask:
6989 case X86::BI__builtin_ia32_vfmaddcsh_round_mask3:
6990 case X86::BI__builtin_ia32_vfmaddcph512_mask:
6991 case X86::BI__builtin_ia32_vfmaddcph512_maskz:
6992 case X86::BI__builtin_ia32_vfmaddcph512_mask3:
6993 case X86::BI__builtin_ia32_vfcmaddcsh_mask:
6994 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask:
6995 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask3:
6996 case X86::BI__builtin_ia32_vfcmaddcph512_mask:
6997 case X86::BI__builtin_ia32_vfcmaddcph512_maskz:
6998 case X86::BI__builtin_ia32_vfcmaddcph512_mask3:
6999 case X86::BI__builtin_ia32_vfmulcsh_mask:
7000 case X86::BI__builtin_ia32_vfmulcph512_mask:
7001 case X86::BI__builtin_ia32_vfcmulcsh_mask:
7002 case X86::BI__builtin_ia32_vfcmulcph512_mask:
7016 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7025 (!HasRC &&
Result == 12) ||
7026 (HasRC &&
Result.getZExtValue() >= 8 &&
Result.getZExtValue() <= 11))
7029 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
7034bool Sema::CheckX86BuiltinGatherScatterScale(
unsigned BuiltinID,
7036 unsigned ArgNum = 0;
7037 switch (BuiltinID) {
7040 case X86::BI__builtin_ia32_gatherpfdpd:
7041 case X86::BI__builtin_ia32_gatherpfdps:
7042 case X86::BI__builtin_ia32_gatherpfqpd:
7043 case X86::BI__builtin_ia32_gatherpfqps:
7044 case X86::BI__builtin_ia32_scatterpfdpd:
7045 case X86::BI__builtin_ia32_scatterpfdps:
7046 case X86::BI__builtin_ia32_scatterpfqpd:
7047 case X86::BI__builtin_ia32_scatterpfqps:
7050 case X86::BI__builtin_ia32_gatherd_pd:
7051 case X86::BI__builtin_ia32_gatherd_pd256:
7052 case X86::BI__builtin_ia32_gatherq_pd:
7053 case X86::BI__builtin_ia32_gatherq_pd256:
7054 case X86::BI__builtin_ia32_gatherd_ps:
7055 case X86::BI__builtin_ia32_gatherd_ps256:
7056 case X86::BI__builtin_ia32_gatherq_ps:
7057 case X86::BI__builtin_ia32_gatherq_ps256:
7058 case X86::BI__builtin_ia32_gatherd_q:
7059 case X86::BI__builtin_ia32_gatherd_q256:
7060 case X86::BI__builtin_ia32_gatherq_q:
7061 case X86::BI__builtin_ia32_gatherq_q256:
7062 case X86::BI__builtin_ia32_gatherd_d:
7063 case X86::BI__builtin_ia32_gatherd_d256:
7064 case X86::BI__builtin_ia32_gatherq_d:
7065 case X86::BI__builtin_ia32_gatherq_d256:
7066 case X86::BI__builtin_ia32_gather3div2df:
7067 case X86::BI__builtin_ia32_gather3div2di:
7068 case X86::BI__builtin_ia32_gather3div4df:
7069 case X86::BI__builtin_ia32_gather3div4di:
7070 case X86::BI__builtin_ia32_gather3div4sf:
7071 case X86::BI__builtin_ia32_gather3div4si:
7072 case X86::BI__builtin_ia32_gather3div8sf:
7073 case X86::BI__builtin_ia32_gather3div8si:
7074 case X86::BI__builtin_ia32_gather3siv2df:
7075 case X86::BI__builtin_ia32_gather3siv2di:
7076 case X86::BI__builtin_ia32_gather3siv4df:
7077 case X86::BI__builtin_ia32_gather3siv4di:
7078 case X86::BI__builtin_ia32_gather3siv4sf:
7079 case X86::BI__builtin_ia32_gather3siv4si:
7080 case X86::BI__builtin_ia32_gather3siv8sf:
7081 case X86::BI__builtin_ia32_gather3siv8si:
7082 case X86::BI__builtin_ia32_gathersiv8df:
7083 case X86::BI__builtin_ia32_gathersiv16sf:
7084 case X86::BI__builtin_ia32_gatherdiv8df:
7085 case X86::BI__builtin_ia32_gatherdiv16sf:
7086 case X86::BI__builtin_ia32_gathersiv8di:
7087 case X86::BI__builtin_ia32_gathersiv16si:
7088 case X86::BI__builtin_ia32_gatherdiv8di:
7089 case X86::BI__builtin_ia32_gatherdiv16si:
7090 case X86::BI__builtin_ia32_scatterdiv2df:
7091 case X86::BI__builtin_ia32_scatterdiv2di:
7092 case X86::BI__builtin_ia32_scatterdiv4df:
7093 case X86::BI__builtin_ia32_scatterdiv4di:
7094 case X86::BI__builtin_ia32_scatterdiv4sf:
7095 case X86::BI__builtin_ia32_scatterdiv4si:
7096 case X86::BI__builtin_ia32_scatterdiv8sf:
7097 case X86::BI__builtin_ia32_scatterdiv8si:
7098 case X86::BI__builtin_ia32_scattersiv2df:
7099 case X86::BI__builtin_ia32_scattersiv2di:
7100 case X86::BI__builtin_ia32_scattersiv4df:
7101 case X86::BI__builtin_ia32_scattersiv4di:
7102 case X86::BI__builtin_ia32_scattersiv4sf:
7103 case X86::BI__builtin_ia32_scattersiv4si:
7104 case X86::BI__builtin_ia32_scattersiv8sf:
7105 case X86::BI__builtin_ia32_scattersiv8si:
7106 case X86::BI__builtin_ia32_scattersiv8df:
7107 case X86::BI__builtin_ia32_scattersiv16sf:
7108 case X86::BI__builtin_ia32_scatterdiv8df:
7109 case X86::BI__builtin_ia32_scatterdiv16sf:
7110 case X86::BI__builtin_ia32_scattersiv8di:
7111 case X86::BI__builtin_ia32_scattersiv16si:
7112 case X86::BI__builtin_ia32_scatterdiv8di:
7113 case X86::BI__builtin_ia32_scatterdiv16si:
7126 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7132 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_scale)
7138bool Sema::CheckX86BuiltinTileArgumentsRange(
CallExpr *TheCall,
7140 for (
int ArgNum : ArgNums) {
7147bool Sema::CheckX86BuiltinTileDuplicate(
CallExpr *TheCall,
7151 std::bitset<TileRegHigh + 1> ArgValues;
7152 for (
int ArgNum : ArgNums) {
7158 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7160 int ArgExtValue =
Result.getExtValue();
7162 "Incorrect tile register num.");
7163 if (ArgValues.test(ArgExtValue))
7165 diag::err_x86_builtin_tile_arg_duplicate)
7167 ArgValues.set(ArgExtValue);
7172bool Sema::CheckX86BuiltinTileRangeAndDuplicate(
CallExpr *TheCall,
7174 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
7175 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
7178bool Sema::CheckX86BuiltinTileArguments(
unsigned BuiltinID,
CallExpr *TheCall) {
7179 switch (BuiltinID) {
7182 case X86::BI__builtin_ia32_tileloadd64:
7183 case X86::BI__builtin_ia32_tileloaddt164:
7184 case X86::BI__builtin_ia32_tilestored64:
7185 case X86::BI__builtin_ia32_tilezero:
7186 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
7187 case X86::BI__builtin_ia32_tdpbssd:
7188 case X86::BI__builtin_ia32_tdpbsud:
7189 case X86::BI__builtin_ia32_tdpbusd:
7190 case X86::BI__builtin_ia32_tdpbuud:
7191 case X86::BI__builtin_ia32_tdpbf16ps:
7192 case X86::BI__builtin_ia32_tdpfp16ps:
7193 case X86::BI__builtin_ia32_tcmmimfp16ps:
7194 case X86::BI__builtin_ia32_tcmmrlfp16ps:
7195 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
7200 switch (BuiltinID) {
7201 case X86::BI__builtin_ia32_readeflags_u32:
7202 case X86::BI__builtin_ia32_writeeflags_u32:
7209bool Sema::CheckX86BuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
7212 const llvm::Triple &TT = TI.
getTriple();
7215 diag::err_32_bit_builtin_64_bit_tgt);
7218 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
7222 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
7226 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
7231 int i = 0, l = 0, u = 0;
7232 switch (BuiltinID) {
7235 case X86::BI__builtin_ia32_vec_ext_v2si:
7236 case X86::BI__builtin_ia32_vec_ext_v2di:
7237 case X86::BI__builtin_ia32_vextractf128_pd256:
7238 case X86::BI__builtin_ia32_vextractf128_ps256:
7239 case X86::BI__builtin_ia32_vextractf128_si256:
7240 case X86::BI__builtin_ia32_extract128i256:
7241 case X86::BI__builtin_ia32_extractf64x4_mask:
7242 case X86::BI__builtin_ia32_extracti64x4_mask:
7243 case X86::BI__builtin_ia32_extractf32x8_mask:
7244 case X86::BI__builtin_ia32_extracti32x8_mask:
7245 case X86::BI__builtin_ia32_extractf64x2_256_mask:
7246 case X86::BI__builtin_ia32_extracti64x2_256_mask:
7247 case X86::BI__builtin_ia32_extractf32x4_256_mask:
7248 case X86::BI__builtin_ia32_extracti32x4_256_mask:
7249 i = 1; l = 0; u = 1;
7251 case X86::BI__builtin_ia32_vec_set_v2di:
7252 case X86::BI__builtin_ia32_vinsertf128_pd256:
7253 case X86::BI__builtin_ia32_vinsertf128_ps256:
7254 case X86::BI__builtin_ia32_vinsertf128_si256:
7255 case X86::BI__builtin_ia32_insert128i256:
7256 case X86::BI__builtin_ia32_insertf32x8:
7257 case X86::BI__builtin_ia32_inserti32x8:
7258 case X86::BI__builtin_ia32_insertf64x4:
7259 case X86::BI__builtin_ia32_inserti64x4:
7260 case X86::BI__builtin_ia32_insertf64x2_256:
7261 case X86::BI__builtin_ia32_inserti64x2_256:
7262 case X86::BI__builtin_ia32_insertf32x4_256:
7263 case X86::BI__builtin_ia32_inserti32x4_256:
7264 i = 2; l = 0; u = 1;
7266 case X86::BI__builtin_ia32_vpermilpd:
7267 case X86::BI__builtin_ia32_vec_ext_v4hi:
7268 case X86::BI__builtin_ia32_vec_ext_v4si:
7269 case X86::BI__builtin_ia32_vec_ext_v4sf:
7270 case X86::BI__builtin_ia32_vec_ext_v4di:
7271 case X86::BI__builtin_ia32_extractf32x4_mask:
7272 case X86::BI__builtin_ia32_extracti32x4_mask:
7273 case X86::BI__builtin_ia32_extractf64x2_512_mask:
7274 case X86::BI__builtin_ia32_extracti64x2_512_mask:
7275 i = 1; l = 0; u = 3;
7277 case X86::BI_mm_prefetch:
7278 case X86::BI__builtin_ia32_vec_ext_v8hi:
7279 case X86::BI__builtin_ia32_vec_ext_v8si:
7280 i = 1; l = 0; u = 7;
7282 case X86::BI__builtin_ia32_sha1rnds4:
7283 case X86::BI__builtin_ia32_blendpd:
7284 case X86::BI__builtin_ia32_shufpd:
7285 case X86::BI__builtin_ia32_vec_set_v4hi:
7286 case X86::BI__builtin_ia32_vec_set_v4si:
7287 case X86::BI__builtin_ia32_vec_set_v4di:
7288 case X86::BI__builtin_ia32_shuf_f32x4_256:
7289 case X86::BI__builtin_ia32_shuf_f64x2_256:
7290 case X86::BI__builtin_ia32_shuf_i32x4_256:
7291 case X86::BI__builtin_ia32_shuf_i64x2_256:
7292 case X86::BI__builtin_ia32_insertf64x2_512:
7293 case X86::BI__builtin_ia32_inserti64x2_512:
7294 case X86::BI__builtin_ia32_insertf32x4:
7295 case X86::BI__builtin_ia32_inserti32x4:
7296 i = 2; l = 0; u = 3;
7298 case X86::BI__builtin_ia32_vpermil2pd:
7299 case X86::BI__builtin_ia32_vpermil2pd256:
7300 case X86::BI__builtin_ia32_vpermil2ps:
7301 case X86::BI__builtin_ia32_vpermil2ps256:
7302 i = 3; l = 0; u = 3;
7304 case X86::BI__builtin_ia32_cmpb128_mask:
7305 case X86::BI__builtin_ia32_cmpw128_mask:
7306 case X86::BI__builtin_ia32_cmpd128_mask:
7307 case X86::BI__builtin_ia32_cmpq128_mask:
7308 case X86::BI__builtin_ia32_cmpb256_mask:
7309 case X86::BI__builtin_ia32_cmpw256_mask:
7310 case X86::BI__builtin_ia32_cmpd256_mask:
7311 case X86::BI__builtin_ia32_cmpq256_mask:
7312 case X86::BI__builtin_ia32_cmpb512_mask:
7313 case X86::BI__builtin_ia32_cmpw512_mask:
7314 case X86::BI__builtin_ia32_cmpd512_mask:
7315 case X86::BI__builtin_ia32_cmpq512_mask:
7316 case X86::BI__builtin_ia32_ucmpb128_mask:
7317 case X86::BI__builtin_ia32_ucmpw128_mask:
7318 case X86::BI__builtin_ia32_ucmpd128_mask:
7319 case X86::BI__builtin_ia32_ucmpq128_mask:
7320 case X86::BI__builtin_ia32_ucmpb256_mask:
7321 case X86::BI__builtin_ia32_ucmpw256_mask:
7322 case X86::BI__builtin_ia32_ucmpd256_mask:
7323 case X86::BI__builtin_ia32_ucmpq256_mask:
7324 case X86::BI__builtin_ia32_ucmpb512_mask:
7325 case X86::BI__builtin_ia32_ucmpw512_mask:
7326 case X86::BI__builtin_ia32_ucmpd512_mask:
7327 case X86::BI__builtin_ia32_ucmpq512_mask:
7328 case X86::BI__builtin_ia32_vpcomub:
7329 case X86::BI__builtin_ia32_vpcomuw:
7330 case X86::BI__builtin_ia32_vpcomud:
7331 case X86::BI__builtin_ia32_vpcomuq:
7332 case X86::BI__builtin_ia32_vpcomb:
7333 case X86::BI__builtin_ia32_vpcomw:
7334 case X86::BI__builtin_ia32_vpcomd:
7335 case X86::BI__builtin_ia32_vpcomq:
7336 case X86::BI__builtin_ia32_vec_set_v8hi:
7337 case X86::BI__builtin_ia32_vec_set_v8si:
7338 i = 2; l = 0; u = 7;
7340 case X86::BI__builtin_ia32_vpermilpd256:
7341 case X86::BI__builtin_ia32_roundps:
7342 case X86::BI__builtin_ia32_roundpd:
7343 case X86::BI__builtin_ia32_roundps256:
7344 case X86::BI__builtin_ia32_roundpd256:
7345 case X86::BI__builtin_ia32_getmantpd128_mask:
7346 case X86::BI__builtin_ia32_getmantpd256_mask:
7347 case X86::BI__builtin_ia32_getmantps128_mask:
7348 case X86::BI__builtin_ia32_getmantps256_mask:
7349 case X86::BI__builtin_ia32_getmantpd512_mask:
7350 case X86::BI__builtin_ia32_getmantps512_mask:
7351 case X86::BI__builtin_ia32_getmantph128_mask:
7352 case X86::BI__builtin_ia32_getmantph256_mask:
7353 case X86::BI__builtin_ia32_getmantph512_mask:
7354 case X86::BI__builtin_ia32_vec_ext_v16qi:
7355 case X86::BI__builtin_ia32_vec_ext_v16hi:
7356 i = 1; l = 0; u = 15;
7358 case X86::BI__builtin_ia32_pblendd128:
7359 case X86::BI__builtin_ia32_blendps:
7360 case X86::BI__builtin_ia32_blendpd256:
7361 case X86::BI__builtin_ia32_shufpd256:
7362 case X86::BI__builtin_ia32_roundss:
7363 case X86::BI__builtin_ia32_roundsd:
7364 case X86::BI__builtin_ia32_rangepd128_mask:
7365 case X86::BI__builtin_ia32_rangepd256_mask:
7366 case X86::BI__builtin_ia32_rangepd512_mask:
7367 case X86::BI__builtin_ia32_rangeps128_mask:
7368 case X86::BI__builtin_ia32_rangeps256_mask:
7369 case X86::BI__builtin_ia32_rangeps512_mask:
7370 case X86::BI__builtin_ia32_getmantsd_round_mask:
7371 case X86::BI__builtin_ia32_getmantss_round_mask:
7372 case X86::BI__builtin_ia32_getmantsh_round_mask:
7373 case X86::BI__builtin_ia32_vec_set_v16qi:
7374 case X86::BI__builtin_ia32_vec_set_v16hi:
7375 i = 2; l = 0; u = 15;
7377 case X86::BI__builtin_ia32_vec_ext_v32qi:
7378 i = 1; l = 0; u = 31;
7380 case X86::BI__builtin_ia32_cmpps:
7381 case X86::BI__builtin_ia32_cmpss:
7382 case X86::BI__builtin_ia32_cmppd:
7383 case X86::BI__builtin_ia32_cmpsd:
7384 case X86::BI__builtin_ia32_cmpps256:
7385 case X86::BI__builtin_ia32_cmppd256:
7386 case X86::BI__builtin_ia32_cmpps128_mask:
7387 case X86::BI__builtin_ia32_cmppd128_mask:
7388 case X86::BI__builtin_ia32_cmpps256_mask:
7389 case X86::BI__builtin_ia32_cmppd256_mask:
7390 case X86::BI__builtin_ia32_cmpps512_mask:
7391 case X86::BI__builtin_ia32_cmppd512_mask:
7392 case X86::BI__builtin_ia32_cmpsd_mask:
7393 case X86::BI__builtin_ia32_cmpss_mask:
7394 case X86::BI__builtin_ia32_vec_set_v32qi:
7395 i = 2; l = 0; u = 31;
7397 case X86::BI__builtin_ia32_permdf256:
7398 case X86::BI__builtin_ia32_permdi256:
7399 case X86::BI__builtin_ia32_permdf512:
7400 case X86::BI__builtin_ia32_permdi512:
7401 case X86::BI__builtin_ia32_vpermilps:
7402 case X86::BI__builtin_ia32_vpermilps256:
7403 case X86::BI__builtin_ia32_vpermilpd512:
7404 case X86::BI__builtin_ia32_vpermilps512:
7405 case X86::BI__builtin_ia32_pshufd:
7406 case X86::BI__builtin_ia32_pshufd256:
7407 case X86::BI__builtin_ia32_pshufd512:
7408 case X86::BI__builtin_ia32_pshufhw:
7409 case X86::BI__builtin_ia32_pshufhw256:
7410 case X86::BI__builtin_ia32_pshufhw512:
7411 case X86::BI__builtin_ia32_pshuflw:
7412 case X86::BI__builtin_ia32_pshuflw256:
7413 case X86::BI__builtin_ia32_pshuflw512:
7414 case X86::BI__builtin_ia32_vcvtps2ph:
7415 case X86::BI__builtin_ia32_vcvtps2ph_mask:
7416 case X86::BI__builtin_ia32_vcvtps2ph256:
7417 case X86::BI__builtin_ia32_vcvtps2ph256_mask:
7418 case X86::BI__builtin_ia32_vcvtps2ph512_mask:
7419 case X86::BI__builtin_ia32_rndscaleps_128_mask:
7420 case X86::BI__builtin_ia32_rndscalepd_128_mask:
7421 case X86::BI__builtin_ia32_rndscaleps_256_mask:
7422 case X86::BI__builtin_ia32_rndscalepd_256_mask:
7423 case X86::BI__builtin_ia32_rndscaleps_mask:
7424 case X86::BI__builtin_ia32_rndscalepd_mask:
7425 case X86::BI__builtin_ia32_rndscaleph_mask:
7426 case X86::BI__builtin_ia32_reducepd128_mask:
7427 case X86::BI__builtin_ia32_reducepd256_mask:
7428 case X86::BI__builtin_ia32_reducepd512_mask:
7429 case X86::BI__builtin_ia32_reduceps128_mask:
7430 case X86::BI__builtin_ia32_reduceps256_mask:
7431 case X86::BI__builtin_ia32_reduceps512_mask:
7432 case X86::BI__builtin_ia32_reduceph128_mask:
7433 case X86::BI__builtin_ia32_reduceph256_mask:
7434 case X86::BI__builtin_ia32_reduceph512_mask:
7435 case X86::BI__builtin_ia32_prold512:
7436 case X86::BI__builtin_ia32_prolq512:
7437 case X86::BI__builtin_ia32_prold128:
7438 case X86::BI__builtin_ia32_prold256:
7439 case X86::BI__builtin_ia32_prolq128:
7440 case X86::BI__builtin_ia32_prolq256:
7441 case X86::BI__builtin_ia32_prord512:
7442 case X86::BI__builtin_ia32_prorq512:
7443 case X86::BI__builtin_ia32_prord128:
7444 case X86::BI__builtin_ia32_prord256:
7445 case X86::BI__builtin_ia32_prorq128:
7446 case X86::BI__builtin_ia32_prorq256:
7447 case X86::BI__builtin_ia32_fpclasspd128_mask:
7448 case X86::BI__builtin_ia32_fpclasspd256_mask:
7449 case X86::BI__builtin_ia32_fpclassps128_mask:
7450 case X86::BI__builtin_ia32_fpclassps256_mask:
7451 case X86::BI__builtin_ia32_fpclassps512_mask:
7452 case X86::BI__builtin_ia32_fpclasspd512_mask:
7453 case X86::BI__builtin_ia32_fpclassph128_mask:
7454 case X86::BI__builtin_ia32_fpclassph256_mask:
7455 case X86::BI__builtin_ia32_fpclassph512_mask:
7456 case X86::BI__builtin_ia32_fpclasssd_mask:
7457 case X86::BI__builtin_ia32_fpclassss_mask:
7458 case X86::BI__builtin_ia32_fpclasssh_mask:
7459 case X86::BI__builtin_ia32_pslldqi128_byteshift:
7460 case X86::BI__builtin_ia32_pslldqi256_byteshift:
7461 case X86::BI__builtin_ia32_pslldqi512_byteshift:
7462 case X86::BI__builtin_ia32_psrldqi128_byteshift:
7463 case X86::BI__builtin_ia32_psrldqi256_byteshift:
7464 case X86::BI__builtin_ia32_psrldqi512_byteshift:
7465 case X86::BI__builtin_ia32_kshiftliqi:
7466 case X86::BI__builtin_ia32_kshiftlihi:
7467 case X86::BI__builtin_ia32_kshiftlisi:
7468 case X86::BI__builtin_ia32_kshiftlidi:
7469 case X86::BI__builtin_ia32_kshiftriqi:
7470 case X86::BI__builtin_ia32_kshiftrihi:
7471 case X86::BI__builtin_ia32_kshiftrisi:
7472 case X86::BI__builtin_ia32_kshiftridi:
7473 i = 1; l = 0; u = 255;
7475 case X86::BI__builtin_ia32_vperm2f128_pd256:
7476 case X86::BI__builtin_ia32_vperm2f128_ps256:
7477 case X86::BI__builtin_ia32_vperm2f128_si256:
7478 case X86::BI__builtin_ia32_permti256:
7479 case X86::BI__builtin_ia32_pblendw128:
7480 case X86::BI__builtin_ia32_pblendw256:
7481 case X86::BI__builtin_ia32_blendps256:
7482 case X86::BI__builtin_ia32_pblendd256:
7483 case X86::BI__builtin_ia32_palignr128:
7484 case X86::BI__builtin_ia32_palignr256:
7485 case X86::BI__builtin_ia32_palignr512:
7486 case X86::BI__builtin_ia32_alignq512:
7487 case X86::BI__builtin_ia32_alignd512:
7488 case X86::BI__builtin_ia32_alignd128:
7489 case X86::BI__builtin_ia32_alignd256:
7490 case X86::BI__builtin_ia32_alignq128:
7491 case X86::BI__builtin_ia32_alignq256:
7492 case X86::BI__builtin_ia32_vcomisd:
7493 case X86::BI__builtin_ia32_vcomiss:
7494 case X86::BI__builtin_ia32_shuf_f32x4:
7495 case X86::BI__builtin_ia32_shuf_f64x2:
7496 case X86::BI__builtin_ia32_shuf_i32x4:
7497 case X86::BI__builtin_ia32_shuf_i64x2:
7498 case X86::BI__builtin_ia32_shufpd512:
7499 case X86::BI__builtin_ia32_shufps:
7500 case X86::BI__builtin_ia32_shufps256:
7501 case X86::BI__builtin_ia32_shufps512:
7502 case X86::BI__builtin_ia32_dbpsadbw128:
7503 case X86::BI__builtin_ia32_dbpsadbw256:
7504 case X86::BI__builtin_ia32_dbpsadbw512:
7505 case X86::BI__builtin_ia32_vpshldd128:
7506 case X86::BI__builtin_ia32_vpshldd256:
7507 case X86::BI__builtin_ia32_vpshldd512:
7508 case X86::BI__builtin_ia32_vpshldq128:
7509 case X86::BI__builtin_ia32_vpshldq256:
7510 case X86::BI__builtin_ia32_vpshldq512:
7511 case X86::BI__builtin_ia32_vpshldw128:
7512 case X86::BI__builtin_ia32_vpshldw256:
7513 case X86::BI__builtin_ia32_vpshldw512:
7514 case X86::BI__builtin_ia32_vpshrdd128:
7515 case X86::BI__builtin_ia32_vpshrdd256:
7516 case X86::BI__builtin_ia32_vpshrdd512:
7517 case X86::BI__builtin_ia32_vpshrdq128:
7518 case X86::BI__builtin_ia32_vpshrdq256:
7519 case X86::BI__builtin_ia32_vpshrdq512:
7520 case X86::BI__builtin_ia32_vpshrdw128:
7521 case X86::BI__builtin_ia32_vpshrdw256:
7522 case X86::BI__builtin_ia32_vpshrdw512:
7523 i = 2; l = 0; u = 255;
7525 case X86::BI__builtin_ia32_fixupimmpd512_mask:
7526 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
7527 case X86::BI__builtin_ia32_fixupimmps512_mask:
7528 case X86::BI__builtin_ia32_fixupimmps512_maskz:
7529 case X86::BI__builtin_ia32_fixupimmsd_mask:
7530 case X86::BI__builtin_ia32_fixupimmsd_maskz:
7531 case X86::BI__builtin_ia32_fixupimmss_mask:
7532 case X86::BI__builtin_ia32_fixupimmss_maskz:
7533 case X86::BI__builtin_ia32_fixupimmpd128_mask:
7534 case X86::BI__builtin_ia32_fixupimmpd128_maskz:
7535 case X86::BI__builtin_ia32_fixupimmpd256_mask:
7536 case X86::BI__builtin_ia32_fixupimmpd256_maskz:
7537 case X86::BI__builtin_ia32_fixupimmps128_mask:
7538 case X86::BI__builtin_ia32_fixupimmps128_maskz:
7539 case X86::BI__builtin_ia32_fixupimmps256_mask:
7540 case X86::BI__builtin_ia32_fixupimmps256_maskz:
7541 case X86::BI__builtin_ia32_pternlogd512_mask:
7542 case X86::BI__builtin_ia32_pternlogd512_maskz:
7543 case X86::BI__builtin_ia32_pternlogq512_mask:
7544 case X86::BI__builtin_ia32_pternlogq512_maskz:
7545 case X86::BI__builtin_ia32_pternlogd128_mask:
7546 case X86::BI__builtin_ia32_pternlogd128_maskz:
7547 case X86::BI__builtin_ia32_pternlogd256_mask:
7548 case X86::BI__builtin_ia32_pternlogd256_maskz:
7549 case X86::BI__builtin_ia32_pternlogq128_mask:
7550 case X86::BI__builtin_ia32_pternlogq128_maskz:
7551 case X86::BI__builtin_ia32_pternlogq256_mask:
7552 case X86::BI__builtin_ia32_pternlogq256_maskz:
7553 case X86::BI__builtin_ia32_vsm3rnds2:
7554 i = 3; l = 0; u = 255;
7556 case X86::BI__builtin_ia32_gatherpfdpd:
7557 case X86::BI__builtin_ia32_gatherpfdps:
7558 case X86::BI__builtin_ia32_gatherpfqpd:
7559 case X86::BI__builtin_ia32_gatherpfqps:
7560 case X86::BI__builtin_ia32_scatterpfdpd:
7561 case X86::BI__builtin_ia32_scatterpfdps:
7562 case X86::BI__builtin_ia32_scatterpfqpd:
7563 case X86::BI__builtin_ia32_scatterpfqps:
7564 i = 4; l = 2; u = 3;
7566 case X86::BI__builtin_ia32_reducesd_mask:
7567 case X86::BI__builtin_ia32_reducess_mask:
7568 case X86::BI__builtin_ia32_rndscalesd_round_mask:
7569 case X86::BI__builtin_ia32_rndscaless_round_mask:
7570 case X86::BI__builtin_ia32_rndscalesh_round_mask:
7571 case X86::BI__builtin_ia32_reducesh_mask:
7572 i = 4; l = 0; u = 255;
7574 case X86::BI__builtin_ia32_cmpccxadd32:
7575 case X86::BI__builtin_ia32_cmpccxadd64:
7576 i = 3; l = 0; u = 15;
7584 return BuiltinConstantArgRange(TheCall, i, l, u,
false);
7593 if (Format->getFirstArg() == 0)
7595 else if (IsVariadic)
7599 FSI->
FormatIdx = Format->getFormatIdx() - 1;
7623 if (isa<CXXNullPtrLiteralExpr>(
7638 if (
const auto *CLE = dyn_cast<CompoundLiteralExpr>(
Expr))
7639 if (
const auto *ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))
7640 Expr = ILE->getInit(0);
7650 const Expr *ArgExpr,
7654 S.
PDiag(diag::warn_null_arg)
7676 bool Format =
false;
7689 if (!Format || NumArgs <= Idx)
7691 const Expr *FormatExpr = Args[Idx];
7692 if (
const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
7693 FormatExpr = CSCE->getSubExpr();
7703 S.
Diag(FormatExpr->
getExprLoc(), diag::warn_objc_cdirective_format_string)
7712 if (
auto nullability =
type->getNullability())
7723 assert((FDecl || Proto) &&
"Need a function declaration or prototype");
7729 llvm::SmallBitVector NonNullArgs;
7735 for (
const auto *Arg : Args)
7742 unsigned IdxAST = Idx.getASTIndex();
7743 if (IdxAST >= Args.size())
7745 if (NonNullArgs.empty())
7746 NonNullArgs.resize(Args.size());
7747 NonNullArgs.set(IdxAST);
7752 if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
7756 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
7759 parms = cast<ObjCMethodDecl>(FDecl)->parameters();
7761 unsigned ParamIndex = 0;
7763 I != E; ++I, ++ParamIndex) {
7766 if (NonNullArgs.empty())
7767 NonNullArgs.resize(Args.size());
7769 NonNullArgs.set(ParamIndex);
7776 if (
const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
7781 type = blockType->getPointeeType();
7795 if (NonNullArgs.empty())
7796 NonNullArgs.resize(Args.size());
7798 NonNullArgs.set(Index);
7807 for (
unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
7808 ArgIndex != ArgIndexEnd; ++ArgIndex) {
7809 if (NonNullArgs[ArgIndex])
7822 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->
IgnoreParens());
7826 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
7830 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
7831 if (!PD || !PD->getType()->isRecordType())
7837 if (
const auto *AA = FD->
getAttr<AlignedAttr>()) {
7842 Diag(Loc, diag::note_misaligned_member_used_here) << PD;
7853 StringRef ParamName,
QualType ArgTy,
7881 if (ArgAlign < ParamAlign)
7882 Diag(Loc, diag::warn_param_mismatched_alignment)
7884 << ParamName << (FDecl !=
nullptr) << FDecl;
7899 llvm::SmallBitVector CheckedVarArgs;
7903 CheckedVarArgs.resize(Args.size());
7905 CheckFormatArguments(I, Args, IsMemberFunction, CallType, Loc, Range,
7912 auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
7916 : FDecl && isa<FunctionDecl>(FDecl)
7917 ? cast<FunctionDecl>(FDecl)->getNumParams()
7918 : FDecl && isa<ObjCMethodDecl>(FDecl)
7919 ? cast<ObjCMethodDecl>(FDecl)->param_size()
7922 for (
unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
7924 if (
const Expr *Arg = Args[ArgIdx]) {
7925 if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
7931 if (FDecl || Proto) {
7936 for (
const auto *I : FDecl->
specific_attrs<ArgumentWithTypeTagAttr>())
7937 CheckArgumentWithTypeTag(I, Args, Loc);
7943 if (!Proto && FDecl) {
7945 if (isa_and_nonnull<FunctionProtoType>(FT))
7951 const auto N = std::min<unsigned>(Proto->
getNumParams(), Args.size());
7952 for (
unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
7954 if (
const Expr *Arg = Args[ArgIdx]) {
7962 checkAIXMemberAlignment((Arg->
getExprLoc()), Arg);
7966 CheckArgAlignment(Arg->
getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
7975 if (
auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext)) {
7976 llvm::StringMap<bool> CallerFeatureMap;
7978 if (!CallerFeatureMap.contains(
"sme"))
7979 Diag(Loc, diag::err_sme_call_in_non_sme_target);
7981 Diag(Loc, diag::err_sme_call_in_non_sme_target);
7991 bool CallerHasZAState =
false;
7992 bool CallerHasZT0State =
false;
7993 if (
const auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext)) {
7994 auto *
Attr = CallerFD->getAttr<ArmNewAttr>();
7996 CallerHasZAState =
true;
7998 CallerHasZT0State =
true;
8002 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8004 CallerHasZT0State |=
8006 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8012 Diag(Loc, diag::err_sme_za_call_no_za_state);
8015 Diag(Loc, diag::err_sme_zt0_call_no_zt0_state);
8019 Diag(Loc, diag::err_sme_unimplemented_za_save_restore);
8020 Diag(Loc, diag::note_sme_use_preserves_za);
8025 if (FDecl && FDecl->
hasAttr<AllocAlignAttr>()) {
8026 auto *AA = FDecl->
getAttr<AllocAlignAttr>();
8027 const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
8028 if (!Arg->isValueDependent()) {
8030 if (Arg->EvaluateAsInt(Align,
Context)) {
8031 const llvm::APSInt &I = Align.
Val.
getInt();
8032 if (!I.isPowerOf2())
8033 Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
8034 << Arg->getSourceRange();
8037 Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
8056 auto *Ctor = cast<CXXConstructorDecl>(FDecl);
8061 checkCall(FDecl, Proto,
nullptr, Args,
true,
8069 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
8070 isa<CXXMethodDecl>(FDecl);
8071 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
8072 IsMemberOperatorCall;
8078 Expr *ImplicitThis =
nullptr;
8083 ImplicitThis = Args[0];
8086 }
else if (IsMemberFunction && !FDecl->
isStatic() &&
8089 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
8101 cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());
8103 CheckArgAlignment(TheCall->
getRParenLoc(), FDecl,
"'this'", ThisType,
8107 checkCall(FDecl, Proto, ImplicitThis,
llvm::ArrayRef(Args, NumArgs),
8119 CheckTCBEnforcement(TheCall->
getExprLoc(), FDecl);
8121 CheckAbsoluteValueFunction(TheCall, FDecl);
8122 CheckMaxUnsignedZero(TheCall, FDecl);
8123 CheckInfNaNFunction(TheCall, FDecl);
8134 case Builtin::BIstrlcpy:
8135 case Builtin::BIstrlcat:
8136 CheckStrlcpycatArguments(TheCall, FnInfo);
8138 case Builtin::BIstrncat:
8139 CheckStrncatArguments(TheCall, FnInfo);
8141 case Builtin::BIfree:
8142 CheckFreeArguments(TheCall);
8145 CheckMemaccessArguments(TheCall, CMId, FnInfo);
8156 checkCall(Method,
nullptr,
nullptr, Args,
8160 CheckTCBEnforcement(lbrac, Method);
8168 if (
const auto *
V = dyn_cast<VarDecl>(NDecl))
8169 Ty =
V->getType().getNonReferenceType();
8170 else if (
const auto *F = dyn_cast<FieldDecl>(NDecl))
8171 Ty = F->getType().getNonReferenceType();
8188 checkCall(NDecl, Proto,
nullptr,
8201 checkCall(
nullptr, Proto,
nullptr,
8210 if (!llvm::isValidAtomicOrderingCABI(Ordering))
8213 auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
8215 case AtomicExpr::AO__c11_atomic_init:
8216 case AtomicExpr::AO__opencl_atomic_init:
8217 llvm_unreachable(
"There is no ordering argument for an init");
8219 case AtomicExpr::AO__c11_atomic_load:
8220 case AtomicExpr::AO__opencl_atomic_load:
8221 case AtomicExpr::AO__hip_atomic_load:
8222 case AtomicExpr::AO__atomic_load_n:
8223 case AtomicExpr::AO__atomic_load:
8224 case AtomicExpr::AO__scoped_atomic_load_n:
8225 case AtomicExpr::AO__scoped_atomic_load:
8226 return OrderingCABI != llvm::AtomicOrderingCABI::release &&
8227 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8229 case AtomicExpr::AO__c11_atomic_store:
8230 case AtomicExpr::AO__opencl_atomic_store:
8231 case AtomicExpr::AO__hip_atomic_store:
8232 case AtomicExpr::AO__atomic_store:
8233 case AtomicExpr::AO__atomic_store_n:
8234 case AtomicExpr::AO__scoped_atomic_store:
8235 case AtomicExpr::AO__scoped_atomic_store_n:
8236 return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
8237 OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
8238 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8247 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
8291 const unsigned NumForm = GNUCmpXchg + 1;
8292 const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
8293 const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
8301 static_assert(
sizeof(NumArgs)/
sizeof(NumArgs[0]) == NumForm
8302 &&
sizeof(NumVals)/
sizeof(NumVals[0]) == NumForm,
8303 "need to update code for modified forms");
8304 static_assert(AtomicExpr::AO__atomic_add_fetch == 0 &&
8305 AtomicExpr::AO__atomic_xor_fetch + 1 ==
8306 AtomicExpr::AO__c11_atomic_compare_exchange_strong,
8307 "need to update code for modified C11 atomics");
8308 bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&
8309 Op <= AtomicExpr::AO__opencl_atomic_store;
8310 bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
8311 Op <= AtomicExpr::AO__hip_atomic_store;
8312 bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&
8313 Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;
8314 bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
8315 Op <= AtomicExpr::AO__c11_atomic_store) ||
8317 bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
8318 Op == AtomicExpr::AO__atomic_store_n ||
8319 Op == AtomicExpr::AO__atomic_exchange_n ||
8320 Op == AtomicExpr::AO__atomic_compare_exchange_n ||
8321 Op == AtomicExpr::AO__scoped_atomic_load_n ||
8322 Op == AtomicExpr::AO__scoped_atomic_store_n ||
8323 Op == AtomicExpr::AO__scoped_atomic_exchange_n ||
8324 Op == AtomicExpr::AO__scoped_atomic_compare_exchange_n;
8328 enum ArithOpExtraValueType {
8333 unsigned ArithAllows = AOEVT_None;
8336 case AtomicExpr::AO__c11_atomic_init:
8337 case AtomicExpr::AO__opencl_atomic_init:
8341 case AtomicExpr::AO__c11_atomic_load:
8342 case AtomicExpr::AO__opencl_atomic_load:
8343 case AtomicExpr::AO__hip_atomic_load:
8344 case AtomicExpr::AO__atomic_load_n:
8345 case AtomicExpr::AO__scoped_atomic_load_n:
8349 case AtomicExpr::AO__atomic_load:
8350 case AtomicExpr::AO__scoped_atomic_load:
8354 case AtomicExpr::AO__c11_atomic_store:
8355 case AtomicExpr::AO__opencl_atomic_store:
8356 case AtomicExpr::AO__hip_atomic_store:
8357 case AtomicExpr::AO__atomic_store:
8358 case AtomicExpr::AO__atomic_store_n:
8359 case AtomicExpr::AO__scoped_atomic_store:
8360 case AtomicExpr::AO__scoped_atomic_store_n:
8363 case AtomicExpr::AO__atomic_fetch_add:
8364 case AtomicExpr::AO__atomic_fetch_sub:
8365 case AtomicExpr::AO__atomic_add_fetch:
8366 case AtomicExpr::AO__atomic_sub_fetch:
8367 case AtomicExpr::AO__scoped_atomic_fetch_add:
8368 case AtomicExpr::AO__scoped_atomic_fetch_sub:
8369 case AtomicExpr::AO__scoped_atomic_add_fetch:
8370 case AtomicExpr::AO__scoped_atomic_sub_fetch:
8371 case AtomicExpr::AO__c11_atomic_fetch_add:
8372 case AtomicExpr::AO__c11_atomic_fetch_sub:
8373 case AtomicExpr::AO__opencl_atomic_fetch_add:
8374 case AtomicExpr::AO__opencl_atomic_fetch_sub:
8375 case AtomicExpr::AO__hip_atomic_fetch_add:
8376 case AtomicExpr::AO__hip_atomic_fetch_sub:
8377 ArithAllows = AOEVT_Pointer | AOEVT_FP;
8380 case AtomicExpr::AO__atomic_fetch_max:
8381 case AtomicExpr::AO__atomic_fetch_min:
8382 case AtomicExpr::AO__atomic_max_fetch:
8383 case AtomicExpr::AO__atomic_min_fetch:
8384 case AtomicExpr::AO__scoped_atomic_fetch_max:
8385 case AtomicExpr::AO__scoped_atomic_fetch_min:
8386 case AtomicExpr::AO__scoped_atomic_max_fetch:
8387 case AtomicExpr::AO__scoped_atomic_min_fetch:
8388 case AtomicExpr::AO__c11_atomic_fetch_max:
8389 case AtomicExpr::AO__c11_atomic_fetch_min:
8390 case AtomicExpr::AO__opencl_atomic_fetch_max:
8391 case AtomicExpr::AO__opencl_atomic_fetch_min:
8392 case AtomicExpr::AO__hip_atomic_fetch_max:
8393 case AtomicExpr::AO__hip_atomic_fetch_min:
8394 ArithAllows = AOEVT_FP;
8397 case AtomicExpr::AO__c11_atomic_fetch_and:
8398 case AtomicExpr::AO__c11_atomic_fetch_or:
8399 case AtomicExpr::AO__c11_atomic_fetch_xor:
8400 case AtomicExpr::AO__hip_atomic_fetch_and:
8401 case AtomicExpr::AO__hip_atomic_fetch_or:
8402 case AtomicExpr::AO__hip_atomic_fetch_xor:
8403 case AtomicExpr::AO__c11_atomic_fetch_nand:
8404 case AtomicExpr::AO__opencl_atomic_fetch_and:
8405 case AtomicExpr::AO__opencl_atomic_fetch_or:
8406 case AtomicExpr::AO__opencl_atomic_fetch_xor:
8407 case AtomicExpr::AO__atomic_fetch_and:
8408 case AtomicExpr::AO__atomic_fetch_or:
8409 case AtomicExpr::AO__atomic_fetch_xor:
8410 case AtomicExpr::AO__atomic_fetch_nand:
8411 case AtomicExpr::AO__atomic_and_fetch:
8412 case AtomicExpr::AO__atomic_or_fetch:
8413 case AtomicExpr::AO__atomic_xor_fetch:
8414 case AtomicExpr::AO__atomic_nand_fetch:
8415 case AtomicExpr::AO__scoped_atomic_fetch_and:
8416 case AtomicExpr::AO__scoped_atomic_fetch_or:
8417 case AtomicExpr::AO__scoped_atomic_fetch_xor:
8418 case AtomicExpr::AO__scoped_atomic_fetch_nand:
8419 case AtomicExpr::AO__scoped_atomic_and_fetch:
8420 case AtomicExpr::AO__scoped_atomic_or_fetch:
8421 case AtomicExpr::AO__scoped_atomic_xor_fetch:
8422 case AtomicExpr::AO__scoped_atomic_nand_fetch:
8426 case AtomicExpr::AO__c11_atomic_exchange:
8427 case AtomicExpr::AO__hip_atomic_exchange:
8428 case AtomicExpr::AO__opencl_atomic_exchange:
8429 case AtomicExpr::AO__atomic_exchange_n:
8430 case AtomicExpr::AO__scoped_atomic_exchange_n:
8434 case AtomicExpr::AO__atomic_exchange:
8435 case AtomicExpr::AO__scoped_atomic_exchange:
8439 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
8440 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
8441 case AtomicExpr::AO__hip_atomic_compare_exchange_strong:
8442 case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
8443 case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
8444 case AtomicExpr::AO__hip_atomic_compare_exchange_weak:
8448 case AtomicExpr::AO__atomic_compare_exchange:
8449 case AtomicExpr::AO__atomic_compare_exchange_n:
8450 case AtomicExpr::AO__scoped_atomic_compare_exchange:
8451 case AtomicExpr::AO__scoped_atomic_compare_exchange_n:
8456 unsigned AdjustedNumArgs = NumArgs[Form];
8457 if ((IsOpenCL || IsHIP || IsScoped) &&
8458 Op != AtomicExpr::AO__opencl_atomic_init)
8461 if (Args.size() < AdjustedNumArgs) {
8462 Diag(CallRange.
getEnd(), diag::err_typecheck_call_too_few_args)
8463 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8466 }
else if (Args.size() > AdjustedNumArgs) {
8467 Diag(Args[AdjustedNumArgs]->getBeginLoc(),
8468 diag::err_typecheck_call_too_many_args)
8469 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8475 Expr *Ptr = Args[0];
8480 Ptr = ConvertedPtr.
get();
8483 Diag(ExprRange.
getBegin(), diag::err_atomic_builtin_must_be_pointer)
8493 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic)
8499 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_atomic)
8505 }
else if (Form != Load && Form != LoadCopy) {
8507 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_pointer)
8514 if (Form == Arithmetic) {
8517 auto IsAllowedValueType = [&](
QualType ValType,
8518 unsigned AllowedType) ->
bool {
8522 return AllowedType & AOEVT_Pointer;
8528 &llvm::APFloat::x87DoubleExtended())
8532 if (!IsAllowedValueType(ValType, ArithAllows)) {
8533 auto DID = ArithAllows & AOEVT_FP
8534 ? (ArithAllows & AOEVT_Pointer
8535 ? diag::err_atomic_op_needs_atomic_int_ptr_or_fp
8536 : diag::err_atomic_op_needs_atomic_int_or_fp)
8537 : diag::err_atomic_op_needs_atomic_int;
8544 diag::err_incomplete_type)) {
8550 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
8561 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_trivial_copy)
8577 Diag(ExprRange.
getBegin(), diag::err_arc_atomic_ownership)
8589 if (Form ==
Copy || Form == LoadCopy || Form == GNUXchg ||
8592 else if (Form == C11CmpXchg || Form == GNUCmpXchg)
8598 bool IsPassedByAddress =
false;
8599 if (!IsC11 && !IsHIP && !IsN) {
8601 IsPassedByAddress =
true;
8606 APIOrderedArgs.push_back(Args[0]);
8610 APIOrderedArgs.push_back(Args[1]);
8616 APIOrderedArgs.push_back(Args[2]);
8617 APIOrderedArgs.push_back(Args[1]);
8620 APIOrderedArgs.push_back(Args[2]);
8621 APIOrderedArgs.push_back(Args[3]);
8622 APIOrderedArgs.push_back(Args[1]);
8625 APIOrderedArgs.push_back(Args[2]);
8626 APIOrderedArgs.push_back(Args[4]);
8627 APIOrderedArgs.push_back(Args[1]);
8628 APIOrderedArgs.push_back(Args[3]);
8631 APIOrderedArgs.push_back(Args[2]);
8632 APIOrderedArgs.push_back(Args[4]);
8633 APIOrderedArgs.push_back(Args[5]);
8634 APIOrderedArgs.push_back(Args[1]);
8635 APIOrderedArgs.push_back(Args[3]);
8639 APIOrderedArgs.append(Args.begin(), Args.end());
8646 for (
unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
8648 if (i < NumVals[Form] + 1) {
8661 assert(Form != Load);
8664 else if (Form ==
Init || Form == Arithmetic)
8666 else if (Form ==
Copy || Form == Xchg) {
8667 if (IsPassedByAddress) {
8674 Expr *ValArg = APIOrderedArgs[i];
8681 AS = PtrTy->getPointeeType().getAddressSpace();
8690 if (IsPassedByAddress)
8710 APIOrderedArgs[i] = Arg.
get();
8715 SubExprs.push_back(Ptr);
8719 SubExprs.push_back(APIOrderedArgs[1]);
8722 SubExprs.push_back(APIOrderedArgs[1]);
8728 SubExprs.push_back(APIOrderedArgs[2]);
8729 SubExprs.push_back(APIOrderedArgs[1]);
8733 SubExprs.push_back(APIOrderedArgs[3]);
8734 SubExprs.push_back(APIOrderedArgs[1]);
8735 SubExprs.push_back(APIOrderedArgs[2]);
8738 SubExprs.push_back(APIOrderedArgs[3]);
8739 SubExprs.push_back(APIOrderedArgs[1]);
8740 SubExprs.push_back(APIOrderedArgs[4]);
8741 SubExprs.push_back(APIOrderedArgs[2]);
8744 SubExprs.push_back(APIOrderedArgs[4]);
8745 SubExprs.push_back(APIOrderedArgs[1]);
8746 SubExprs.push_back(APIOrderedArgs[5]);
8747 SubExprs.push_back(APIOrderedArgs[2]);
8748 SubExprs.push_back(APIOrderedArgs[3]);
8753 if (SubExprs.size() >= 2 && Form !=
Init) {
8754 std::optional<llvm::APSInt>
Success =
8755 SubExprs[1]->getIntegerConstantExpr(
Context);
8757 Diag(SubExprs[1]->getBeginLoc(),
8758 diag::warn_atomic_op_has_invalid_memory_order)
8759 << (Form == C11CmpXchg || Form == GNUCmpXchg)
8760 << SubExprs[1]->getSourceRange();
8762 if (SubExprs.size() >= 5) {
8763 if (std::optional<llvm::APSInt> Failure =
8764 SubExprs[3]->getIntegerConstantExpr(
Context)) {
8765 if (!llvm::is_contained(
8766 {llvm::AtomicOrderingCABI::relaxed,
8767 llvm::AtomicOrderingCABI::consume,
8768 llvm::AtomicOrderingCABI::acquire,
8769 llvm::AtomicOrderingCABI::seq_cst},
8770 (llvm::AtomicOrderingCABI)Failure->getSExtValue())) {
8771 Diag(SubExprs[3]->getBeginLoc(),
8772 diag::warn_atomic_op_has_invalid_memory_order)
8773 << 2 << SubExprs[3]->getSourceRange();
8780 auto *
Scope = Args[Args.size() - 1];
8781 if (std::optional<llvm::APSInt>
Result =
8783 if (!ScopeModel->isValid(
Result->getZExtValue()))
8784 Diag(
Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
8785 <<
Scope->getSourceRange();
8787 SubExprs.push_back(
Scope);
8793 if ((Op == AtomicExpr::AO__c11_atomic_load ||
8794 Op == AtomicExpr::AO__c11_atomic_store ||
8795 Op == AtomicExpr::AO__opencl_atomic_load ||
8796 Op == AtomicExpr::AO__hip_atomic_load ||
8797 Op == AtomicExpr::AO__opencl_atomic_store ||
8798 Op == AtomicExpr::AO__hip_atomic_store) &&
8801 << ((Op == AtomicExpr::AO__c11_atomic_load ||
8802 Op == AtomicExpr::AO__opencl_atomic_load ||
8803 Op == AtomicExpr::AO__hip_atomic_load)
8808 Diag(Ptr->
getExprLoc(), diag::err_atomic_builtin_bit_int_prohibit);
8824 assert(Fn &&
"builtin call without direct callee!");
8839bool Sema::BuiltinWasmRefNullExtern(
CallExpr *TheCall) {
8848bool Sema::BuiltinWasmRefNullFunc(
CallExpr *TheCall) {
8883 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
8885 <<
Callee->getSourceRange();
8898 FirstArg = FirstArgResult.
get();
8899 TheCall->
setArg(0, FirstArg);
8911 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
8946#define BUILTIN_ROW(x) \
8947 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
8948 Builtin::BI##x##_8, Builtin::BI##x##_16 }
8950 static const unsigned BuiltinIndices[][5] = {
8976 case 1: SizeIndex = 0;
break;
8977 case 2: SizeIndex = 1;
break;
8978 case 4: SizeIndex = 2;
break;
8979 case 8: SizeIndex = 3;
break;
8980 case 16: SizeIndex = 4;
break;
8992 unsigned BuiltinIndex, NumFixed = 1;
8993 bool WarnAboutSemanticsChange =
false;
8994 switch (BuiltinID) {
8995 default: llvm_unreachable(
"Unknown overloaded atomic builtin!");
8996 case Builtin::BI__sync_fetch_and_add:
8997 case Builtin::BI__sync_fetch_and_add_1:
8998 case Builtin::BI__sync_fetch_and_add_2:
8999 case Builtin::BI__sync_fetch_and_add_4:
9000 case Builtin::BI__sync_fetch_and_add_8:
9001 case Builtin::BI__sync_fetch_and_add_16:
9005 case Builtin::BI__sync_fetch_and_sub:
9006 case Builtin::BI__sync_fetch_and_sub_1:
9007 case Builtin::BI__sync_fetch_and_sub_2:
9008 case Builtin::BI__sync_fetch_and_sub_4:
9009 case Builtin::BI__sync_fetch_and_sub_8:
9010 case Builtin::BI__sync_fetch_and_sub_16:
9014 case Builtin::BI__sync_fetch_and_or:
9015 case Builtin::BI__sync_fetch_and_or_1:
9016 case Builtin::BI__sync_fetch_and_or_2:
9017 case Builtin::BI__sync_fetch_and_or_4:
9018 case Builtin::BI__sync_fetch_and_or_8:
9019 case Builtin::BI__sync_fetch_and_or_16:
9023 case Builtin::BI__sync_fetch_and_and:
9024 case Builtin::BI__sync_fetch_and_and_1:
9025 case Builtin::BI__sync_fetch_and_and_2:
9026 case Builtin::BI__sync_fetch_and_and_4:
9027 case Builtin::BI__sync_fetch_and_and_8:
9028 case Builtin::BI__sync_fetch_and_and_16:
9032 case Builtin::BI__sync_fetch_and_xor:
9033 case Builtin::BI__sync_fetch_and_xor_1:
9034 case Builtin::BI__sync_fetch_and_xor_2:
9035 case Builtin::BI__sync_fetch_and_xor_4:
9036 case Builtin::BI__sync_fetch_and_xor_8:
9037 case Builtin::BI__sync_fetch_and_xor_16:
9041 case Builtin::BI__sync_fetch_and_nand:
9042 case Builtin::BI__sync_fetch_and_nand_1:
9043 case Builtin::BI__sync_fetch_and_nand_2:
9044 case Builtin::BI__sync_fetch_and_nand_4:
9045 case Builtin::BI__sync_fetch_and_nand_8:
9046 case Builtin::BI__sync_fetch_and_nand_16:
9048 WarnAboutSemanticsChange =
true;
9051 case Builtin::BI__sync_add_and_fetch:
9052 case Builtin::BI__sync_add_and_fetch_1:
9053 case Builtin::BI__sync_add_and_fetch_2:
9054 case Builtin::BI__sync_add_and_fetch_4:
9055 case Builtin::BI__sync_add_and_fetch_8:
9056 case Builtin::BI__sync_add_and_fetch_16:
9060 case Builtin::BI__sync_sub_and_fetch:
9061 case Builtin::BI__sync_sub_and_fetch_1:
9062 case Builtin::BI__sync_sub_and_fetch_2:
9063 case Builtin::BI__sync_sub_and_fetch_4:
9064 case Builtin::BI__sync_sub_and_fetch_8:
9065 case Builtin::BI__sync_sub_and_fetch_16:
9069 case Builtin::BI__sync_and_and_fetch:
9070 case Builtin::BI__sync_and_and_fetch_1:
9071 case Builtin::BI__sync_and_and_fetch_2:
9072 case Builtin::BI__sync_and_and_fetch_4:
9073 case Builtin::BI__sync_and_and_fetch_8:
9074 case Builtin::BI__sync_and_and_fetch_16:
9078 case Builtin::BI__sync_or_and_fetch:
9079 case Builtin::BI__sync_or_and_fetch_1:
9080 case Builtin::BI__sync_or_and_fetch_2:
9081 case Builtin::BI__sync_or_and_fetch_4:
9082 case Builtin::BI__sync_or_and_fetch_8:
9083 case Builtin::BI__sync_or_and_fetch_16:
9087 case Builtin::BI__sync_xor_and_fetch:
9088 case Builtin::BI__sync_xor_and_fetch_1:
9089 case Builtin::BI__sync_xor_and_fetch_2:
9090 case Builtin::BI__sync_xor_and_fetch_4:
9091 case Builtin::BI__sync_xor_and_fetch_8:
9092 case Builtin::BI__sync_xor_and_fetch_16:
9096 case Builtin::BI__sync_nand_and_fetch:
9097 case Builtin::BI__sync_nand_and_fetch_1:
9098 case Builtin::BI__sync_nand_and_fetch_2:
9099 case Builtin::BI__sync_nand_and_fetch_4:
9100 case Builtin::BI__sync_nand_and_fetch_8:
9101 case Builtin::BI__sync_nand_and_fetch_16:
9103 WarnAboutSemanticsChange =
true;
9106 case Builtin::BI__sync_val_compare_and_swap:
9107 case Builtin::BI__sync_val_compare_and_swap_1:
9108 case Builtin::BI__sync_val_compare_and_swap_2:
9109 case Builtin::BI__sync_val_compare_and_swap_4:
9110 case Builtin::BI__sync_val_compare_and_swap_8:
9111 case Builtin::BI__sync_val_compare_and_swap_16:
9116 case Builtin::BI__sync_bool_compare_and_swap:
9117 case Builtin::BI__sync_bool_compare_and_swap_1:
9118 case Builtin::BI__sync_bool_compare_and_swap_2:
9119 case Builtin::BI__sync_bool_compare_and_swap_4:
9120 case Builtin::BI__sync_bool_compare_and_swap_8:
9121 case Builtin::BI__sync_bool_compare_and_swap_16:
9127 case Builtin::BI__sync_lock_test_and_set:
9128 case Builtin::BI__sync_lock_test_and_set_1:
9129 case Builtin::BI__sync_lock_test_and_set_2:
9130 case Builtin::BI__sync_lock_test_and_set_4:
9131 case Builtin::BI__sync_lock_test_and_set_8:
9132 case Builtin::BI__sync_lock_test_and_set_16:
9136 case Builtin::BI__sync_lock_release:
9137 case Builtin::BI__sync_lock_release_1:
9138 case Builtin::BI__sync_lock_release_2:
9139 case Builtin::BI__sync_lock_release_4:
9140 case Builtin::BI__sync_lock_release_8:
9141 case Builtin::BI__sync_lock_release_16:
9147 case Builtin::BI__sync_swap:
9148 case Builtin::BI__sync_swap_1:
9149 case Builtin::BI__sync_swap_2:
9150 case Builtin::BI__sync_swap_4:
9151 case Builtin::BI__sync_swap_8:
9152 case Builtin::BI__sync_swap_16:
9160 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
9161 << 0 << 1 + NumFixed << TheCall->
getNumArgs() << 0
9162 <<
Callee->getSourceRange();
9166 Diag(TheCall->
getEndLoc(), diag::warn_atomic_implicit_seq_cst)
9167 <<
Callee->getSourceRange();
9169 if (WarnAboutSemanticsChange) {
9170 Diag(TheCall->
getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
9171 <<
Callee->getSourceRange();
9176 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
9179 if (NewBuiltinID == BuiltinID)
9180 NewBuiltinDecl = FDecl;
9186 assert(Res.getFoundDecl());
9187 NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
9188 if (!NewBuiltinDecl)
9195 for (
unsigned i = 0; i != NumFixed; ++i) {
9226 CK_BuiltinFnToFnPtr);
9238 if (BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {
9239 Diag(FirstArg->
getExprLoc(), diag::err_atomic_builtin_ext_int_size);
9243 return TheCallResult;
9258 assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||
9259 BuiltinID == Builtin::BI__builtin_nontemporal_load) &&
9260 "Unexpected nontemporal load/store builtin!");
9261 bool isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;
9262 unsigned numArgs = isStore ? 2 : 1;
9272 Expr *PointerArg = TheCall->
getArg(numArgs - 1);
9278 PointerArg = PointerArgResult.
get();
9279 TheCall->
setArg(numArgs - 1, PointerArg);
9283 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
9296 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
9303 return TheCallResult;
9315 return TheCallResult;
9322bool Sema::CheckObjCString(
Expr *Arg) {
9326 if (!Literal || !
Literal->isOrdinary()) {
9327 Diag(Arg->
getBeginLoc(), diag::err_cfstring_literal_not_string_constant)
9332 if (
Literal->containsNonAsciiOrNull()) {
9333 StringRef String =
Literal->getString();
9334 unsigned NumBytes = String.size();
9336 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
9337 llvm::UTF16 *ToPtr = &ToBuf[0];
9339 llvm::ConversionResult
Result =
9340 llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
9341 ToPtr + NumBytes, llvm::strictConversion);
9343 if (
Result != llvm::conversionOK)
9354 auto *
Literal = dyn_cast<StringLiteral>(Arg);
9356 if (
auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
9357 Literal = ObjcLiteral->getString();
9361 if (!Literal || (!
Literal->isOrdinary() && !
Literal->isUTF8())) {
9379 bool IsX64 = TT.getArch() == llvm::Triple::x86_64;
9380 bool IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||
9381 TT.getArch() == llvm::Triple::aarch64_32);
9382 bool IsWindows = TT.isOSWindows();
9383 bool IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;
9384 if (IsX64 || IsAArch64) {
9392 diag::err_ms_va_start_used_in_sysv_function);
9401 diag::err_va_start_used_in_wrong_abi_function)
9416 bool IsVariadic =
false;
9419 if (
auto *
Block = dyn_cast<BlockDecl>(Caller)) {
9420 IsVariadic =
Block->isVariadic();
9421 Params =
Block->parameters();
9422 }
else if (
auto *FD = dyn_cast<FunctionDecl>(Caller)) {
9425 }
else if (
auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {
9426 IsVariadic = MD->isVariadic();
9428 Params = MD->parameters();
9429 }
else if (isa<CapturedDecl>(Caller)) {
9445 *LastParam = Params.empty() ? nullptr : Params.back();
9453bool Sema::BuiltinVAStart(
unsigned BuiltinID,
CallExpr *TheCall) {
9478 bool SecondArgIsLastNamedArgument =
false;
9480 if (std::optional<llvm::APSInt> Val =
9489 bool IsCRegister =
false;
9491 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
9492 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
9493 SecondArgIsLastNamedArgument = PV == LastParam;
9495 Type = PV->getType();
9496 ParamLoc = PV->getLocation();
9502 if (!SecondArgIsLastNamedArgument)
9504 diag::warn_second_arg_of_va_start_not_last_named_param);
9509 if (!Context.isPromotableIntegerType(Type))
9511 if (!Type->isEnumeralType())
9513 const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
9515 Context.typesAreCompatible(ED->getPromotionType(), Type));
9517 unsigned Reason = 0;
9519 else if (IsCRegister) Reason = 2;
9520 Diag(Arg->
getBeginLoc(), diag::warn_va_start_type_is_undefined) << Reason;
9521 Diag(ParamLoc, diag::note_parameter_type) <<
Type;
9528 auto IsSuitablyTypedFormatArgument = [
this](
const Expr *Arg) ->
bool {
9548 if (
Call->getNumArgs() < 3)
9550 diag::err_typecheck_call_too_few_args_at_least)
9551 << 0 << 3 <<
Call->getNumArgs()
9564 const Expr *Arg1 =
Call->getArg(1)->IgnoreParens();
9567 const Expr *Arg2 =
Call->getArg(2)->IgnoreParens();
9572 if (!Arg1Ty->
isPointerType() || !IsSuitablyTypedFormatArgument(Arg1))
9574 << Arg1->
getType() << ConstCharPtrTy << 1
9577 << 2 << Arg1->
getType() << ConstCharPtrTy;
9582 << Arg2->
getType() << SizeTy << 1
9585 << 3 << Arg2->
getType() << SizeTy;
9592bool Sema::BuiltinUnorderedCompare(
CallExpr *TheCall,
unsigned BuiltinID) {
9596 if (BuiltinID == Builtin::BI__builtin_isunordered &&
9624 diag::err_typecheck_call_invalid_ordered_compare)
9635bool Sema::BuiltinFPClassification(
CallExpr *TheCall,
unsigned NumArgs,
9636 unsigned BuiltinID) {
9641 if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
9642 BuiltinID == Builtin::BI__builtin_isinf ||
9643 BuiltinID == Builtin::BI__builtin_isinf_sign))
9647 if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
9648 BuiltinID == Builtin::BI__builtin_isunordered))
9652 bool IsFPClass = NumArgs == 2;
9655 unsigned FPArgNo = IsFPClass ? 0 : NumArgs - 1;
9659 for (
unsigned i = 0; i < FPArgNo; ++i) {
9684 TheCall->
setArg(FPArgNo, OrigArg);
9698 diag::err_typecheck_call_invalid_unary_fp)
9704 if (BuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
9710 if (!VectorResultTy.
isNull())
9711 ResultTy = VectorResultTy;
9721bool Sema::BuiltinComplex(
CallExpr *TheCall) {
9725 bool Dependent =
false;
9726 for (
unsigned I = 0; I != 2; ++I) {
9737 return Diag(Arg->
getBeginLoc(), diag::err_typecheck_call_requires_real_fp)
9756 diag::err_typecheck_call_different_arg_types)
9782bool Sema::BuiltinVSX(
CallExpr *TheCall) {
9783 unsigned ExpectedNumArgs = 3;
9790 diag::err_vsx_builtin_nonconstant_argument)
9802 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
9810 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
9829 diag::err_typecheck_call_too_few_args_at_least)
9837 unsigned numElements = 0;
9852 unsigned numResElements = TheCall->
getNumArgs() - 2;
9861 diag::err_vec_builtin_incompatible_vector)
9868 diag::err_vec_builtin_incompatible_vector)
9873 }
else if (numElements != numResElements) {
9880 for (
unsigned i = 2; i < TheCall->
getNumArgs(); i++) {
9885 std::optional<llvm::APSInt>
Result;
9888 diag::err_shufflevector_nonconstant_argument)
9895 if (
Result->getActiveBits() > 64 ||
9896 Result->getZExtValue() >= numElements * 2)
9898 diag::err_shufflevector_argument_too_large)
9904 for (
unsigned i = 0, e = TheCall->
getNumArgs(); i != e; i++) {
9905 exprs.push_back(TheCall->
getArg(i));
9906 TheCall->
setArg(i,
nullptr);
9925 diag::err_convertvector_non_vector)
9928 return ExprError(
Diag(BuiltinLoc, diag::err_builtin_non_vector_type)
9930 <<
"__builtin_convertvector");
9935 if (SrcElts != DstElts)
9937 diag::err_convertvector_incompatible_vector)
9942 BuiltinLoc, RParenLoc);
9948bool Sema::BuiltinPrefetch(
CallExpr *TheCall) {
9953 diag::err_typecheck_call_too_many_args_at_most)
9954 << 0 << 3 << NumArgs << 0
9959 for (
unsigned i = 1; i != NumArgs; ++i)
9960 if (BuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
9967bool Sema::BuiltinArithmeticFence(
CallExpr *TheCall) {
9969 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
9979 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
9992bool Sema::BuiltinAssume(
CallExpr *TheCall) {
9999 << cast<FunctionDecl>(TheCall->
getCalleeDecl())->getIdentifier();
10007bool Sema::BuiltinAllocaWithAlign(
CallExpr *TheCall) {
10013 if (
const auto *UE =
10015 if (UE->getKind() == UETT_AlignOf ||
10016 UE->getKind() == UETT_PreferredAlignOf)
10022 if (!
Result.isPowerOf2())
10023 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10030 if (
Result > std::numeric_limits<int32_t>::max())
10032 << std::numeric_limits<int32_t>::max() << Arg->
getSourceRange();
10040bool Sema::BuiltinAssumeAligned(
CallExpr *TheCall) {
10053 TheCall->
setArg(0, FirstArgResult.
get());
10062 if (BuiltinConstantArg(TheCall, 1,
Result))
10065 if (!
Result.isPowerOf2())
10066 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10078 TheCall->
setArg(2, ThirdArg);
10084bool Sema::BuiltinOSLogFormat(
CallExpr *TheCall) {
10085 unsigned BuiltinID =
10086 cast<FunctionDecl>(TheCall->
getCalleeDecl())->getBuiltinID();
10087 bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
10090 unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
10091 if (NumArgs < NumRequiredArgs) {
10092 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args)
10093 << 0 << NumRequiredArgs << NumArgs
10096 if (NumArgs >= NumRequiredArgs + 0x100) {
10098 diag::err_typecheck_call_too_many_args_at_most)
10099 << 0 << (NumRequiredArgs + 0xff) << NumArgs
10110 if (Arg.isInvalid())
10112 TheCall->
setArg(i, Arg.get());
10117 unsigned FormatIdx = i;
10127 unsigned FirstDataArg = i;
10128 while (i < NumArgs) {
10146 llvm::SmallBitVector CheckedVarArgs(NumArgs,
false);
10148 bool Success = CheckFormatArguments(
10166bool Sema::BuiltinConstantArg(
CallExpr *TheCall,
int ArgNum,
10174 std::optional<llvm::APSInt> R;
10176 return Diag(TheCall->
getBeginLoc(), diag::err_constant_integer_arg_type)
10184bool Sema::BuiltinConstantArgRange(
CallExpr *TheCall,
int ArgNum,
int Low,
10185 int High,
bool RangeIsError) {
10196 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10199 if (
Result.getSExtValue() < Low ||
Result.getSExtValue() > High) {
10201 return Diag(TheCall->
getBeginLoc(), diag::err_argument_invalid_range)
10207 PDiag(diag::warn_argument_invalid_range)
10217bool Sema::BuiltinConstantArgMultiple(
CallExpr *TheCall,
int ArgNum,
10227 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10230 if (
Result.getSExtValue() % Num != 0)
10239bool Sema::BuiltinConstantArgPower2(
CallExpr *TheCall,
int ArgNum) {
10248 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10256 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_power_of_2)
10261 if (
Value.isNegative())
10272 if ((
Value & 0xFF) != 0)
10285bool Sema::BuiltinConstantArgShiftedByte(
CallExpr *TheCall,
int ArgNum,
10286 unsigned ArgBits) {
10295 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10300 Result.setIsUnsigned(
true);
10305 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_shifted_byte)
10314bool Sema::BuiltinConstantArgShiftedByteOrXXFF(
CallExpr *TheCall,
int ArgNum,
10315 unsigned ArgBits) {
10324 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10329 Result.setIsUnsigned(
true);
10337 diag::err_argument_not_shifted_byte_or_xxff)
10342bool Sema::BuiltinARMMemoryTaggingCall(
unsigned BuiltinID,
CallExpr *TheCall) {
10343 if (BuiltinID == AArch64::BI__builtin_arm_irg) {
10354 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10363 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10367 TheCall->
setType(FirstArgType);
10371 if (BuiltinID == AArch64::BI__builtin_arm_addg) {
10381 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10386 TheCall->
setType(FirstArgType);
10389 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
10392 if (BuiltinID == AArch64::BI__builtin_arm_gmi) {
10403 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10408 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10414 if (BuiltinID == AArch64::BI__builtin_arm_ldg ||
10415 BuiltinID == AArch64::BI__builtin_arm_stg) {
10425 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10430 if (BuiltinID == AArch64::BI__builtin_arm_ldg)
10431 TheCall->
setType(FirstArgType);
10435 if (BuiltinID == AArch64::BI__builtin_arm_subp) {
10448 auto isNull = [&] (
Expr *E) ->
bool {
10454 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10458 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10469 return Diag(TheCall->
getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
10477 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_any2arg_pointer)
10491 assert(
false &&
"Unhandled ARM MTE intrinsic");
10497bool Sema::BuiltinARMSpecialReg(
unsigned BuiltinID,
CallExpr *TheCall,
10498 int ArgNum,
unsigned ExpectedFieldNum,
10500 bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
10501 BuiltinID == ARM::BI__builtin_arm_wsr64 ||
10502 BuiltinID == ARM::BI__builtin_arm_rsr ||
10503 BuiltinID == ARM::BI__builtin_arm_rsrp ||
10504 BuiltinID == ARM::BI__builtin_arm_wsr ||
10505 BuiltinID == ARM::BI__builtin_arm_wsrp;
10506 bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
10507 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
10508 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10509 BuiltinID == AArch64::BI__builtin_arm_wsr128 ||
10510 BuiltinID == AArch64::BI__builtin_arm_rsr ||
10511 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
10512 BuiltinID == AArch64::BI__builtin_arm_wsr ||
10513 BuiltinID == AArch64::BI__builtin_arm_wsrp;
10514 assert((IsARMBuiltin || IsAArch64Builtin) &&
"Unexpected ARM builtin.");
10523 return Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
10529 Reg.split(Fields,
":");
10531 if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))
10532 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10539 if (Fields.size() > 1) {
10540 bool FiveFields = Fields.size() == 5;
10542 bool ValidString =
true;
10543 if (IsARMBuiltin) {
10544 ValidString &= Fields[0].starts_with_insensitive(
"cp") ||
10545 Fields[0].starts_with_insensitive(
"p");
10547 Fields[0] = Fields[0].drop_front(
10548 Fields[0].starts_with_insensitive(
"cp") ? 2 : 1);
10550 ValidString &= Fields[2].starts_with_insensitive(
"c");
10552 Fields[2] = Fields[2].drop_front(1);
10555 ValidString &= Fields[3].starts_with_insensitive(
"c");
10557 Fields[3] = Fields[3].drop_front(1);
10563 Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});
10565 Ranges.append({15, 7, 15});
10567 for (
unsigned i=0; i<Fields.size(); ++i) {
10569 ValidString &= !Fields[i].getAsInteger(10, IntField);
10570 ValidString &= (IntField >= 0 && IntField <= Ranges[i]);
10574 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10576 }
else if (IsAArch64Builtin && Fields.size() == 1) {
10584 if (BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10585 BuiltinID == AArch64::BI__builtin_arm_wsr128)
10590 auto MaxLimit = llvm::StringSwitch<std::optional<unsigned>>(Reg)
10591 .CaseLower(
"spsel", 15)
10592 .CaseLower(
"daifclr", 15)
10593 .CaseLower(
"daifset", 15)
10594 .CaseLower(
"pan", 15)
10595 .CaseLower(
"uao", 15)
10596 .CaseLower(
"dit", 15)
10597 .CaseLower(
"ssbs", 15)
10598 .CaseLower(
"tco", 15)
10599 .CaseLower(
"allint", 1)
10600 .CaseLower(
"pm", 1)
10601 .Default(std::nullopt);
10621 return BuiltinConstantArgRange(TheCall, 1, 0, *MaxLimit);
10631bool Sema::BuiltinPPCMMACall(
CallExpr *TheCall,
unsigned BuiltinID,
10632 const char *TypeStr) {
10634 assert((TypeStr[0] !=
'\0') &&
10635 "Invalid types in PPC MMA builtin declaration");
10638 unsigned ArgNum = 0;
10645 while (*TypeStr !=
'\0') {
10669 diag::err_typecheck_convert_incompatible)
10675 if (Mask != 0 && BuiltinConstantArgRange(TheCall, ArgNum, 0, Mask,
true))
10685 while (*TypeStr !=
'\0') {
10698bool Sema::BuiltinLongjmp(
CallExpr *TheCall) {
10700 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_unsupported)
10707 if (BuiltinConstantArg(TheCall, 1,
Result))
10711 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
10719bool Sema::BuiltinSetjmp(
CallExpr *TheCall) {
10721 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_setjmp_unsupported)
10728class UncoveredArgHandler {
10729 enum {
Unknown = -1, AllCovered = -2 };
10731 signed FirstUncoveredArg =
Unknown;
10735 UncoveredArgHandler() =
default;
10737 bool hasUncoveredArg()
const {
10738 return (FirstUncoveredArg >= 0);
10741 unsigned getUncoveredArg()
const {
10742 assert(hasUncoveredArg() &&
"no uncovered argument");
10743 return FirstUncoveredArg;
10746 void setAllCovered() {
10749 DiagnosticExprs.clear();
10750 FirstUncoveredArg = AllCovered;
10753 void Update(
signed NewFirstUncoveredArg,
const Expr *StrExpr) {
10754 assert(NewFirstUncoveredArg >= 0 &&
"Outside range");
10757 if (FirstUncoveredArg == AllCovered)
10762 if (NewFirstUncoveredArg == FirstUncoveredArg)
10763 DiagnosticExprs.push_back(StrExpr);
10764 else if (NewFirstUncoveredArg > FirstUncoveredArg) {
10765 DiagnosticExprs.clear();
10766 DiagnosticExprs.push_back(StrExpr);
10767 FirstUncoveredArg = NewFirstUncoveredArg;
10771 void Diagnose(
Sema &S,
bool IsFunctionCall,
const Expr *ArgExpr);
10774enum StringLiteralCheckType {
10776 SLCT_UncheckedLiteral,
10777 SLCT_CheckedLiteral
10784 bool AddendIsRight) {
10785 unsigned BitWidth = Offset.getBitWidth();
10786 unsigned AddendBitWidth = Addend.getBitWidth();
10788 if (Addend.isUnsigned()) {
10789 Addend = Addend.zext(++AddendBitWidth);
10790 Addend.setIsSigned(
true);
10793 if (AddendBitWidth > BitWidth) {
10794 Offset = Offset.sext(AddendBitWidth);
10795 BitWidth = AddendBitWidth;
10796 }
else if (BitWidth > AddendBitWidth) {
10797 Addend = Addend.sext(BitWidth);
10801 llvm::APSInt ResOffset = Offset;
10802 if (BinOpKind == BO_Add)
10803 ResOffset = Offset.sadd_ov(Addend, Ov);
10805 assert(AddendIsRight && BinOpKind == BO_Sub &&
10806 "operator must be add or sub with addend on the right");
10807 ResOffset = Offset.ssub_ov(Addend, Ov);
10813 assert(BitWidth <= std::numeric_limits<unsigned>::max() / 2 &&
10814 "index (intermediate) result too big");
10815 Offset = Offset.sext(2 * BitWidth);
10816 sumOffsets(Offset, Addend, BinOpKind, AddendIsRight);
10820 Offset = ResOffset;
10828class FormatStringLiteral {
10833 FormatStringLiteral(
const StringLiteral *fexpr, int64_t Offset = 0)
10834 : FExpr(fexpr), Offset(Offset) {}
10836 StringRef getString()
const {
10837 return FExpr->
getString().drop_front(Offset);
10840 unsigned getByteLength()
const {
10841 return FExpr->
getByteLength() - getCharByteWidth() * Offset;
10844 unsigned getLength()
const {
return FExpr->
getLength() - Offset; }
10851 bool isAscii()
const {
return FExpr->
isOrdinary(); }
10852 bool isWide()
const {
return FExpr->
isWide(); }
10853 bool isUTF8()
const {
return FExpr->
isUTF8(); }
10854 bool isUTF16()
const {
return FExpr->
isUTF16(); }
10855 bool isUTF32()
const {
return FExpr->
isUTF32(); }
10856 bool isPascal()
const {
return FExpr->
isPascal(); }
10861 unsigned *StartTokenByteOffset =
nullptr)
const {
10863 StartToken, StartTokenByteOffset);
10876 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
10880 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
10881 bool IgnoreStringsWithoutSpecifiers);
10890static StringLiteralCheckType
10895 llvm::SmallBitVector &CheckedVarArgs,
10896 UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset,
10897 bool IgnoreStringsWithoutSpecifiers =
false) {
10899 return SLCT_NotALiteral;
10901 assert(Offset.isSigned() &&
"invalid offset");
10904 return SLCT_NotALiteral;
10913 return SLCT_UncheckedLiteral;
10916 case Stmt::InitListExprClass:
10920 Type, CallType,
false,
10921 CheckedVarArgs, UncoveredArg, Offset,
10922 IgnoreStringsWithoutSpecifiers);
10924 return SLCT_NotALiteral;
10925 case Stmt::BinaryConditionalOperatorClass:
10926 case Stmt::ConditionalOperatorClass: {
10930 cast<AbstractConditionalOperator>(E);
10935 bool CheckLeft =
true, CheckRight =
true;
10938 if (
C->getCond()->EvaluateAsBooleanCondition(
10941 CheckRight =
false;
10950 StringLiteralCheckType Left;
10952 Left = SLCT_UncheckedLiteral;
10955 firstDataArg,
Type, CallType, InFunctionCall,
10956 CheckedVarArgs, UncoveredArg, Offset,
10957 IgnoreStringsWithoutSpecifiers);
10958 if (Left == SLCT_NotALiteral || !CheckRight) {
10964 S,
C->getFalseExpr(), Args, APK, format_idx, firstDataArg,
Type,
10965 CallType, InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
10966 IgnoreStringsWithoutSpecifiers);
10968 return (CheckLeft && Left < Right) ? Left : Right;
10971 case Stmt::ImplicitCastExprClass:
10972 E = cast<ImplicitCastExpr>(E)->getSubExpr();
10975 case Stmt::OpaqueValueExprClass:
10976 if (
const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
10980 return SLCT_NotALiteral;
10982 case Stmt::PredefinedExprClass:
10986 return SLCT_UncheckedLiteral;
10988 case Stmt::DeclRefExprClass: {
10994 bool isConstant =
false;
10998 isConstant = AT->getElementType().isConstant(S.
Context);
11000 isConstant =
T.isConstant(S.
Context) &&
11005 isConstant =
T.isConstant(S.
Context);
11009 if (
const Expr *
Init = VD->getAnyInitializer()) {
11012 if (InitList->isStringLiteralInit())
11013 Init = InitList->getInit(0)->IgnoreParenImpCasts();
11016 S,
Init, Args, APK, format_idx, firstDataArg,
Type, CallType,
11017 false, CheckedVarArgs, UncoveredArg, Offset);
11058 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
11059 if (
const auto *D = dyn_cast<Decl>(PV->getDeclContext())) {
11061 bool IsCXXMember =
false;
11062 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D))
11063 IsCXXMember = MD->isInstance();
11065 bool IsVariadic =
false;
11067 IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();
11068 else if (
const auto *BD = dyn_cast<BlockDecl>(D))
11069 IsVariadic = BD->isVariadic();
11070 else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D))
11071 IsVariadic = OMD->isVariadic();
11078 if (PV->getFunctionScopeIndex() == CallerFSI.
FormatIdx &&
11091 return SLCT_UncheckedLiteral;
11100 return SLCT_NotALiteral;
11103 case Stmt::CallExprClass:
11104 case Stmt::CXXMemberCallExprClass: {
11105 const CallExpr *CE = cast<CallExpr>(E);
11107 bool IsFirst =
true;
11108 StringLiteralCheckType CommonResult;
11109 for (
const auto *FA : ND->specific_attrs<FormatArgAttr>()) {
11110 const Expr *Arg = CE->
getArg(FA->getFormatIdx().getASTIndex());
11112 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11113 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11114 IgnoreStringsWithoutSpecifiers);
11121 return CommonResult;
11123 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
11125 if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
11126 BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString) {
11129 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11130 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11131 IgnoreStringsWithoutSpecifiers);
11137 Type, CallType,
false,
11138 CheckedVarArgs, UncoveredArg, Offset,
11139 IgnoreStringsWithoutSpecifiers);
11140 return SLCT_NotALiteral;
11142 case Stmt::ObjCMessageExprClass: {
11143 const auto *ME = cast<ObjCMessageExpr>(E);
11144 if (
const auto *MD = ME->getMethodDecl()) {
11145 if (
const auto *FA = MD->getAttr<FormatArgAttr>()) {
11154 if (MD->isInstanceMethod() && (IFace = MD->getClassInterface()) &&
11156 MD->getSelector().isKeywordSelector(
11157 {
"localizedStringForKey",
"value",
"table"})) {
11158 IgnoreStringsWithoutSpecifiers =
true;
11161 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
11163 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11164 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11165 IgnoreStringsWithoutSpecifiers);
11169 return SLCT_NotALiteral;
11171 case Stmt::ObjCStringLiteralClass:
11172 case Stmt::StringLiteralClass: {
11178 StrE = cast<StringLiteral>(E);
11181 if (Offset.isNegative() || Offset > StrE->
getLength()) {
11184 return SLCT_NotALiteral;
11186 FormatStringLiteral FStr(StrE, Offset.sextOrTrunc(64).getSExtValue());
11188 InFunctionCall, CallType, CheckedVarArgs, UncoveredArg,
11189 IgnoreStringsWithoutSpecifiers);
11190 return SLCT_CheckedLiteral;
11193 return SLCT_NotALiteral;
11195 case Stmt::BinaryOperatorClass: {
11209 if (LIsInt != RIsInt) {
11213 if (BinOpKind == BO_Add) {
11226 return SLCT_NotALiteral;
11228 case Stmt::UnaryOperatorClass: {
11230 auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->
getSubExpr());
11231 if (UnaOp->
getOpcode() == UO_AddrOf && ASE) {
11233 if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.
Context,
11238 E = ASE->getBase();
11243 return SLCT_NotALiteral;
11247 return SLCT_NotALiteral;
11258 const auto *LVE =
Result.Val.getLValueBase().dyn_cast<
const Expr *>();
11259 if (isa_and_nonnull<StringLiteral>(LVE))
11266 return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
11272 .Cases(
"kprintf",
"cmn_err",
"vcmn_err",
"zcmn_err",
FST_Kprintf)
11282bool Sema::CheckFormatArguments(
const FormatAttr *Format,
11286 llvm::SmallBitVector &CheckedVarArgs) {
11287 FormatStringInfo FSI;
11290 return CheckFormatArguments(Args, FSI.ArgPassingKind, FSI.FormatIdx,
11292 CallType, Loc, Range, CheckedVarArgs);
11298 unsigned format_idx,
unsigned firstDataArg,
11299 FormatStringType
Type,
11302 llvm::SmallBitVector &CheckedVarArgs) {
11304 if (format_idx >= Args.size()) {
11305 Diag(Loc, diag::warn_missing_format_string) << Range;
11309 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
11323 UncoveredArgHandler UncoveredArg;
11325 *
this, OrigFormatExpr, Args, APK, format_idx, firstDataArg,
Type,
11327 true, CheckedVarArgs, UncoveredArg,
11328 llvm::APSInt(64,
false) = 0);
11331 if (UncoveredArg.hasUncoveredArg()) {
11332 unsigned ArgIdx = UncoveredArg.getUncoveredArg() + firstDataArg;
11333 assert(ArgIdx < Args.size() &&
"ArgIdx outside bounds");
11334 UncoveredArg.Diagnose(*
this,
true, Args[ArgIdx]);
11337 if (CT != SLCT_NotALiteral)
11339 return CT == SLCT_CheckedLiteral;
11356 if (Args.size() == firstDataArg) {
11357 Diag(FormatLoc, diag::warn_format_nonliteral_noargs)
11365 Diag(FormatLoc, diag::note_format_security_fixit)
11369 Diag(FormatLoc, diag::note_format_security_fixit)
11374 Diag(FormatLoc, diag::warn_format_nonliteral)
11385 const FormatStringLiteral *FExpr;
11386 const Expr *OrigFormatExpr;
11388 const unsigned FirstDataArg;
11389 const unsigned NumDataArgs;
11393 unsigned FormatIdx;
11394 llvm::SmallBitVector CoveredArgs;
11395 bool usesPositionalArgs =
false;
11396 bool atFirstArg =
true;
11397 bool inFunctionCall;
11399 llvm::SmallBitVector &CheckedVarArgs;
11400 UncoveredArgHandler &UncoveredArg;
11403 CheckFormatHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11404 const Expr *origFormatExpr,
11406 unsigned numDataArgs,
const char *beg,
11410 llvm::SmallBitVector &CheckedVarArgs,
11411 UncoveredArgHandler &UncoveredArg)
11412 : S(
s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(
type),
11413 FirstDataArg(firstDataArg), NumDataArgs(numDataArgs), Beg(beg),
11414 ArgPassingKind(APK), Args(Args), FormatIdx(formatIdx),
11415 inFunctionCall(inFunctionCall), CallType(callType),
11416 CheckedVarArgs(CheckedVarArgs), UncoveredArg(UncoveredArg) {
11417 CoveredArgs.resize(numDataArgs);
11418 CoveredArgs.reset();
11421 void DoneProcessing();
11423 void HandleIncompleteSpecifier(
const char *startSpecifier,
11424 unsigned specifierLen)
override;
11426 void HandleInvalidLengthModifier(
11429 const char *startSpecifier,
unsigned specifierLen,
11432 void HandleNonStandardLengthModifier(
11434 const char *startSpecifier,
unsigned specifierLen);
11436 void HandleNonStandardConversionSpecifier(
11438 const char *startSpecifier,
unsigned specifierLen);
11440 void HandlePosition(
const char *startPos,
unsigned posLen)
override;
11442 void HandleInvalidPosition(
const char *startSpecifier,
11443 unsigned specifierLen,
11446 void HandleZeroPosition(
const char *startPos,
unsigned posLen)
override;
11448 void HandleNullChar(
const char *nullCharacter)
override;
11450 template <
typename Range>
11452 EmitFormatDiagnostic(
Sema &S,
bool inFunctionCall,
const Expr *ArgumentExpr,
11454 bool IsStringLocation, Range StringRange,
11458 bool HandleInvalidConversionSpecifier(
unsigned argIndex,
SourceLocation Loc,
11459 const char *startSpec,
11460 unsigned specifierLen,
11461 const char *csStart,
unsigned csLen);
11464 const char *startSpec,
11465 unsigned specifierLen);
11469 unsigned specifierLen);
11472 const Expr *getDataArg(
unsigned i)
const;
11476 const char *startSpecifier,
unsigned specifierLen,
11477 unsigned argIndex);
11479 template <
typename Range>
11481 bool IsStringLocation, Range StringRange,
11487SourceRange CheckFormatHandler::getFormatStringRange() {
11492getSpecifierRange(
const char *startSpecifier,
unsigned specifierLen) {
11494 SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
11497 End = End.getLocWithOffset(1);
11502SourceLocation CheckFormatHandler::getLocationOfByte(
const char *x) {
11507void CheckFormatHandler::HandleIncompleteSpecifier(
const char *startSpecifier,
11508 unsigned specifierLen){
11509 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_incomplete_specifier),
11510 getLocationOfByte(startSpecifier),
11512 getSpecifierRange(startSpecifier, specifierLen));
11515void CheckFormatHandler::HandleInvalidLengthModifier(
11518 const char *startSpecifier,
unsigned specifierLen,
unsigned DiagID) {
11519 using namespace analyze_format_string;
11521 const LengthModifier &LM = FS.getLengthModifier();
11522 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11525 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11527 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11528 getLocationOfByte(LM.getStart()),
11530 getSpecifierRange(startSpecifier, specifierLen));
11532 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11533 << FixedLM->toString()
11538 if (DiagID == diag::warn_format_nonsensical_length)
11541 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11542 getLocationOfByte(LM.getStart()),
11544 getSpecifierRange(startSpecifier, specifierLen),
11549void CheckFormatHandler::HandleNonStandardLengthModifier(
11551 const char *startSpecifier,
unsigned specifierLen) {
11552 using namespace analyze_format_string;
11554 const LengthModifier &LM = FS.getLengthModifier();
11555 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11558 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11560 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11561 << LM.toString() << 0,
11562 getLocationOfByte(LM.getStart()),
11564 getSpecifierRange(startSpecifier, specifierLen));
11566 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11567 << FixedLM->toString()
11571 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11572 << LM.toString() << 0,
11573 getLocationOfByte(LM.getStart()),
11575 getSpecifierRange(startSpecifier, specifierLen));
11579void CheckFormatHandler::HandleNonStandardConversionSpecifier(
11581 const char *startSpecifier,
unsigned specifierLen) {
11582 using namespace analyze_format_string;
11587 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11591 getSpecifierRange(startSpecifier, specifierLen));
11594 S.
Diag(getLocationOfByte(CS.
getStart()), diag::note_format_fix_specifier)
11595 << FixedCS->toString()
11598 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11602 getSpecifierRange(startSpecifier, specifierLen));
11606void CheckFormatHandler::HandlePosition(
const char *startPos,
11608 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard_positional_arg),
11609 getLocationOfByte(startPos),
11611 getSpecifierRange(startPos, posLen));
11614void CheckFormatHandler::HandleInvalidPosition(
11615 const char *startSpecifier,
unsigned specifierLen,
11617 EmitFormatDiagnostic(
11618 S.
PDiag(diag::warn_format_invalid_positional_specifier) << (
unsigned)p,
11619 getLocationOfByte(startSpecifier),
true,
11620 getSpecifierRange(startSpecifier, specifierLen));
11623void CheckFormatHandler::HandleZeroPosition(
const char *startPos,
11625 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_zero_positional_specifier),
11626 getLocationOfByte(startPos),
11628 getSpecifierRange(startPos, posLen));
11631void CheckFormatHandler::HandleNullChar(
const char *nullCharacter) {
11632 if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
11634 EmitFormatDiagnostic(
11635 S.
PDiag(diag::warn_printf_format_string_contains_null_char),
11636 getLocationOfByte(nullCharacter),
true,
11637 getFormatStringRange());
11643const Expr *CheckFormatHandler::getDataArg(
unsigned i)
const {
11644 return Args[FirstDataArg + i];
11647void CheckFormatHandler::DoneProcessing() {
11652 CoveredArgs.flip();
11653 signed notCoveredArg = CoveredArgs.find_first();
11654 if (notCoveredArg >= 0) {
11655 assert((
unsigned)notCoveredArg < NumDataArgs);
11656 UncoveredArg.Update(notCoveredArg, OrigFormatExpr);
11658 UncoveredArg.setAllCovered();
11663void UncoveredArgHandler::Diagnose(
Sema &S,
bool IsFunctionCall,
11664 const Expr *ArgExpr) {
11665 assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
11677 for (
auto E : DiagnosticExprs)
11680 CheckFormatHandler::EmitFormatDiagnostic(
11681 S, IsFunctionCall, DiagnosticExprs[0],
11687CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex,
11689 const char *startSpec,
11690 unsigned specifierLen,
11691 const char *csStart,
11693 bool keepGoing =
true;
11694 if (argIndex < NumDataArgs) {
11697 CoveredArgs.set(argIndex);
11713 std::string CodePointStr;
11714 if (!llvm::sys::locale::isPrint(*csStart)) {
11715 llvm::UTF32 CodePoint;
11716 const llvm::UTF8 **B =
reinterpret_cast<const llvm::UTF8 **
>(&csStart);
11717 const llvm::UTF8 *E =
11718 reinterpret_cast<const llvm::UTF8 *
>(csStart + csLen);
11719 llvm::ConversionResult
Result =
11720 llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
11722 if (
Result != llvm::conversionOK) {
11723 unsigned char FirstChar = *csStart;
11724 CodePoint = (llvm::UTF32)FirstChar;
11727 llvm::raw_string_ostream OS(CodePointStr);
11728 if (CodePoint < 256)
11729 OS <<
"\\x" << llvm::format(
"%02x", CodePoint);
11730 else if (CodePoint <= 0xFFFF)
11731 OS <<
"\\u" << llvm::format(
"%04x", CodePoint);
11733 OS <<
"\\U" << llvm::format(
"%08x", CodePoint);
11738 EmitFormatDiagnostic(
11739 S.
PDiag(diag::warn_format_invalid_conversion) << Specifier, Loc,
11740 true, getSpecifierRange(startSpec, specifierLen));
11746CheckFormatHandler::HandlePositionalNonpositionalArgs(
SourceLocation Loc,
11747 const char *startSpec,
11748 unsigned specifierLen) {
11749 EmitFormatDiagnostic(
11750 S.
PDiag(diag::warn_format_mix_positional_nonpositional_args),
11751 Loc,
true, getSpecifierRange(startSpec, specifierLen));
11755CheckFormatHandler::CheckNumArgs(
11758 const char *startSpecifier,
unsigned specifierLen,
unsigned argIndex) {
11760 if (argIndex >= NumDataArgs) {
11762 ? (S.
PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
11763 << (argIndex+1) << NumDataArgs)
11764 : S.
PDiag(diag::warn_printf_insufficient_data_args);
11765 EmitFormatDiagnostic(
11766 PDiag, getLocationOfByte(CS.
getStart()),
true,
11767 getSpecifierRange(startSpecifier, specifierLen));
11771 UncoveredArg.setAllCovered();
11777template<
typename Range>
11780 bool IsStringLocation,
11783 EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
11784 Loc, IsStringLocation, StringRange, FixIt);
11814template <
typename Range>
11815void CheckFormatHandler::EmitFormatDiagnostic(
11816 Sema &S,
bool InFunctionCall,
const Expr *ArgumentExpr,
11819 if (InFunctionCall) {
11824 S.
Diag(IsStringLocation ? ArgumentExpr->
getExprLoc() : Loc, PDiag)
11828 S.
Diag(IsStringLocation ? Loc : StringRange.getBegin(),
11829 diag::note_format_string_defined);
11831 Note << StringRange;
11840class CheckPrintfHandler :
public CheckFormatHandler {
11842 CheckPrintfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11843 const Expr *origFormatExpr,
11845 unsigned numDataArgs,
bool isObjC,
const char *beg,
11849 llvm::SmallBitVector &CheckedVarArgs,
11850 UncoveredArgHandler &UncoveredArg)
11851 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
11852 numDataArgs, beg, APK, Args, formatIdx,
11853 inFunctionCall, CallType, CheckedVarArgs,
11859 bool allowsObjCArg()
const {
11864 bool HandleInvalidPrintfConversionSpecifier(
11866 const char *startSpecifier,
11867 unsigned specifierLen)
override;
11869 void handleInvalidMaskType(StringRef MaskType)
override;
11872 const char *startSpecifier,
unsigned specifierLen,
11875 const char *StartSpecifier,
11876 unsigned SpecifierLen,
11880 const char *startSpecifier,
unsigned specifierLen);
11884 const char *startSpecifier,
unsigned specifierLen);
11887 const char *startSpecifier,
unsigned specifierLen);
11891 const char *startSpecifier,
unsigned specifierLen);
11895 void HandleEmptyObjCModifierFlag(
const char *startFlag,
11896 unsigned flagLen)
override;
11898 void HandleInvalidObjCModifierFlag(
const char *startFlag,
11899 unsigned flagLen)
override;
11901 void HandleObjCFlagsWithNonObjCConversion(
const char *flagsStart,
11902 const char *flagsEnd,
11903 const char *conversionPosition)
11909bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
11911 const char *startSpecifier,
11912 unsigned specifierLen) {
11914 FS.getConversionSpecifier();
11916 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
11918 startSpecifier, specifierLen,
11922void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
11923 S.
Diag(getLocationOfByte(MaskType.data()), diag::err_invalid_mask_type_size);
11926bool CheckPrintfHandler::HandleAmount(
11928 const char *startSpecifier,
unsigned specifierLen) {
11932 if (argIndex >= NumDataArgs) {
11933 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_missing_arg)
11935 getLocationOfByte(Amt.
getStart()),
11937 getSpecifierRange(startSpecifier, specifierLen));
11947 CoveredArgs.set(argIndex);
11948 const Expr *Arg = getDataArg(argIndex);
11958 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_wrong_type)
11961 getLocationOfByte(Amt.
getStart()),
11963 getSpecifierRange(startSpecifier, specifierLen));
11973void CheckPrintfHandler::HandleInvalidAmount(
11977 const char *startSpecifier,
11978 unsigned specifierLen) {
11980 FS.getConversionSpecifier();
11988 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_optional_amount)
11990 getLocationOfByte(Amt.
getStart()),
11992 getSpecifierRange(startSpecifier, specifierLen),
11998 const char *startSpecifier,
11999 unsigned specifierLen) {
12002 FS.getConversionSpecifier();
12003 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_flag)
12007 getSpecifierRange(startSpecifier, specifierLen),
12012void CheckPrintfHandler::HandleIgnoredFlag(
12016 const char *startSpecifier,
12017 unsigned specifierLen) {
12019 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_ignored_flag)
12023 getSpecifierRange(startSpecifier, specifierLen),
12025 getSpecifierRange(ignoredFlag.
getPosition(), 1)));
12028void CheckPrintfHandler::HandleEmptyObjCModifierFlag(
const char *startFlag,
12029 unsigned flagLen) {
12031 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_empty_objc_flag),
12032 getLocationOfByte(startFlag),
12034 getSpecifierRange(startFlag, flagLen));
12037void CheckPrintfHandler::HandleInvalidObjCModifierFlag(
const char *startFlag,
12038 unsigned flagLen) {
12040 auto Range = getSpecifierRange(startFlag, flagLen);
12041 StringRef flag(startFlag, flagLen);
12042 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_invalid_objc_flag) << flag,
12043 getLocationOfByte(startFlag),
12048void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
12049 const char *flagsStart,
const char *flagsEnd,
const char *conversionPosition) {
12051 auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
12052 auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
12053 EmitFormatDiagnostic(S.
PDiag(diag) << StringRef(conversionPosition, 1),
12054 getLocationOfByte(conversionPosition),
12062template<
typename MemberKind>
12083 if (MemberKind *FK = dyn_cast<MemberKind>(
decl))
12084 Results.insert(FK);
12096 MethodSet Results =
12097 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", *
this, E->
getType());
12098 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12100 if ((*MI)->getMinRequiredArguments() == 0)
12108bool CheckPrintfHandler::checkForCStrMembers(
12112 MethodSet Results =
12113 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", S, E->
getType());
12115 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12131bool CheckPrintfHandler::HandlePrintfSpecifier(
12134 using namespace analyze_format_string;
12135 using namespace analyze_printf;
12137 const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
12139 if (FS.consumesDataArgument()) {
12141 atFirstArg =
false;
12142 usesPositionalArgs = FS.usesPositionalArg();
12144 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12145 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12146 startSpecifier, specifierLen);
12153 if (!HandleAmount(FS.getFieldWidth(), 0,
12154 startSpecifier, specifierLen)) {
12158 if (!HandleAmount(FS.getPrecision(), 1,
12159 startSpecifier, specifierLen)) {
12163 if (!CS.consumesDataArgument()) {
12170 unsigned argIndex = FS.getArgIndex();
12171 if (argIndex < NumDataArgs) {
12175 CoveredArgs.set(argIndex);
12179 if (CS.getKind() == ConversionSpecifier::FreeBSDbArg ||
12180 CS.getKind() == ConversionSpecifier::FreeBSDDArg) {
12182 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex + 1))
12186 CoveredArgs.set(argIndex + 1);
12189 const Expr *Ex = getDataArg(argIndex);
12191 (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
12194 EmitFormatDiagnostic(
12195 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12199 getSpecifierRange(startSpecifier, specifierLen));
12202 Ex = getDataArg(argIndex + 1);
12205 EmitFormatDiagnostic(
12206 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12210 getSpecifierRange(startSpecifier, specifierLen));
12217 if (!allowsObjCArg() && CS.isObjCArg()) {
12218 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12223 if (FSType !=
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::PArg) {
12224 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12229 if (FSType ==
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {
12230 EmitFormatDiagnostic(S.
PDiag(diag::warn_os_log_format_narg),
12231 getLocationOfByte(CS.getStart()),
12233 getSpecifierRange(startSpecifier, specifierLen));
12240 (CS.getKind() == ConversionSpecifier::PArg ||
12241 CS.getKind() == ConversionSpecifier::sArg ||
12242 CS.getKind() == ConversionSpecifier::ObjCObjArg)) {
12243 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12249 if (FS.isPublic().isSet()) {
12250 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12252 getLocationOfByte(FS.isPublic().getPosition()),
12254 getSpecifierRange(startSpecifier, specifierLen));
12256 if (FS.isPrivate().isSet()) {
12257 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12259 getLocationOfByte(FS.isPrivate().getPosition()),
12261 getSpecifierRange(startSpecifier, specifierLen));
12265 const llvm::Triple &Triple =
Target.getTriple();
12266 if (CS.getKind() == ConversionSpecifier::nArg &&
12267 (Triple.isAndroid() || Triple.isOSFuchsia())) {
12268 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_narg_not_supported),
12269 getLocationOfByte(CS.getStart()),
12271 getSpecifierRange(startSpecifier, specifierLen));
12275 if (!FS.hasValidFieldWidth()) {
12276 HandleInvalidAmount(FS, FS.getFieldWidth(), 0,
12277 startSpecifier, specifierLen);
12281 if (!FS.hasValidPrecision()) {
12282 HandleInvalidAmount(FS, FS.getPrecision(), 1,
12283 startSpecifier, specifierLen);
12287 if (CS.getKind() == ConversionSpecifier::PArg &&
12288 FS.getPrecision().getHowSpecified() == OptionalAmount::NotSpecified) {
12289 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_no_precision),
12290 getLocationOfByte(startSpecifier),
12292 getSpecifierRange(startSpecifier, specifierLen));
12296 if (!FS.hasValidThousandsGroupingPrefix())
12297 HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen);
12298 if (!FS.hasValidLeadingZeros())
12299 HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
12300 if (!FS.hasValidPlusPrefix())
12301 HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
12302 if (!FS.hasValidSpacePrefix())
12303 HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
12304 if (!FS.hasValidAlternativeForm())
12305 HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
12306 if (!FS.hasValidLeftJustified())
12307 HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
12310 if (FS.hasSpacePrefix() && FS.hasPlusPrefix())
12311 HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
12312 startSpecifier, specifierLen);
12313 if (FS.hasLeadingZeros() && FS.isLeftJustified())
12314 HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
12315 startSpecifier, specifierLen);
12320 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12321 diag::warn_format_nonsensical_length);
12322 else if (!FS.hasStandardLengthModifier())
12323 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12324 else if (!FS.hasStandardLengthConversionCombination())
12325 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12326 diag::warn_format_non_standard_conversion_spec);
12328 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12329 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12335 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12338 const Expr *Arg = getDataArg(argIndex);
12342 return checkFormatExpr(FS, startSpecifier, specifierLen, Arg);
12354 case Stmt::ArraySubscriptExprClass:
12355 case Stmt::CallExprClass:
12356 case Stmt::CharacterLiteralClass:
12357 case Stmt::CXXBoolLiteralExprClass:
12358 case Stmt::DeclRefExprClass:
12359 case Stmt::FloatingLiteralClass:
12360 case Stmt::IntegerLiteralClass:
12361 case Stmt::MemberExprClass:
12362 case Stmt::ObjCArrayLiteralClass:
12363 case Stmt::ObjCBoolLiteralExprClass:
12364 case Stmt::ObjCBoxedExprClass:
12365 case Stmt::ObjCDictionaryLiteralClass:
12366 case Stmt::ObjCEncodeExprClass:
12367 case Stmt::ObjCIvarRefExprClass:
12368 case Stmt::ObjCMessageExprClass:
12369 case Stmt::ObjCPropertyRefExprClass:
12370 case Stmt::ObjCStringLiteralClass:
12371 case Stmt::ObjCSubscriptRefExprClass:
12372 case Stmt::ParenExprClass:
12373 case Stmt::StringLiteralClass:
12374 case Stmt::UnaryOperatorClass:
12381static std::pair<QualType, StringRef>
12388 StringRef Name = UserTy->getDecl()->getName();
12389 QualType CastTy = llvm::StringSwitch<QualType>(Name)
12393 .Case(
"SInt32", Context.
IntTy)
12398 return std::make_pair(CastTy, Name);
12400 TyTy = UserTy->desugar();
12404 if (
const ParenExpr *PE = dyn_cast<ParenExpr>(E))
12406 PE->getSubExpr()->getType(),
12415 StringRef TrueName, FalseName;
12417 std::tie(TrueTy, TrueName) =
12419 CO->getTrueExpr()->getType(),
12420 CO->getTrueExpr());
12421 std::tie(FalseTy, FalseName) =
12423 CO->getFalseExpr()->getType(),
12424 CO->getFalseExpr());
12426 if (TrueTy == FalseTy)
12427 return std::make_pair(TrueTy, TrueName);
12428 else if (TrueTy.
isNull())
12429 return std::make_pair(FalseTy, FalseName);
12430 else if (FalseTy.
isNull())
12431 return std::make_pair(TrueTy, TrueName);
12434 return std::make_pair(
QualType(), StringRef());
12453 From = VecTy->getElementType();
12455 To = VecTy->getElementType();
12467 diag::warn_format_conversion_argument_type_mismatch_signedness, Loc)
12476 const char *StartSpecifier,
12477 unsigned SpecifierLen,
12479 using namespace analyze_format_string;
12480 using namespace analyze_printf;
12489 while (
const TypeOfExprType *TET = dyn_cast<TypeOfExprType>(ExprTy)) {
12490 ExprTy = TET->getUnderlyingExpr()->getType();
12502 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::cArg &&
12505 getSpecifierRange(StartSpecifier, SpecifierLen);
12507 llvm::raw_svector_ostream os(FSString);
12509 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_bool_as_character)
12515 ArgType::MatchKind ImplicitMatch = ArgType::NoMatch;
12517 ArgType::MatchKind OrigMatch = Match;
12520 if (Match == ArgType::Match)
12524 assert(Match != ArgType::NoMatchPromotionTypeConfusion);
12533 E = ICE->getSubExpr();
12543 if (OrigMatch == ArgType::NoMatchSignedness &&
12544 ImplicitMatch != ArgType::NoMatchSignedness)
12551 if (ImplicitMatch == ArgType::Match)
12562 FS.getLengthModifier().getKind() != LengthModifier::AsChar)
12569 if (Match == ArgType::MatchPromotion)
12570 Match = ArgType::NoMatch;
12573 if (Match == ArgType::MatchPromotion) {
12577 ImplicitMatch != ArgType::NoMatchPromotionTypeConfusion &&
12578 ImplicitMatch != ArgType::NoMatchTypeConfusion)
12580 Match = ArgType::NoMatch;
12582 if (ImplicitMatch == ArgType::NoMatchPedantic ||
12583 ImplicitMatch == ArgType::NoMatchTypeConfusion)
12584 Match = ImplicitMatch;
12585 assert(Match != ArgType::MatchPromotion);
12588 bool IsEnum =
false;
12589 bool IsScopedEnum =
false;
12592 IntendedTy = EnumTy->getDecl()->getIntegerType();
12593 if (EnumTy->isUnscopedEnumerationType()) {
12594 ExprTy = IntendedTy;
12599 IsScopedEnum =
true;
12606 if (isObjCContext() &&
12607 FS.getConversionSpecifier().getKind() == ConversionSpecifier::CArg) {
12617 const llvm::APInt &
V = IL->getValue();
12627 if (TD->getUnderlyingType() == IntendedTy)
12635 bool ShouldNotPrintDirectly =
false; StringRef CastTyName;
12643 if (!IsScopedEnum &&
12644 (CastTyName ==
"NSInteger" || CastTyName ==
"NSUInteger") &&
12647 Match = ArgType::NoMatchPedantic;
12648 IntendedTy = CastTy;
12649 ShouldNotPrintDirectly =
true;
12654 PrintfSpecifier fixedFS = FS;
12661 llvm::raw_svector_ostream os(buf);
12662 fixedFS.toString(os);
12664 CharSourceRange SpecRange = getSpecifierRange(StartSpecifier, SpecifierLen);
12666 if (IntendedTy == ExprTy && !ShouldNotPrintDirectly && !IsScopedEnum) {
12669 case ArgType::Match:
12670 case ArgType::MatchPromotion:
12671 case ArgType::NoMatchPromotionTypeConfusion:
12672 case ArgType::NoMatchSignedness:
12673 llvm_unreachable(
"expected non-matching");
12674 case ArgType::NoMatchPedantic:
12675 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12677 case ArgType::NoMatchTypeConfusion:
12678 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12680 case ArgType::NoMatch:
12681 Diag = diag::warn_format_conversion_argument_type_mismatch;
12702 llvm::raw_svector_ostream CastFix(CastBuf);
12703 CastFix << (S.
LangOpts.CPlusPlus ?
"static_cast<" :
"(");
12705 CastFix << (S.
LangOpts.CPlusPlus ?
">" :
")");
12711 if ((IntendedMatch != ArgType::Match) || ShouldNotPrintDirectly)
12714 if (
const CStyleCastExpr *CCast = dyn_cast<CStyleCastExpr>(E)) {
12716 SourceRange CastRange(CCast->getLParenLoc(), CCast->getRParenLoc());
12738 if (ShouldNotPrintDirectly && !IsScopedEnum) {
12744 Name = TypedefTy->getDecl()->getName();
12747 unsigned Diag = Match == ArgType::NoMatchPedantic
12748 ? diag::warn_format_argument_needs_cast_pedantic
12749 : diag::warn_format_argument_needs_cast;
12750 EmitFormatDiagnostic(S.
PDiag(
Diag) << Name << IntendedTy << IsEnum
12758 EmitFormatDiagnostic(
12759 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12771 bool EmitTypeMismatch =
false;
12777 case ArgType::Match:
12778 case ArgType::MatchPromotion:
12779 case ArgType::NoMatchPromotionTypeConfusion:
12780 case ArgType::NoMatchSignedness:
12781 llvm_unreachable(
"expected non-matching");
12782 case ArgType::NoMatchPedantic:
12783 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12785 case ArgType::NoMatchTypeConfusion:
12786 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12788 case ArgType::NoMatch:
12789 Diag = diag::warn_format_conversion_argument_type_mismatch;
12793 EmitFormatDiagnostic(
12802 EmitTypeMismatch =
true;
12804 EmitFormatDiagnostic(
12805 S.
PDiag(diag::warn_non_pod_vararg_with_format_string)
12806 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12810 checkForCStrMembers(AT, E);
12816 EmitTypeMismatch =
true;
12818 EmitFormatDiagnostic(
12819 S.
PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
12820 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12828 << isa<InitListExpr>(E) << ExprTy << CallType
12833 if (EmitTypeMismatch) {
12839 EmitFormatDiagnostic(
12840 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12846 assert(FirstDataArg + FS.getArgIndex() < CheckedVarArgs.size() &&
12847 "format string specifier index out of range");
12848 CheckedVarArgs[FirstDataArg + FS.getArgIndex()] =
true;
12858class CheckScanfHandler :
public CheckFormatHandler {
12860 CheckScanfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
12862 unsigned firstDataArg,
unsigned numDataArgs,
12866 llvm::SmallBitVector &CheckedVarArgs,
12867 UncoveredArgHandler &UncoveredArg)
12868 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
12869 numDataArgs, beg, APK, Args, formatIdx,
12870 inFunctionCall, CallType, CheckedVarArgs,
12874 const char *startSpecifier,
12875 unsigned specifierLen)
override;
12877 bool HandleInvalidScanfConversionSpecifier(
12879 const char *startSpecifier,
12880 unsigned specifierLen)
override;
12882 void HandleIncompleteScanList(
const char *start,
const char *end)
override;
12887void CheckScanfHandler::HandleIncompleteScanList(
const char *start,
12889 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_scanlist_incomplete),
12890 getLocationOfByte(end),
true,
12891 getSpecifierRange(start, end - start));
12894bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
12896 const char *startSpecifier,
12897 unsigned specifierLen) {
12899 FS.getConversionSpecifier();
12901 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
12903 startSpecifier, specifierLen,
12907bool CheckScanfHandler::HandleScanfSpecifier(
12909 const char *startSpecifier,
12910 unsigned specifierLen) {
12911 using namespace analyze_scanf;
12912 using namespace analyze_format_string;
12914 const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
12918 if (FS.consumesDataArgument()) {
12920 atFirstArg =
false;
12921 usesPositionalArgs = FS.usesPositionalArg();
12923 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12924 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12925 startSpecifier, specifierLen);
12931 const OptionalAmount &Amt = FS.getFieldWidth();
12932 if (Amt.getHowSpecified() == OptionalAmount::Constant) {
12933 if (Amt.getConstantAmount() == 0) {
12935 Amt.getConstantLength());
12936 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_nonzero_width),
12937 getLocationOfByte(Amt.getStart()),
12943 if (!FS.consumesDataArgument()) {
12950 unsigned argIndex = FS.getArgIndex();
12951 if (argIndex < NumDataArgs) {
12955 CoveredArgs.set(argIndex);
12961 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12962 diag::warn_format_nonsensical_length);
12963 else if (!FS.hasStandardLengthModifier())
12964 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12965 else if (!FS.hasStandardLengthConversionCombination())
12966 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12967 diag::warn_format_non_standard_conversion_spec);
12969 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12970 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12976 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12980 const Expr *Ex = getDataArg(argIndex);
12997 ScanfSpecifier fixedFS = FS;
13002 Pedantic ? diag::warn_format_conversion_argument_type_mismatch_pedantic
13003 : diag::warn_format_conversion_argument_type_mismatch;
13008 llvm::raw_svector_ostream os(buf);
13009 fixedFS.toString(os);
13011 EmitFormatDiagnostic(
13016 getSpecifierRange(startSpecifier, specifierLen),
13018 getSpecifierRange(startSpecifier, specifierLen), os.str()));
13025 getSpecifierRange(startSpecifier, specifierLen));
13032 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
13036 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
13037 bool IgnoreStringsWithoutSpecifiers) {
13039 if (!FExpr->isAscii() && !FExpr->isUTF8()) {
13040 CheckFormatHandler::EmitFormatDiagnostic(
13041 S, inFunctionCall, Args[format_idx],
13042 S.
PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
13048 StringRef StrRef = FExpr->getString();
13049 const char *Str = StrRef.data();
13053 assert(
T &&
"String literal not of constant array type!");
13054 size_t TypeSize =
T->getZExtSize();
13055 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13056 const unsigned numDataArgs = Args.size() - firstDataArg;
13058 if (IgnoreStringsWithoutSpecifiers &&
13065 if (TypeSize <= StrRef.size() && !StrRef.substr(0, TypeSize).contains(
'\0')) {
13066 CheckFormatHandler::EmitFormatDiagnostic(
13067 S, inFunctionCall, Args[format_idx],
13068 S.
PDiag(diag::warn_printf_format_string_not_null_terminated),
13069 FExpr->getBeginLoc(),
13075 if (StrLen == 0 && numDataArgs > 0) {
13076 CheckFormatHandler::EmitFormatDiagnostic(
13077 S, inFunctionCall, Args[format_idx],
13078 S.
PDiag(diag::warn_empty_format_string), FExpr->getBeginLoc(),
13086 CheckPrintfHandler H(
13087 S, FExpr, OrigFormatExpr,
Type, firstDataArg, numDataArgs,
13089 Args, format_idx, inFunctionCall, CallType, CheckedVarArgs,
13095 H.DoneProcessing();
13097 CheckScanfHandler H(S, FExpr, OrigFormatExpr,
Type, firstDataArg,
13098 numDataArgs, Str, APK, Args, format_idx, inFunctionCall,
13099 CallType, CheckedVarArgs, UncoveredArg);
13103 H.DoneProcessing();
13110 const char *Str = StrRef.data();
13113 assert(
T &&
"String literal not of constant array type!");
13114 size_t TypeSize =
T->getZExtSize();
13115 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13126 switch (AbsFunction) {
13130 case Builtin::BI__builtin_abs:
13131 return Builtin::BI__builtin_labs;
13132 case Builtin::BI__builtin_labs:
13133 return Builtin::BI__builtin_llabs;
13134 case Builtin::BI__builtin_llabs:
13137 case Builtin::BI__builtin_fabsf:
13138 return Builtin::BI__builtin_fabs;
13139 case Builtin::BI__builtin_fabs:
13140 return Builtin::BI__builtin_fabsl;
13141 case Builtin::BI__builtin_fabsl:
13144 case Builtin::BI__builtin_cabsf:
13145 return Builtin::BI__builtin_cabs;
13146 case Builtin::BI__builtin_cabs:
13147 return Builtin::BI__builtin_cabsl;
13148 case Builtin::BI__builtin_cabsl:
13151 case Builtin::BIabs:
13152 return Builtin::BIlabs;
13153 case Builtin::BIlabs:
13154 return Builtin::BIllabs;
13155 case Builtin::BIllabs:
13158 case Builtin::BIfabsf:
13159 return Builtin::BIfabs;
13160 case Builtin::BIfabs:
13161 return Builtin::BIfabsl;
13162 case Builtin::BIfabsl:
13165 case Builtin::BIcabsf:
13166 return Builtin::BIcabs;
13167 case Builtin::BIcabs:
13168 return Builtin::BIcabsl;
13169 case Builtin::BIcabsl:
13176 unsigned AbsType) {
13198 unsigned AbsFunctionKind) {
13199 unsigned BestKind = 0;
13201 for (
unsigned Kind = AbsFunctionKind; Kind != 0;
13207 else if (Context.
hasSameType(ParamType, ArgType)) {
13230 llvm_unreachable(
"Type not integer, floating, or complex");
13237 switch (ValueKind) {
13242 case Builtin::BI__builtin_fabsf:
13243 case Builtin::BI__builtin_fabs:
13244 case Builtin::BI__builtin_fabsl:
13245 case Builtin::BI__builtin_cabsf:
13246 case Builtin::BI__builtin_cabs:
13247 case Builtin::BI__builtin_cabsl:
13248 return Builtin::BI__builtin_abs;
13249 case Builtin::BIfabsf:
13250 case Builtin::BIfabs:
13251 case Builtin::BIfabsl:
13252 case Builtin::BIcabsf:
13253 case Builtin::BIcabs:
13254 case Builtin::BIcabsl:
13255 return Builtin::BIabs;
13261 case Builtin::BI__builtin_abs:
13262 case Builtin::BI__builtin_labs:
13263 case Builtin::BI__builtin_llabs:
13264 case Builtin::BI__builtin_cabsf:
13265 case Builtin::BI__builtin_cabs:
13266 case Builtin::BI__builtin_cabsl:
13267 return Builtin::BI__builtin_fabsf;
13268 case Builtin::BIabs:
13269 case Builtin::BIlabs:
13270 case Builtin::BIllabs:
13271 case Builtin::BIcabsf:
13272 case Builtin::BIcabs:
13273 case Builtin::BIcabsl:
13274 return Builtin::BIfabsf;
13280 case Builtin::BI__builtin_abs:
13281 case Builtin::BI__builtin_labs:
13282 case Builtin::BI__builtin_llabs:
13283 case Builtin::BI__builtin_fabsf:
13284 case Builtin::BI__builtin_fabs:
13285 case Builtin::BI__builtin_fabsl:
13286 return Builtin::BI__builtin_cabsf;
13287 case Builtin::BIabs:
13288 case Builtin::BIlabs:
13289 case Builtin::BIllabs:
13290 case Builtin::BIfabsf:
13291 case Builtin::BIfabs:
13292 case Builtin::BIfabsl:
13293 return Builtin::BIcabsf;
13296 llvm_unreachable(
"Unable to convert function");
13307 case Builtin::BI__builtin_abs:
13308 case Builtin::BI__builtin_fabs:
13309 case Builtin::BI__builtin_fabsf:
13310 case Builtin::BI__builtin_fabsl:
13311 case Builtin::BI__builtin_labs:
13312 case Builtin::BI__builtin_llabs:
13313 case Builtin::BI__builtin_cabs:
13314 case Builtin::BI__builtin_cabsf:
13315 case Builtin::BI__builtin_cabsl:
13316 case Builtin::BIabs:
13317 case Builtin::BIlabs:
13318 case Builtin::BIllabs:
13319 case Builtin::BIfabs:
13320 case Builtin::BIfabsf:
13321 case Builtin::BIfabsl:
13322 case Builtin::BIcabs:
13323 case Builtin::BIcabsf:
13324 case Builtin::BIcabsl:
13327 llvm_unreachable(
"Unknown Builtin type");
13333 unsigned AbsKind,
QualType ArgType) {
13334 bool EmitHeaderHint =
true;
13335 const char *HeaderName =
nullptr;
13336 StringRef FunctionName;
13338 FunctionName =
"std::abs";
13340 HeaderName =
"cstdlib";
13342 HeaderName =
"cmath";
13344 llvm_unreachable(
"Invalid Type");
13353 for (
const auto *I : R) {
13356 FDecl = dyn_cast<FunctionDecl>(UsingD->getTargetDecl());
13358 FDecl = dyn_cast<FunctionDecl>(I);
13373 EmitHeaderHint =
false;
13391 EmitHeaderHint =
false;
13395 }
else if (!R.
empty()) {
13401 S.
Diag(Loc, diag::note_replace_abs_function)
13407 if (!EmitHeaderHint)
13410 S.
Diag(Loc, diag::note_include_header_or_declare) << HeaderName
13414template <std::
size_t StrLen>
13416 const char (&Str)[StrLen]) {
13431 (
Call->getBuiltinCallee() == Builtin::BI__builtin_nanf)) &&
13432 FPO.getNoHonorNaNs())
13433 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13434 << 1 << 0 <<
Call->getSourceRange();
13438 FPO.getNoHonorInfs())
13439 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13440 << 0 << 0 <<
Call->getSourceRange();
13444void Sema::CheckAbsoluteValueFunction(
const CallExpr *
Call,
13446 if (
Call->getNumArgs() != 1)
13451 if (AbsKind == 0 && !IsStdAbs)
13454 QualType ArgType =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13460 StringRef FunctionName =
13462 Diag(
Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
13463 Diag(
Call->getExprLoc(), diag::note_remove_abs)
13472 unsigned DiagType = 0;
13478 Diag(
Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;
13492 if (ArgValueKind == ParamValueKind) {
13497 Diag(
Call->getExprLoc(), diag::warn_abs_too_small)
13498 << FDecl << ArgType << ParamType;
13500 if (NewAbsKind == 0)
13504 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13513 if (NewAbsKind == 0)
13516 Diag(
Call->getExprLoc(), diag::warn_wrong_absolute_value_type)
13517 << FDecl << ParamValueKind << ArgValueKind;
13520 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13526 if (!
Call || !FDecl)
return;
13530 if (
Call->getExprLoc().isMacroID())
return;
13533 if (
Call->getNumArgs() != 2)
return;
13536 if (!ArgList)
return;
13537 if (ArgList->size() != 1)
return;
13540 const auto& TA = ArgList->
get(0);
13542 QualType ArgType = TA.getAsType();
13546 auto IsLiteralZeroArg = [](
const Expr* E) ->
bool {
13547 const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
13548 if (!MTE)
return false;
13549 const auto *Num = dyn_cast<IntegerLiteral>(MTE->getSubExpr());
13550 if (!Num)
return false;
13551 if (Num->getValue() != 0)
return false;
13555 const Expr *FirstArg =
Call->getArg(0);
13556 const Expr *SecondArg =
Call->getArg(1);
13557 const bool IsFirstArgZero = IsLiteralZeroArg(FirstArg);
13558 const bool IsSecondArgZero = IsLiteralZeroArg(SecondArg);
13561 if (IsFirstArgZero == IsSecondArgZero)
return;
13566 SourceRange ZeroRange = IsFirstArgZero ? FirstRange : SecondRange;
13568 Diag(
Call->getExprLoc(), diag::warn_max_unsigned_zero)
13569 << IsFirstArgZero <<
Call->getCallee()->getSourceRange() << ZeroRange;
13573 if (IsFirstArgZero) {
13581 Diag(
Call->getExprLoc(), diag::note_remove_max_call)
13601 if (!Size->isComparisonOp() && !Size->isLogicalOp())
13605 S.
Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison)
13606 << SizeRange << FnName;
13607 S.
Diag(FnLoc, diag::note_memsize_comparison_paren)
13612 S.
Diag(SizeRange.
getBegin(), diag::note_memsize_comparison_cast_silence)
13623 bool &IsContained) {
13626 IsContained =
false;
13639 for (
auto *FD : RD->
fields()) {
13643 IsContained =
true;
13644 return ContainedRD;
13652 if (
const auto *Unary = dyn_cast<UnaryExprOrTypeTraitExpr>(E))
13653 if (Unary->getKind() == UETT_SizeOf)
13662 if (!
SizeOf->isArgumentType())
13663 return SizeOf->getArgumentExpr()->IgnoreParenImpCasts();
13670 return SizeOf->getTypeOfArgument();
13676struct SearchNonTrivialToInitializeField
13681 SearchNonTrivialToInitializeField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13685 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13686 asDerived().visitArray(PDIK, AT, SL);
13690 Super::visitWithKind(PDIK, FT, SL);
13705 visit(getContext().getBaseElementType(AT), SL);
13710 SearchNonTrivialToInitializeField(E, S).visitStruct(RT,
SourceLocation());
13719struct SearchNonTrivialToCopyField
13723 SearchNonTrivialToCopyField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13727 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13728 asDerived().visitArray(PCK, AT, SL);
13732 Super::visitWithKind(PCK, FT, SL);
13747 visit(getContext().getBaseElementType(AT), SL);
13755 SearchNonTrivialToCopyField(E, S).visitStruct(RT,
SourceLocation());
13770 if (
const auto *BO = dyn_cast<BinaryOperator>(SizeofExpr)) {
13771 if (BO->getOpcode() != BO_Mul && BO->getOpcode() != BO_Add)
13795 return SM.getFileID(CallLoc) !=
SM.getFileID(ArgLoc);
13797 return SM.getFileID(
SM.getImmediateMacroCallerLoc(CallLoc)) !=
13798 SM.getFileID(
SM.getImmediateMacroCallerLoc(ArgLoc));
13804 if (BId != Builtin::BImemset && BId != Builtin::BIbzero)
13807 const Expr *SizeArg =
13808 Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
13810 auto isLiteralZero = [](
const Expr *E) {
13811 return (isa<IntegerLiteral>(E) &&
13812 cast<IntegerLiteral>(E)->getValue() == 0) ||
13813 (isa<CharacterLiteral>(E) &&
13814 cast<CharacterLiteral>(E)->getValue() == 0);
13820 if (isLiteralZero(SizeArg) &&
13827 if (BId == Builtin::BIbzero ||
13830 S.
Diag(DiagLoc, diag::warn_suspicious_bzero_size);
13831 S.
Diag(DiagLoc, diag::note_suspicious_bzero_size_silence);
13832 }
else if (!isLiteralZero(
Call->getArg(1)->IgnoreImpCasts())) {
13833 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 0;
13834 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 0;
13842 if (BId == Builtin::BImemset &&
13846 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 1;
13847 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 1;
13859void Sema::CheckMemaccessArguments(
const CallExpr *
Call,
13866 unsigned ExpectedNumArgs =
13867 (BId == Builtin::BIstrndup || BId == Builtin::BIbzero ? 2 : 3);
13868 if (
Call->getNumArgs() < ExpectedNumArgs)
13871 unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
13872 BId == Builtin::BIstrndup ? 1 : 2);
13874 (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
13875 const Expr *LenExpr =
Call->getArg(LenArg)->IgnoreParenImpCasts();
13878 Call->getBeginLoc(),
Call->getRParenLoc()))
13887 llvm::FoldingSetNodeID SizeOfArgID;
13892 QualType FirstArgTy =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13896 for (
unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {
13897 const Expr *Dest =
Call->getArg(ArgIdx)->IgnoreParenImpCasts();
13919 if (SizeOfArgID == llvm::FoldingSetNodeID())
13921 llvm::FoldingSetNodeID DestID;
13923 if (DestID == SizeOfArgID) {
13926 unsigned ActionIdx = 0;
13927 StringRef ReadableName = FnName->
getName();
13929 if (
const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
13930 if (UnaryOp->getOpcode() == UO_AddrOf)
13944 if (
SM.isMacroArgExpansion(SL)) {
13946 SL =
SM.getSpellingLoc(SL);
13954 PDiag(diag::warn_sizeof_pointer_expr_memaccess)
13961 PDiag(diag::warn_sizeof_pointer_expr_memaccess_note)
13976 PDiag(diag::warn_sizeof_pointer_type_memaccess)
13977 << FnName << SizeOfArgTy << ArgIdx
13984 PointeeTy = DestTy;
13995 unsigned OperationType = 0;
13996 const bool IsCmp = BId == Builtin::BImemcmp || BId == Builtin::BIbcmp;
13999 if (ArgIdx != 0 || IsCmp) {
14000 if (BId == Builtin::BImemcpy)
14002 else if(BId == Builtin::BImemmove)
14009 PDiag(diag::warn_dyn_class_memaccess)
14010 << (IsCmp ? ArgIdx + 2 : ArgIdx) << FnName
14011 << IsContained << ContainedRD << OperationType
14012 <<
Call->getCallee()->getSourceRange());
14014 BId != Builtin::BImemset)
14017 PDiag(diag::warn_arc_object_memaccess)
14018 << ArgIdx << FnName << PointeeTy
14019 <<
Call->getCallee()->getSourceRange());
14021 if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
14022 RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
14024 PDiag(diag::warn_cstruct_memaccess)
14025 << ArgIdx << FnName << PointeeTy << 0);
14026 SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *
this);
14027 }
else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
14028 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
14030 PDiag(diag::warn_cstruct_memaccess)
14031 << ArgIdx << FnName << PointeeTy << 1);
14032 SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *
this);
14041 PDiag(diag::note_bad_memaccess_silence)
14061 if (isa<IntegerLiteral>(RHS))
14063 else if (isa<IntegerLiteral>(LHS))
14077 if (CAT->getZExtSize() <= 1)
14087void Sema::CheckStrlcpycatArguments(
const CallExpr *
Call,
14091 unsigned NumArgs =
Call->getNumArgs();
14092 if ((NumArgs != 3) && (NumArgs != 4))
14097 const Expr *CompareWithSrc =
nullptr;
14100 Call->getBeginLoc(),
Call->getRParenLoc()))
14105 CompareWithSrc = Ex;
14108 if (
const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
14109 if (SizeCall->getBuiltinCallee() == Builtin::BIstrlen &&
14110 SizeCall->getNumArgs() == 1)
14115 if (!CompareWithSrc)
14122 const DeclRefExpr *SrcArgDRE = dyn_cast<DeclRefExpr>(SrcArg);
14126 const DeclRefExpr *CompareWithSrcDRE = dyn_cast<DeclRefExpr>(CompareWithSrc);
14127 if (!CompareWithSrcDRE ||
14131 const Expr *OriginalSizeArg =
Call->getArg(2);
14132 Diag(CompareWithSrcDRE->
getBeginLoc(), diag::warn_strlcpycat_wrong_size)
14139 const Expr *DstArg =
Call->getArg(0)->IgnoreParenImpCasts();
14144 llvm::raw_svector_ostream
OS(sizeString);
14149 Diag(OriginalSizeArg->
getBeginLoc(), diag::note_strlcpycat_wrong_size)
14156 if (
const DeclRefExpr *D1 = dyn_cast_or_null<DeclRefExpr>(E1))
14157 if (
const DeclRefExpr *D2 = dyn_cast_or_null<DeclRefExpr>(E2))
14158 return D1->getDecl() == D2->getDecl();
14163 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
14167 return CE->getArg(0)->IgnoreParenCasts();
14175void Sema::CheckStrncatArguments(
const CallExpr *CE,
14190 unsigned PatternType = 0;
14198 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(LenArg)) {
14199 if (BE->getOpcode() == BO_Sub) {
14212 if (PatternType == 0)
14221 if (
SM.isMacroArgExpansion(SL)) {
14222 SL =
SM.getSpellingLoc(SL);
14231 if (!isKnownSizeArray) {
14232 if (PatternType == 1)
14233 Diag(SL, diag::warn_strncat_wrong_size) << SR;
14235 Diag(SL, diag::warn_strncat_src_size) << SR;
14239 if (PatternType == 1)
14240 Diag(SL, diag::warn_strncat_large_size) << SR;
14242 Diag(SL, diag::warn_strncat_src_size) << SR;
14245 llvm::raw_svector_ostream
OS(sizeString);
14253 Diag(SL, diag::note_strncat_wrong_size)
14258void CheckFreeArgumentsOnLvalue(
Sema &S,
const std::string &CalleeName,
14260 if (isa<FieldDecl, FunctionDecl, VarDecl>(D)) {
14262 << CalleeName << 0 << cast<NamedDecl>(D);
14267void CheckFreeArgumentsAddressof(
Sema &S,
const std::string &CalleeName,
14269 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->
getSubExpr())) {
14270 const Decl *D = Lvalue->getDecl();
14271 if (isa<DeclaratorDecl>(D))
14272 if (!dyn_cast<DeclaratorDecl>(D)->getType()->isReferenceType())
14273 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
14276 if (
const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->
getSubExpr()))
14277 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
14278 Lvalue->getMemberDecl());
14281void CheckFreeArgumentsPlus(
Sema &S,
const std::string &CalleeName,
14283 const auto *Lambda = dyn_cast<LambdaExpr>(
14288 S.
Diag(Lambda->getBeginLoc(), diag::warn_free_nonheap_object)
14289 << CalleeName << 2 ;
14292void CheckFreeArgumentsStackArray(
Sema &S,
const std::string &CalleeName,
14294 const auto *Var = dyn_cast<VarDecl>(Lvalue->
getDecl());
14295 if (Var ==
nullptr)
14299 << CalleeName << 0 << Var;
14302void CheckFreeArgumentsCast(
Sema &S,
const std::string &CalleeName,
14305 llvm::raw_svector_ostream OS(SizeString);
14308 if (Kind == clang::CK_BitCast &&
14309 !
Cast->getSubExpr()->getType()->isFunctionPointerType())
14311 if (Kind == clang::CK_IntegralToPointer &&
14312 !isa<IntegerLiteral>(
14313 Cast->getSubExpr()->IgnoreParenImpCasts()->IgnoreParens()))
14316 switch (
Cast->getCastKind()) {
14317 case clang::CK_BitCast:
14318 case clang::CK_IntegralToPointer:
14319 case clang::CK_FunctionToPointerDecay:
14328 S.
Diag(
Cast->getBeginLoc(), diag::warn_free_nonheap_object)
14329 << CalleeName << 0 << OS.str();
14334void Sema::CheckFreeArguments(
const CallExpr *E) {
14335 const std::string CalleeName =
14336 cast<FunctionDecl>(E->
getCalleeDecl())->getQualifiedNameAsString();
14340 if (
const auto *UnaryExpr = dyn_cast<UnaryOperator>(Arg))
14342 case UnaryOperator::Opcode::UO_AddrOf:
14343 return CheckFreeArgumentsAddressof(*
this, CalleeName, UnaryExpr);
14344 case UnaryOperator::Opcode::UO_Plus:
14345 return CheckFreeArgumentsPlus(*
this, CalleeName, UnaryExpr);
14350 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
14352 return CheckFreeArgumentsStackArray(*
this, CalleeName, Lvalue);
14354 if (
const auto *
Label = dyn_cast<AddrLabelExpr>(Arg)) {
14355 Diag(
Label->getBeginLoc(), diag::warn_free_nonheap_object)
14356 << CalleeName << 0 <<
Label->getLabel()->getIdentifier();
14360 if (isa<BlockExpr>(Arg)) {
14362 << CalleeName << 1 ;
14367 if (
const auto *Cast = dyn_cast<CastExpr>(E->
getArg(0)))
14368 return CheckFreeArgumentsCast(*
this, CalleeName, Cast);
14372Sema::CheckReturnValExpr(
Expr *RetValExp,
QualType lhsType,
14378 if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) ||
14381 Diag(ReturnLoc, diag::warn_null_ret)
14391 if (Op == OO_New || Op == OO_Array_New) {
14396 Diag(ReturnLoc, diag::warn_operator_new_returns_null)
14402 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
14408 CheckPPCMMAType(RetValExp->
getType(), ReturnLoc);
14421 auto getCastAndLiteral = [&FPLiteral, &FPCast](
Expr *L,
Expr *R) {
14422 FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
14424 return FPLiteral && FPCast;
14427 if (getCastAndLiteral(LHS, RHS) || getCastAndLiteral(RHS, LHS)) {
14433 llvm::APFloat TargetC = FPLiteral->
getValue();
14435 llvm::APFloat::rmNearestTiesToEven, &Lossy);
14439 Diag(Loc, diag::warn_float_compare_literal)
14440 << (Opcode == BO_EQ) <<
QualType(SourceTy, 0)
14453 if (
auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
14454 if (
auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
14455 if (DRL->getDecl() == DRR->getDecl())
14463 if (
FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
14464 if (FLL->isExact())
14467 if (
FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
14468 if (FLR->isExact())
14472 if (
CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
14473 if (CL->getBuiltinCallee())
14476 if (
CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
14477 if (CR->getBuiltinCallee())
14481 Diag(Loc, diag::warn_floatingpoint_eq)
14502 IntRange(
unsigned Width,
bool NonNegative)
14503 : Width(Width), NonNegative(NonNegative) {}
14506 unsigned valueBits()
const {
14507 return NonNegative ? Width : Width - 1;
14511 static IntRange forBoolType() {
14512 return IntRange(1,
true);
14517 return forValueOfCanonicalType(
C,
14525 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14526 T = VT->getElementType().getTypePtr();
14528 T = CT->getElementType().getTypePtr();
14529 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14530 T = AT->getValueType().getTypePtr();
14532 if (!
C.getLangOpts().CPlusPlus) {
14534 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14535 T = ET->getDecl()->getIntegerType().getDesugaredType(
C).getTypePtr();
14536 }
else if (
const EnumType *ET = dyn_cast<EnumType>(
T)) {
14541 if (
Enum->isFixed()) {
14542 return IntRange(
C.getIntWidth(
QualType(
T, 0)),
14543 !ET->isSignedIntegerOrEnumerationType());
14546 unsigned NumPositive =
Enum->getNumPositiveBits();
14547 unsigned NumNegative =
Enum->getNumNegativeBits();
14549 if (NumNegative == 0)
14550 return IntRange(NumPositive,
true);
14552 return IntRange(std::max(NumPositive + 1, NumNegative),
14556 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14557 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14573 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14574 T = VT->getElementType().getTypePtr();
14576 T = CT->getElementType().getTypePtr();
14577 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14578 T = AT->getValueType().getTypePtr();
14579 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14580 T =
C.getCanonicalType(ET->getDecl()->getIntegerType()).getTypePtr();
14582 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14583 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14592 static IntRange join(IntRange L, IntRange R) {
14593 bool Unsigned = L.NonNegative && R.NonNegative;
14594 return IntRange(std::max(L.valueBits(), R.valueBits()) + !
Unsigned,
14595 L.NonNegative && R.NonNegative);
14599 static IntRange bit_and(IntRange L, IntRange R) {
14600 unsigned Bits = std::max(L.Width, R.Width);
14601 bool NonNegative =
false;
14602 if (L.NonNegative) {
14603 Bits = std::min(Bits, L.Width);
14604 NonNegative =
true;
14606 if (R.NonNegative) {
14607 Bits = std::min(Bits, R.Width);
14608 NonNegative =
true;
14610 return IntRange(Bits, NonNegative);
14614 static IntRange sum(IntRange L, IntRange R) {
14615 bool Unsigned = L.NonNegative && R.NonNegative;
14616 return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !
Unsigned,
14621 static IntRange difference(IntRange L, IntRange R) {
14625 bool CanWiden = !L.NonNegative || !R.NonNegative;
14626 bool Unsigned = L.NonNegative && R.Width == 0;
14627 return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
14633 static IntRange product(IntRange L, IntRange R) {
14637 bool CanWiden = !L.NonNegative && !R.NonNegative;
14638 bool Unsigned = L.NonNegative && R.NonNegative;
14639 return IntRange(L.valueBits() + R.valueBits() + CanWiden + !
Unsigned,
14644 static IntRange rem(IntRange L, IntRange R) {
14648 return IntRange(std::min(L.valueBits(), R.valueBits()) + !
Unsigned,
14656 unsigned MaxWidth) {
14657 if (value.isSigned() && value.isNegative())
14658 return IntRange(value.getSignificantBits(),
false);
14660 if (value.getBitWidth() > MaxWidth)
14661 value = value.trunc(MaxWidth);
14665 return IntRange(value.getActiveBits(),
true);
14669 unsigned MaxWidth) {
14670 if (result.
isInt())
14677 R = IntRange::join(R, El);
14685 return IntRange::join(R, I);
14700 Ty = AtomicRHS->getValueType();
14713 bool InConstantContext,
bool Approximate) {
14724 if (
const auto *CE = dyn_cast<ImplicitCastExpr>(E)) {
14725 if (CE->getCastKind() == CK_NoOp || CE->getCastKind() == CK_LValueToRValue)
14726 return GetExprRange(
C, CE->getSubExpr(), MaxWidth, InConstantContext,
14729 IntRange OutputTypeRange = IntRange::forValueOfType(
C,
GetExprType(CE));
14731 bool isIntegerCast = CE->getCastKind() == CK_IntegralCast ||
14732 CE->getCastKind() == CK_BooleanToSignedIntegral;
14735 if (!isIntegerCast)
14736 return OutputTypeRange;
14739 std::min(MaxWidth, OutputTypeRange.Width),
14740 InConstantContext, Approximate);
14743 if (SubRange.Width >= OutputTypeRange.Width)
14744 return OutputTypeRange;
14748 return IntRange(SubRange.Width,
14749 SubRange.NonNegative || OutputTypeRange.NonNegative);
14752 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
14755 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult,
C))
14757 CondResult ? CO->getTrueExpr() : CO->getFalseExpr(),
14758 MaxWidth, InConstantContext, Approximate);
14763 Expr *E = CO->getTrueExpr();
14765 ? IntRange{0,
true}
14766 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14767 E = CO->getFalseExpr();
14769 ? IntRange{0,
true}
14770 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14771 return IntRange::join(L, R);
14774 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
14775 IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
14777 switch (BO->getOpcode()) {
14779 llvm_unreachable(
"builtin <=> should have class type");
14790 return IntRange::forBoolType();
14808 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14819 Combine = IntRange::bit_and;
14827 = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
14828 if (I->getValue() == 1) {
14829 IntRange R = IntRange::forValueOfType(
C,
GetExprType(E));
14830 return IntRange(R.Width,
true);
14840 case BO_ShrAssign: {
14841 IntRange L =
GetExprRange(
C, BO->getLHS(), MaxWidth, InConstantContext,
14846 if (std::optional<llvm::APSInt> shift =
14847 BO->getRHS()->getIntegerConstantExpr(
C)) {
14848 if (shift->isNonNegative()) {
14849 if (shift->uge(L.Width))
14850 L.Width = (L.NonNegative ? 0 : 1);
14852 L.Width -= shift->getZExtValue();
14861 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14866 Combine = IntRange::sum;
14870 if (BO->getLHS()->getType()->isPointerType())
14873 Combine = IntRange::difference;
14878 Combine = IntRange::product;
14886 IntRange L =
GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext,
14890 if (std::optional<llvm::APSInt> divisor =
14891 BO->getRHS()->getIntegerConstantExpr(
C)) {
14892 unsigned log2 = divisor->logBase2();
14893 if (
log2 >= L.Width)
14894 L.Width = (L.NonNegative ? 0 : 1);
14896 L.Width = std::min(L.Width -
log2, MaxWidth);
14903 IntRange R =
GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext,
14905 return IntRange(L.Width, L.NonNegative && R.NonNegative);
14909 Combine = IntRange::rem;
14921 unsigned opWidth =
C.getIntWidth(
T);
14923 GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext, Approximate);
14925 GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext, Approximate);
14926 IntRange
C = Combine(L, R);
14928 C.Width = std::min(
C.Width, MaxWidth);
14932 if (
const auto *UO = dyn_cast<UnaryOperator>(E)) {
14933 switch (UO->getOpcode()) {
14936 return IntRange::forBoolType();
14944 return GetExprRange(
C, UO->getSubExpr(), MaxWidth, InConstantContext,
14949 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
14950 return GetExprRange(
C, OVE->getSourceExpr(), MaxWidth, InConstantContext,
14954 return IntRange(BitField->getBitWidthValue(
C),
14955 BitField->getType()->isUnsignedIntegerOrEnumerationType());
14961 bool InConstantContext,
bool Approximate) {
14970 const llvm::fltSemantics &Src,
14971 const llvm::fltSemantics &Tgt) {
14972 llvm::APFloat truncated = value;
14975 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
14976 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
14978 return truncated.bitwiseIsEqual(value);
14987 const llvm::fltSemantics &Src,
14988 const llvm::fltSemantics &Tgt) {
15005 bool IsListInit =
false);
15011 if (isa<EnumConstantDecl>(DR->getDecl()))
15021 return MacroName !=
"YES" && MacroName !=
"NO" &&
15022 MacroName !=
"true" && MacroName !=
"false";
15045struct PromotedRange {
15047 llvm::APSInt PromotedMin;
15049 llvm::APSInt PromotedMax;
15051 PromotedRange(IntRange R,
unsigned BitWidth,
bool Unsigned) {
15053 PromotedMin = PromotedMax = llvm::APSInt(BitWidth,
Unsigned);
15054 else if (R.Width >= BitWidth && !
Unsigned) {
15058 PromotedMin = llvm::APSInt::getMinValue(BitWidth,
Unsigned);
15059 PromotedMax = llvm::APSInt::getMaxValue(BitWidth,
Unsigned);
15061 PromotedMin = llvm::APSInt::getMinValue(R.Width, R.NonNegative)
15062 .extOrTrunc(BitWidth);
15063 PromotedMin.setIsUnsigned(
Unsigned);
15065 PromotedMax = llvm::APSInt::getMaxValue(R.Width, R.NonNegative)
15066 .extOrTrunc(BitWidth);
15067 PromotedMax.setIsUnsigned(
Unsigned);
15072 bool isContiguous()
const {
return PromotedMin <= PromotedMax; }
15082 InRangeFlag = 0x40,
15085 Min =
LE | InRangeFlag,
15087 Max =
GE | InRangeFlag,
15090 OnlyValue =
LE |
GE |
EQ | InRangeFlag,
15095 assert(
Value.getBitWidth() == PromotedMin.getBitWidth() &&
15096 Value.isUnsigned() == PromotedMin.isUnsigned());
15097 if (!isContiguous()) {
15098 assert(
Value.isUnsigned() &&
"discontiguous range for signed compare");
15099 if (
Value.isMinValue())
return Min;
15100 if (
Value.isMaxValue())
return Max;
15106 switch (llvm::APSInt::compareValues(
Value, PromotedMin)) {
15107 case -1:
return Less;
15108 case 0:
return PromotedMin == PromotedMax ? OnlyValue :
Min;
15110 switch (llvm::APSInt::compareValues(
Value, PromotedMax)) {
15112 case 0:
return Max;
15117 llvm_unreachable(
"impossible compare result");
15120 static std::optional<StringRef>
15122 if (Op == BO_Cmp) {
15124 if (ConstantOnRHS) std::swap(LTFlag, GTFlag);
15126 if (R & EQ)
return StringRef(
"'std::strong_ordering::equal'");
15127 if (R & LTFlag)
return StringRef(
"'std::strong_ordering::less'");
15128 if (R & GTFlag)
return StringRef(
"'std::strong_ordering::greater'");
15129 return std::nullopt;
15136 }
else if (Op == BO_NE) {
15140 if ((Op == BO_LT || Op == BO_GE) ^ ConstantOnRHS) {
15147 if (Op == BO_GE || Op == BO_LE)
15148 std::swap(TrueFlag, FalseFlag);
15151 return StringRef(
"true");
15153 return StringRef(
"false");
15154 return std::nullopt;
15162 if (ICE->getCastKind() != CK_IntegralCast &&
15163 ICE->getCastKind() != CK_NoOp)
15165 E = ICE->getSubExpr();
15174 enum ConstantValueKind {
15179 if (
auto *BL = dyn_cast<CXXBoolLiteralExpr>(Constant))
15180 return BL->getValue() ? ConstantValueKind::LiteralTrue
15181 : ConstantValueKind::LiteralFalse;
15182 return ConstantValueKind::Miscellaneous;
15187 const llvm::APSInt &
Value,
15188 bool RhsConstant) {
15213 OtherT = AT->getValueType();
15214 IntRange OtherTypeRange = IntRange::forValueOfType(S.
Context, OtherT);
15218 bool IsObjCSignedCharBool = S.
getLangOpts().ObjC &&
15219 S.
NSAPIObj->isObjCBOOLType(OtherT) &&
15224 bool OtherIsBooleanDespiteType =
15226 if (OtherIsBooleanDespiteType || IsObjCSignedCharBool)
15227 OtherTypeRange = OtherValueRange = IntRange::forBoolType();
15231 PromotedRange OtherPromotedValueRange(OtherValueRange,
Value.getBitWidth(),
15232 Value.isUnsigned());
15233 auto Cmp = OtherPromotedValueRange.compare(
Value);
15234 auto Result = PromotedRange::constantValue(E->
getOpcode(), Cmp, RhsConstant);
15240 bool TautologicalTypeCompare =
false;
15242 PromotedRange OtherPromotedTypeRange(OtherTypeRange,
Value.getBitWidth(),
15243 Value.isUnsigned());
15244 auto TypeCmp = OtherPromotedTypeRange.compare(
Value);
15247 TautologicalTypeCompare =
true;
15255 if (!TautologicalTypeCompare && OtherValueRange.Width == 0)
15264 bool InRange = Cmp & PromotedRange::InRangeFlag;
15270 if (
Other->refersToBitField() && InRange &&
Value == 0 &&
15271 Other->getType()->isUnsignedIntegerOrEnumerationType())
15272 TautologicalTypeCompare =
true;
15277 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
15278 ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
15282 llvm::raw_svector_ostream OS(PrettySourceValue);
15284 OS <<
'\'' << *ED <<
"' (" <<
Value <<
")";
15285 }
else if (
auto *BL = dyn_cast<ObjCBoolLiteralExpr>(
15287 OS << (BL->getValue() ?
"YES" :
"NO");
15292 if (!TautologicalTypeCompare) {
15294 << RhsConstant << OtherValueRange.Width << OtherValueRange.NonNegative
15300 if (IsObjCSignedCharBool) {
15302 S.
PDiag(diag::warn_tautological_compare_objc_bool)
15303 << OS.str() << *
Result);
15310 if (!InRange ||
Other->isKnownToHaveBooleanValue()) {
15314 S.
PDiag(!InRange ? diag::warn_out_of_range_compare
15315 : diag::warn_tautological_bool_compare)
15317 << OtherIsBooleanDespiteType << *
Result
15324 ? diag::warn_unsigned_enum_always_true_comparison
15325 : IsCharTy ? diag::warn_unsigned_char_always_true_comparison
15326 : diag::warn_unsigned_always_true_comparison)
15327 : diag::warn_tautological_constant_compare;
15364 std::optional<llvm::APSInt> RHSValue =
15366 std::optional<llvm::APSInt> LHSValue =
15370 if (RHSValue && LHSValue)
15374 if ((
bool)RHSValue ^ (
bool)LHSValue) {
15376 const bool RhsConstant = (
bool)RHSValue;
15377 Expr *Const = RhsConstant ? RHS : LHS;
15379 const llvm::APSInt &
Value = RhsConstant ? *RHSValue : *LHSValue;
15402 if (
const auto *TET = dyn_cast<TypeOfExprType>(LHS->
getType()))
15404 if (
const auto *TET = dyn_cast<TypeOfExprType>(RHS->
getType()))
15410 Expr *signedOperand, *unsignedOperand;
15413 "unsigned comparison between two signed integer expressions?");
15414 signedOperand = LHS;
15415 unsignedOperand = RHS;
15417 signedOperand = RHS;
15418 unsignedOperand = LHS;
15424 IntRange signedRange =
15434 if (signedRange.NonNegative)
15443 IntRange unsignedRange =
15449 assert(unsignedRange.NonNegative &&
"unsigned range includes negative?");
15451 if (unsignedRange.Width < comparisonWidth)
15456 S.
PDiag(diag::warn_mixed_sign_comparison)
15484 S.
Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield)
15485 << BitfieldEnumDecl;
15492 Init->isValueDependent() ||
15493 Init->isTypeDependent())
15496 Expr *OriginalInit =
Init->IgnoreParenImpCasts();
15519 unsigned DiagID = 0;
15520 if (SignedEnum && !SignedBitfield) {
15521 DiagID = diag::warn_unsigned_bitfield_assigned_signed_enum;
15522 }
else if (SignedBitfield && !SignedEnum &&
15524 DiagID = diag::warn_signed_bitfield_enum_conversion;
15528 S.
Diag(InitLoc, DiagID) << Bitfield << ED;
15533 << SignedEnum << TypeRange;
15544 if (BitsNeeded > FieldWidth) {
15546 S.
Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
15558 unsigned OriginalWidth =
Value.getBitWidth();
15564 bool OneAssignedToOneBitBitfield = FieldWidth == 1 &&
Value == 1;
15565 if (OneAssignedToOneBitBitfield && !S.
LangOpts.CPlusPlus) {
15572 if (!
Value.isSigned() ||
Value.isNegative())
15573 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(OriginalInit))
15574 if (UO->getOpcode() == UO_Minus || UO->getOpcode() == UO_Not)
15575 OriginalWidth =
Value.getSignificantBits();
15577 if (OriginalWidth <= FieldWidth)
15581 llvm::APSInt TruncatedValue =
Value.trunc(FieldWidth);
15585 TruncatedValue = TruncatedValue.extend(OriginalWidth);
15586 if (llvm::APSInt::isSameValue(
Value, TruncatedValue))
15590 std::string PrettyTrunc =
toString(TruncatedValue, 10);
15592 S.
Diag(InitLoc, OneAssignedToOneBitBitfield
15593 ? diag::warn_impcast_single_bit_bitield_precision_constant
15594 : diag::warn_impcast_bitfield_precision_constant)
15595 << PrettyValue << PrettyTrunc << OriginalInit->
getType()
15596 <<
Init->getSourceRange();
15628 bool pruneControlFlow =
false) {
15629 if (pruneControlFlow) {
15643 unsigned diag,
bool pruneControlFlow =
false) {
15655 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
15656 Ignored = OVE->getSourceExpr();
15657 bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
15658 isa<BinaryOperator>(Ignored) ||
15659 isa<CXXOperatorCallExpr>(Ignored);
15676 if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
15679 const bool IsLiteral =
15680 isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
15682 llvm::APFloat
Value(0.0);
15689 S.
Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
15694 diag::warn_impcast_float_integer, PruneWarnings);
15697 bool isExact =
false;
15701 llvm::APFloat::opStatus
Result =
Value.convertToInteger(
15702 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
15710 unsigned precision = llvm::APFloat::semanticsPrecision(
Value.getSemantics());
15711 precision = (precision * 59 + 195) / 196;
15712 Value.toString(PrettySourceValue, precision);
15717 S.
Diag(CContext, diag::warn_impcast_constant_value_to_objc_bool)
15718 << PrettySourceValue);
15721 if (
Result == llvm::APFloat::opOK && isExact) {
15722 if (IsLiteral)
return;
15723 return DiagnoseImpCast(S, E,
T, CContext, diag::warn_impcast_float_integer,
15729 if (!IsBool &&
Result == llvm::APFloat::opInvalidOp)
15732 IsLiteral ? diag::warn_impcast_literal_float_to_integer_out_of_range
15733 : diag::warn_impcast_float_to_integer_out_of_range,
15736 unsigned DiagID = 0;
15739 DiagID = diag::warn_impcast_literal_float_to_integer;
15740 }
else if (IntegerValue == 0) {
15741 if (
Value.isZero()) {
15743 diag::warn_impcast_float_integer, PruneWarnings);
15746 DiagID = diag::warn_impcast_float_to_integer_zero;
15748 if (IntegerValue.isUnsigned()) {
15749 if (!IntegerValue.isMaxValue()) {
15751 diag::warn_impcast_float_integer, PruneWarnings);
15754 if (!IntegerValue.isMaxSignedValue() &&
15755 !IntegerValue.isMinSignedValue()) {
15757 diag::warn_impcast_float_integer, PruneWarnings);
15761 DiagID = diag::warn_impcast_float_to_integer;
15766 PrettyTargetValue =
Value.isZero() ?
"false" :
"true";
15768 IntegerValue.toString(PrettyTargetValue);
15770 if (PruneWarnings) {
15773 << E->
getType() <<
T.getUnqualifiedType()
15774 << PrettySourceValue << PrettyTargetValue
15778 << E->
getType() <<
T.getUnqualifiedType() << PrettySourceValue
15786 assert(isa<CompoundAssignOperator>(E) &&
15787 "Must be compound assignment operation");
15797 const auto *RBT = cast<CompoundAssignOperator>(E)
15798 ->getComputationResultType()
15805 if (ResultBT->isInteger())
15807 E->
getExprLoc(), diag::warn_impcast_float_integer);
15809 if (!ResultBT->isFloatingPoint())
15818 diag::warn_impcast_float_result_precision);
15823 if (!Range.Width)
return "0";
15825 llvm::APSInt ValueInRange =
Value;
15826 ValueInRange.setIsSigned(!Range.NonNegative);
15827 ValueInRange = ValueInRange.trunc(Range.Width);
15828 return toString(ValueInRange, 10);
15832 if (!isa<ImplicitCastExpr>(Ex))
15837 const Type *Source =
15839 if (
Target->isDependentType())
15843 dyn_cast<BuiltinType>(ToBool ? Source :
Target);
15844 const Type *BoolCandidateType = ToBool ?
Target : Source;
15853 for (
unsigned i = 0; i < NumArgs; ++i) {
15858 bool IsSwapped = ((i > 0) &&
15860 IsSwapped |= ((i < (NumArgs - 1)) &&
15866 diag::warn_impcast_floating_point_to_bool);
15873 if (S.
Diags.
isIgnored(diag::warn_impcast_null_pointer_to_integer,
15878 if (isa<CallExpr>(E))
15883 bool IsGNUNullExpr = isa<GNUNullExpr>(NewE);
15885 if (!IsGNUNullExpr && !HasNullPtrType)
15902 if (IsGNUNullExpr && Loc.
isMacroID()) {
15905 if (MacroName ==
"NULL")
15913 S.
Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
15931 unsigned ElementKind) {
15933 if (
auto ICE = dyn_cast<ImplicitCastExpr>(Element)) {
15934 if (ICE->getCastKind() == CK_BitCast &&
15936 Element = ICE->getSubExpr();
15939 QualType ElementType = Element->getType();
15946 S.
Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element)
15947 << ElementType << ElementKind << TargetElementType
15948 << Element->getSourceRange();
15951 if (
auto ArrayLiteral = dyn_cast<ObjCArrayLiteral>(Element))
15953 else if (
auto DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(Element))
15965 if (!TargetObjCPtr)
15968 if (TargetObjCPtr->isUnspecialized() ||
15969 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
15974 if (TypeArgs.size() != 1)
15977 QualType TargetElementType = TypeArgs[0];
15978 for (
unsigned I = 0, N = ArrayLiteral->
getNumElements(); I != N; ++I) {
15994 if (!TargetObjCPtr)
15997 if (TargetObjCPtr->isUnspecialized() ||
15998 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
16003 if (TypeArgs.size() != 2)
16006 QualType TargetKeyType = TypeArgs[0];
16007 QualType TargetObjectType = TypeArgs[1];
16008 for (
unsigned I = 0, N = DictionaryLiteral->
getNumElements(); I != N; ++I) {
16023 const char FirstLiteralCharacter =
16025 if (FirstLiteralCharacter ==
'0')
16032 const char FirstContextCharacter =
16034 if (FirstContextCharacter ==
'{')
16042 const auto *IL = dyn_cast<IntegerLiteral>(E);
16044 if (
auto *UO = dyn_cast<UnaryOperator>(E)) {
16045 if (UO->getOpcode() == UO_Minus)
16046 return dyn_cast<IntegerLiteral>(UO->getSubExpr());
16057 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
16061 if (Opc == BO_Shl) {
16064 if (LHS && LHS->getValue() == 0)
16065 S.
Diag(ExprLoc, diag::warn_left_shift_always) << 0;
16067 RHS->getValue().isNonNegative() &&
16069 S.
Diag(ExprLoc, diag::warn_left_shift_always)
16070 << (
Result.Val.getInt() != 0);
16072 S.
Diag(ExprLoc, diag::warn_left_shift_in_bool_context) << E;
16076 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
16081 if ((LHS->getValue() == 0 || LHS->getValue() == 1) &&
16082 (RHS->getValue() == 0 || RHS->getValue() == 1))
16085 if (LHS->getValue() != 0 && RHS->getValue() != 0)
16086 S.
Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
16092 bool *ICContext =
nullptr,
16093 bool IsListInit =
false) {
16098 if (Source ==
Target)
return;
16099 if (
Target->isDependentType())
return;
16113 if (
Target->isSpecificBuiltinType(BuiltinType::Bool)) {
16114 if (isa<StringLiteral>(E))
16119 diag::warn_impcast_string_literal_to_bool);
16120 if (isa<ObjCStringLiteral>(E) || isa<ObjCArrayLiteral>(E) ||
16121 isa<ObjCDictionaryLiteral>(E) || isa<ObjCBoxedExpr>(E)) {
16125 diag::warn_impcast_objective_c_literal_to_bool);
16141 if (
Result.Val.getInt() != 1 &&
Result.Val.getInt() != 0) {
16144 S.
Diag(CC, diag::warn_impcast_constant_value_to_objc_bool)
16153 if (
auto *ArrayLiteral = dyn_cast<ObjCArrayLiteral>(E))
16155 else if (
auto *DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(E))
16159 if (isa<VectorType>(Source)) {
16160 if (
Target->isSveVLSBuiltinType() &&
16167 if (
Target->isRVVVLSBuiltinType() &&
16174 if (!isa<VectorType>(
Target)) {
16192 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
16193 Target = cast<VectorType>(
Target)->getElementType().getTypePtr();
16195 if (
auto VecTy = dyn_cast<VectorType>(
Target))
16196 Target = VecTy->getElementType().getTypePtr();
16199 if (isa<ComplexType>(Source)) {
16200 if (!isa<ComplexType>(
Target)) {
16206 ? diag::err_impcast_complex_scalar
16207 : diag::warn_impcast_complex_scalar);
16210 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
16211 Target = cast<ComplexType>(
Target)->getElementType().getTypePtr();
16214 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
16266 else if (Order < 0) {
16276 if (TargetBT && TargetBT->
isInteger()) {
16291 if (
Target->isBooleanType() && isa<CallExpr>(E)) {
16295 CallExpr *CEx = cast<CallExpr>(E);
16299 if (isa<ImplicitCastExpr>(LastA) &&
16303 diag::warn_impcast_floating_point_to_bool);
16312 if (
Target->isUnsaturatedFixedPointType()) {
16316 llvm::APFixedPoint
Value =
Result.Val.getFixedPoint();
16321 S.
PDiag(diag::warn_impcast_fixed_point_range)
16322 <<
Value.toString() <<
T
16328 }
else if (
Target->isIntegerType()) {
16333 llvm::APFixedPoint FXResult =
Result.Val.getFixedPoint();
16336 llvm::APSInt IntResult = FXResult.convertToInt(
16338 Target->isSignedIntegerOrEnumerationType(), &Overflowed);
16342 S.
PDiag(diag::warn_impcast_fixed_point_range)
16343 << FXResult.toString() <<
T
16350 }
else if (
Target->isUnsaturatedFixedPointType()) {
16358 llvm::APFixedPoint IntResult = llvm::APFixedPoint::getFromIntValue(
16363 S.
PDiag(diag::warn_impcast_fixed_point_range)
16382 unsigned int SourcePrecision =
SourceRange.Width;
16386 unsigned int TargetPrecision = llvm::APFloatBase::semanticsPrecision(
16389 if (SourcePrecision > 0 && TargetPrecision > 0 &&
16390 SourcePrecision > TargetPrecision) {
16392 if (std::optional<llvm::APSInt> SourceInt =
16397 llvm::APFloat TargetFloatValue(
16399 llvm::APFloat::opStatus ConversionStatus =
16400 TargetFloatValue.convertFromAPInt(
16402 llvm::APFloat::rmNearestTiesToEven);
16404 if (ConversionStatus != llvm::APFloat::opOK) {
16406 SourceInt->toString(PrettySourceValue, 10);
16408 TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
16412 S.
PDiag(diag::warn_impcast_integer_float_precision_constant)
16413 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16419 diag::warn_impcast_integer_float_precision);
16428 if (
Target->isBooleanType())
16436 if (
Target->isSpecificBuiltinType(BuiltinType::Bool))
16443 S.
Diag(CC, diag::warn_impcast_int_to_objc_signed_char_bool)
16447 IntRange SourceTypeRange =
16448 IntRange::forTargetOfCanonicalType(S.
Context, Source);
16451 IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.
Context,
Target);
16453 if (LikelySourceRange.Width > TargetRange.Width) {
16459 llvm::APSInt
Value(32);
16470 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16471 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16483 return DiagnoseImpCast(S, E,
T, CC, diag::warn_impcast_integer_precision);
16486 if (TargetRange.Width > SourceTypeRange.Width) {
16487 if (
auto *UO = dyn_cast<UnaryOperator>(E))
16488 if (UO->getOpcode() == UO_Minus)
16490 if (
Target->isUnsignedIntegerType())
16492 diag::warn_impcast_high_order_zero_bits);
16493 if (
Target->isSignedIntegerType())
16495 diag::warn_impcast_nonnegative_result);
16499 if (TargetRange.Width == LikelySourceRange.Width &&
16500 !TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16516 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16517 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16526 if ((!isa<EnumType>(
Target) || !isa<EnumType>(Source)) &&
16527 ((TargetRange.NonNegative && !LikelySourceRange.NonNegative) ||
16528 (!TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16529 LikelySourceRange.Width == TargetRange.Width))) {
16533 if (SourceBT && SourceBT->
isInteger() && TargetBT &&
16539 unsigned DiagID = diag::warn_impcast_integer_sign;
16547 DiagID = diag::warn_impcast_integer_sign_conditional;
16562 if (SourceEnum->getDecl()->hasNameForLinkage() &&
16563 TargetEnum->getDecl()->hasNameForLinkage() &&
16564 SourceEnum != TargetEnum) {
16569 diag::warn_impcast_different_enum_types);
16583 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(E))
16596 if (
auto *BCO = dyn_cast<BinaryConditionalOperator>(E))
16597 TrueExpr = BCO->getCommon();
16599 bool Suspicious =
false;
16608 if (!Suspicious)
return;
16611 if (!S.
Diags.
isIgnored(diag::warn_impcast_integer_sign_conditional, CC))
16618 Suspicious =
false;
16620 E->
getType(), CC, &Suspicious);
16623 E->
getType(), CC, &Suspicious);
16640struct AnalyzeImplicitConversionsWorkItem {
16650 Sema &S, AnalyzeImplicitConversionsWorkItem Item,
16652 Expr *OrigE = Item.E;
16661 bool IsListInit = Item.IsListInit ||
16662 (isa<InitListExpr>(OrigE) && S.
getLangOpts().CPlusPlus);
16667 Expr *SourceExpr = E;
16672 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(E))
16673 if (
auto *Src = OVE->getSourceExpr())
16676 if (
const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
16677 if (UO->getOpcode() == UO_Not &&
16678 UO->getSubExpr()->isKnownToHaveBooleanValue())
16679 S.
Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
16683 if (
const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
16684 if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
16685 BO->getLHS()->isKnownToHaveBooleanValue() &&
16686 BO->getRHS()->isKnownToHaveBooleanValue() &&
16687 BO->getLHS()->HasSideEffects(S.
Context) &&
16688 BO->getRHS()->HasSideEffects(S.
Context)) {
16699 if (SR.str() ==
"&" || SR.str() ==
"|") {
16701 S.
Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical)
16702 << (BO->getOpcode() == BO_And ?
"&" :
"|")
16705 BO->getOperatorLoc(),
16706 (BO->getOpcode() == BO_And ?
"&&" :
"||"));
16707 S.
Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
16713 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(SourceExpr)) {
16734 for (
auto *SE : POE->semantics())
16735 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(SE))
16736 WorkList.push_back({OVE->getSourceExpr(), CC, IsListInit});
16740 if (
auto *CE = dyn_cast<ExplicitCastExpr>(E)) {
16744 WorkList.push_back({E, CC, IsListInit});
16750 if (BO->isComparisonOp())
16754 if (BO->getOpcode() == BO_Assign)
16757 if (BO->isAssignmentOp())
16765 if (isa<StmtExpr>(E))
return;
16768 if (isa<UnaryExprOrTypeTraitExpr>(E))
return;
16773 bool IsLogicalAndOperator = BO && BO->
getOpcode() == BO_LAnd;
16775 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
16779 if (
auto *CSE = dyn_cast<CoroutineSuspendExpr>(E))
16780 if (ChildExpr == CSE->getOperand())
16786 if (IsLogicalAndOperator &&
16791 WorkList.push_back({ChildExpr, CC, IsListInit});
16796 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16800 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16805 if (
U->getOpcode() == UO_LNot) {
16807 }
else if (
U->getOpcode() != UO_AddrOf) {
16808 if (
U->getSubExpr()->getType()->isAtomicType())
16809 S.
Diag(
U->getSubExpr()->getBeginLoc(),
16810 diag::warn_atomic_implicit_seq_cst);
16821 WorkList.push_back({OrigE, CC, IsListInit});
16822 while (!WorkList.empty())
16832 diag::err_opencl_enqueue_kernel_invalid_local_size_type);
16849 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
16852 }
else if (
const MemberExpr *M = dyn_cast<MemberExpr>(E)) {
16853 if (!M->getMemberDecl()->getType()->isReferenceType())
16855 }
else if (
const CallExpr *
Call = dyn_cast<CallExpr>(E)) {
16856 if (!
Call->getCallReturnType(SemaRef.
Context)->isReferenceType())
16858 FD =
Call->getDirectCallee();
16867 SemaRef.
Diag(FD->
getLocation(), diag::note_reference_is_return_value) << FD;
16881 if (
SM.isMacroBodyExpansion(Loc))
16883 Loc =
SM.getImmediateMacroCallerLoc(Loc);
16912 if (isa<CXXThisExpr>(E)) {
16913 unsigned DiagID = IsCompare ? diag::warn_this_null_compare
16914 : diag::warn_this_bool_conversion;
16919 bool IsAddressOf =
false;
16921 if (
auto *UO = dyn_cast<UnaryOperator>(E->
IgnoreParens())) {
16922 if (UO->getOpcode() != UO_AddrOf)
16924 IsAddressOf =
true;
16925 E = UO->getSubExpr();
16929 unsigned DiagID = IsCompare
16930 ? diag::warn_address_of_reference_null_compare
16931 : diag::warn_address_of_reference_bool_conversion;
16939 auto ComplainAboutNonnullParamOrCall = [&](
const Attr *NonnullAttr) {
16940 bool IsParam = isa<NonNullAttr>(NonnullAttr);
16942 llvm::raw_string_ostream S(Str);
16944 unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare
16945 : diag::warn_cast_nonnull_to_bool;
16948 Diag(NonnullAttr->getLocation(), diag::note_declared_nonnull) << IsParam;
16953 if (
auto *Callee =
Call->getDirectCallee()) {
16954 if (
const Attr *A = Callee->getAttr<ReturnsNonNullAttr>()) {
16955 ComplainAboutNonnullParamOrCall(A);
16964 if (
const auto *MCallExpr = dyn_cast<CXXMemberCallExpr>(E)) {
16965 if (
const auto *MRecordDecl = MCallExpr->getRecordDecl();
16966 MRecordDecl && MRecordDecl->isLambda()) {
16969 << MRecordDecl->getSourceRange() << Range << IsEqual;
16979 }
else if (
MemberExpr *M = dyn_cast<MemberExpr>(E)) {
16980 D = M->getMemberDecl();
16988 if (
const auto* PV = dyn_cast<ParmVarDecl>(D)) {
16991 if (
const Attr *A = PV->getAttr<NonNullAttr>()) {
16992 ComplainAboutNonnullParamOrCall(A);
16996 if (
const auto *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
17000 auto ParamIter = llvm::find(FD->
parameters(), PV);
17002 unsigned ParamNo = std::distance(FD->
param_begin(), ParamIter);
17006 ComplainAboutNonnullParamOrCall(
NonNull);
17011 if (ArgNo.getASTIndex() == ParamNo) {
17012 ComplainAboutNonnullParamOrCall(
NonNull);
17026 if (IsAddressOf && IsFunction) {
17031 if (!IsAddressOf && !IsFunction && !IsArray)
17036 llvm::raw_string_ostream S(Str);
17039 unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare
17040 : diag::warn_impcast_pointer_to_bool;
17047 DiagType = AddressOf;
17048 else if (IsFunction)
17049 DiagType = FunctionPointer;
17051 DiagType = ArrayPointer;
17053 llvm_unreachable(
"Could not determine diagnostic.");
17055 << Range << IsEqual;
17068 if (ReturnType.
isNull())
17113 CheckArrayAccess(E);
17122 ::CheckBoolLikeConversion(*
this, E, CC);
17127void Sema::CheckForIntOverflow (
const Expr *E) {
17132 const Expr *OriginalE = Exprs.pop_back_val();
17135 if (isa<BinaryOperator, UnaryOperator>(E)) {
17140 if (
const auto *InitList = dyn_cast<InitListExpr>(OriginalE))
17141 Exprs.append(InitList->inits().begin(), InitList->inits().end());
17142 else if (isa<ObjCBoxedExpr>(OriginalE))
17144 else if (
const auto *
Call = dyn_cast<CallExpr>(E))
17145 Exprs.append(
Call->arg_begin(),
Call->arg_end());
17146 else if (
const auto *Message = dyn_cast<ObjCMessageExpr>(E))
17147 Exprs.append(Message->arg_begin(), Message->arg_end());
17148 else if (
const auto *Construct = dyn_cast<CXXConstructExpr>(E))
17149 Exprs.append(Construct->arg_begin(), Construct->arg_end());
17150 else if (
const auto *Temporary = dyn_cast<CXXBindTemporaryExpr>(E))
17151 Exprs.push_back(Temporary->getSubExpr());
17152 else if (
const auto *Array = dyn_cast<ArraySubscriptExpr>(E))
17153 Exprs.push_back(Array->getIdx());
17154 else if (
const auto *Compound = dyn_cast<CompoundLiteralExpr>(E))
17155 Exprs.push_back(Compound->getInitializer());
17156 else if (
const auto *New = dyn_cast<CXXNewExpr>(E);
17157 New && New->isArray()) {
17158 if (
auto ArraySize = New->getArraySize())
17159 Exprs.push_back(*ArraySize);
17161 }
while (!Exprs.empty());
17176 class SequenceTree {
17180 LLVM_PREFERRED_TYPE(
bool)
17181 unsigned Merged : 1;
17189 friend class SequenceTree;
17193 explicit Seq(
unsigned N) : Index(N) {}
17196 Seq() : Index(0) {}
17199 SequenceTree() { Values.push_back(
Value(0)); }
17200 Seq root()
const {
return Seq(0); }
17207 return Seq(Values.size() - 1);
17211 void merge(
Seq S) {
17212 Values[S.Index].Merged =
true;
17218 bool isUnsequenced(
Seq Cur,
Seq Old) {
17219 unsigned C = representative(Cur.Index);
17220 unsigned Target = representative(Old.Index);
17224 C = Values[
C].Parent;
17231 unsigned representative(
unsigned K) {
17232 if (Values[K].Merged)
17234 return Values[K].Parent = representative(Values[K].
Parent);
17254 UK_ModAsSideEffect,
17256 UK_Count = UK_ModAsSideEffect + 1
17262 const Expr *UsageExpr =
nullptr;
17263 SequenceTree::Seq
Seq;
17269 Usage Uses[UK_Count];
17272 bool Diagnosed =
false;
17276 using UsageInfoMap = llvm::SmallDenseMap<Object, UsageInfo, 16>;
17284 UsageInfoMap UsageMap;
17287 SequenceTree::Seq Region;
17302 struct SequencedSubexpression {
17303 SequencedSubexpression(SequenceChecker &Self)
17304 : Self(Self), OldModAsSideEffect(Self.ModAsSideEffect) {
17305 Self.ModAsSideEffect = &ModAsSideEffect;
17308 ~SequencedSubexpression() {
17309 for (
const std::pair<Object, Usage> &M : llvm::reverse(ModAsSideEffect)) {
17313 UsageInfo &UI = Self.UsageMap[M.first];
17314 auto &SideEffectUsage = UI.Uses[UK_ModAsSideEffect];
17315 Self.addUsage(M.first, UI, SideEffectUsage.UsageExpr, UK_ModAsValue);
17316 SideEffectUsage = M.second;
17318 Self.ModAsSideEffect = OldModAsSideEffect;
17321 SequenceChecker &Self;
17330 class EvaluationTracker {
17332 EvaluationTracker(SequenceChecker &Self)
17333 : Self(Self), Prev(Self.EvalTracker) {
17334 Self.EvalTracker =
this;
17337 ~EvaluationTracker() {
17338 Self.EvalTracker = Prev;
17340 Prev->EvalOK &= EvalOK;
17343 bool evaluate(
const Expr *E,
bool &Result) {
17347 Result, Self.SemaRef.Context,
17348 Self.SemaRef.isConstantEvaluatedContext());
17353 SequenceChecker &Self;
17354 EvaluationTracker *Prev;
17355 bool EvalOK =
true;
17356 } *EvalTracker =
nullptr;
17360 Object getObject(
const Expr *E,
bool Mod)
const {
17362 if (
const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
17363 if (Mod && (UO->getOpcode() == UO_PreInc || UO->getOpcode() == UO_PreDec))
17364 return getObject(UO->getSubExpr(), Mod);
17365 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
17366 if (BO->getOpcode() == BO_Comma)
17367 return getObject(BO->getRHS(), Mod);
17368 if (Mod && BO->isAssignmentOp())
17369 return getObject(BO->getLHS(), Mod);
17370 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
17372 if (isa<CXXThisExpr>(ME->getBase()->IgnoreParenCasts()))
17373 return ME->getMemberDecl();
17374 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
17383 void addUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr, UsageKind UK) {
17385 Usage &
U = UI.Uses[UK];
17386 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq)) {
17390 if (UK == UK_ModAsSideEffect && ModAsSideEffect)
17391 ModAsSideEffect->push_back(std::make_pair(O,
U));
17393 U.UsageExpr = UsageExpr;
17403 void checkUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr,
17404 UsageKind OtherKind,
bool IsModMod) {
17408 const Usage &
U = UI.Uses[OtherKind];
17409 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq))
17412 const Expr *Mod =
U.UsageExpr;
17413 const Expr *ModOrUse = UsageExpr;
17414 if (OtherKind == UK_Use)
17415 std::swap(Mod, ModOrUse);
17419 SemaRef.
PDiag(IsModMod ? diag::warn_unsequenced_mod_mod
17420 : diag::warn_unsequenced_mod_use)
17422 UI.Diagnosed =
true;
17451 void notePreUse(Object O,
const Expr *UseExpr) {
17452 UsageInfo &UI = UsageMap[O];
17454 checkUsage(O, UI, UseExpr, UK_ModAsValue,
false);
17457 void notePostUse(Object O,
const Expr *UseExpr) {
17458 UsageInfo &UI = UsageMap[O];
17459 checkUsage(O, UI, UseExpr, UK_ModAsSideEffect,
17461 addUsage(O, UI, UseExpr, UK_Use);
17464 void notePreMod(Object O,
const Expr *ModExpr) {
17465 UsageInfo &UI = UsageMap[O];
17467 checkUsage(O, UI, ModExpr, UK_ModAsValue,
true);
17468 checkUsage(O, UI, ModExpr, UK_Use,
false);
17471 void notePostMod(Object O,
const Expr *ModExpr, UsageKind UK) {
17472 UsageInfo &UI = UsageMap[O];
17473 checkUsage(O, UI, ModExpr, UK_ModAsSideEffect,
17475 addUsage(O, UI, ModExpr, UK);
17479 SequenceChecker(
Sema &S,
const Expr *E,
17481 :
Base(S.Context), SemaRef(S), Region(
Tree.root()), WorkList(WorkList) {
17485 (void)this->WorkList;
17488 void VisitStmt(
const Stmt *S) {
17492 void VisitExpr(
const Expr *E) {
17494 Base::VisitStmt(E);
17498 for (
auto *Sub : CSE->
children()) {
17499 const Expr *ChildExpr = dyn_cast_or_null<Expr>(Sub);
17514 void VisitCastExpr(
const CastExpr *E) {
17526 void VisitSequencedExpressions(
const Expr *SequencedBefore,
17527 const Expr *SequencedAfter) {
17528 SequenceTree::Seq BeforeRegion =
Tree.allocate(Region);
17529 SequenceTree::Seq AfterRegion =
Tree.allocate(Region);
17530 SequenceTree::Seq OldRegion = Region;
17533 SequencedSubexpression SeqBefore(*
this);
17534 Region = BeforeRegion;
17535 Visit(SequencedBefore);
17538 Region = AfterRegion;
17539 Visit(SequencedAfter);
17541 Region = OldRegion;
17543 Tree.merge(BeforeRegion);
17544 Tree.merge(AfterRegion);
17552 VisitSequencedExpressions(ASE->
getLHS(), ASE->
getRHS());
17559 void VisitBinPtrMemD(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17560 void VisitBinPtrMemI(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17566 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17573 void VisitBinShl(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17574 void VisitBinShr(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17579 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17591 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17595 SequenceTree::Seq RHSRegion;
17596 SequenceTree::Seq LHSRegion;
17598 RHSRegion =
Tree.allocate(Region);
17599 LHSRegion =
Tree.allocate(Region);
17601 RHSRegion = Region;
17602 LHSRegion = Region;
17604 SequenceTree::Seq OldRegion = Region;
17620 SequencedSubexpression SeqBefore(*
this);
17621 Region = RHSRegion;
17625 Region = LHSRegion;
17628 if (O && isa<CompoundAssignOperator>(BO))
17629 notePostUse(O, BO);
17633 Region = LHSRegion;
17636 if (O && isa<CompoundAssignOperator>(BO))
17637 notePostUse(O, BO);
17639 Region = RHSRegion;
17647 Region = OldRegion;
17651 : UK_ModAsSideEffect);
17653 Tree.merge(RHSRegion);
17654 Tree.merge(LHSRegion);
17659 VisitBinAssign(CAO);
17662 void VisitUnaryPreInc(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17663 void VisitUnaryPreDec(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17667 return VisitExpr(UO);
17675 : UK_ModAsSideEffect);
17678 void VisitUnaryPostInc(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17679 void VisitUnaryPostDec(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17683 return VisitExpr(UO);
17687 notePostMod(O, UO, UK_ModAsSideEffect);
17696 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17697 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17698 SequenceTree::Seq OldRegion = Region;
17700 EvaluationTracker Eval(*
this);
17702 SequencedSubexpression Sequenced(*
this);
17703 Region = LHSRegion;
17710 bool EvalResult =
false;
17711 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17712 bool ShouldVisitRHS = !EvalOK || !EvalResult;
17713 if (ShouldVisitRHS) {
17714 Region = RHSRegion;
17718 Region = OldRegion;
17719 Tree.merge(LHSRegion);
17720 Tree.merge(RHSRegion);
17729 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17730 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17731 SequenceTree::Seq OldRegion = Region;
17733 EvaluationTracker Eval(*
this);
17735 SequencedSubexpression Sequenced(*
this);
17736 Region = LHSRegion;
17742 bool EvalResult =
false;
17743 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17744 bool ShouldVisitRHS = !EvalOK || EvalResult;
17745 if (ShouldVisitRHS) {
17746 Region = RHSRegion;
17750 Region = OldRegion;
17751 Tree.merge(LHSRegion);
17752 Tree.merge(RHSRegion);
17760 SequenceTree::Seq ConditionRegion =
Tree.allocate(Region);
17776 SequenceTree::Seq TrueRegion =
Tree.allocate(Region);
17777 SequenceTree::Seq FalseRegion =
Tree.allocate(Region);
17778 SequenceTree::Seq OldRegion = Region;
17780 EvaluationTracker Eval(*
this);
17782 SequencedSubexpression Sequenced(*
this);
17783 Region = ConditionRegion;
17793 bool EvalResult =
false;
17794 bool EvalOK = Eval.evaluate(CO->
getCond(), EvalResult);
17795 bool ShouldVisitTrueExpr = !EvalOK || EvalResult;
17796 bool ShouldVisitFalseExpr = !EvalOK || !EvalResult;
17797 if (ShouldVisitTrueExpr) {
17798 Region = TrueRegion;
17801 if (ShouldVisitFalseExpr) {
17802 Region = FalseRegion;
17806 Region = OldRegion;
17807 Tree.merge(ConditionRegion);
17808 Tree.merge(TrueRegion);
17809 Tree.merge(FalseRegion);
17812 void VisitCallExpr(
const CallExpr *CE) {
17824 SequencedSubexpression Sequenced(*
this);
17829 SequenceTree::Seq CalleeRegion;
17830 SequenceTree::Seq OtherRegion;
17831 if (SemaRef.getLangOpts().CPlusPlus17) {
17832 CalleeRegion = Tree.allocate(Region);
17833 OtherRegion = Tree.allocate(Region);
17835 CalleeRegion = Region;
17836 OtherRegion = Region;
17838 SequenceTree::Seq OldRegion = Region;
17841 Region = CalleeRegion;
17843 SequencedSubexpression Sequenced(*this);
17844 Visit(CE->getCallee());
17846 Visit(CE->getCallee());
17850 Region = OtherRegion;
17854 Region = OldRegion;
17856 Tree.merge(CalleeRegion);
17857 Tree.merge(OtherRegion);
17875 return VisitCallExpr(CXXOCE);
17886 case OO_MinusEqual:
17888 case OO_SlashEqual:
17889 case OO_PercentEqual:
17890 case OO_CaretEqual:
17893 case OO_LessLessEqual:
17894 case OO_GreaterGreaterEqual:
17895 SequencingKind = RHSBeforeLHS;
17899 case OO_GreaterGreater:
17905 SequencingKind = LHSBeforeRHS;
17909 SequencingKind = LHSBeforeRest;
17913 SequencingKind = NoSequencing;
17917 if (SequencingKind == NoSequencing)
17918 return VisitCallExpr(CXXOCE);
17921 SequencedSubexpression Sequenced(*
this);
17924 assert(SemaRef.getLangOpts().CPlusPlus17 &&
17925 "Should only get there with C++17 and above!");
17926 assert((CXXOCE->getNumArgs() == 2 || CXXOCE->getOperator() == OO_Call) &&
17927 "Should only get there with an overloaded binary operator"
17928 " or an overloaded call operator!");
17930 if (SequencingKind == LHSBeforeRest) {
17931 assert(CXXOCE->getOperator() == OO_Call &&
17932 "We should only have an overloaded call operator here!");
17941 SequenceTree::Seq PostfixExprRegion = Tree.allocate(Region);
17942 SequenceTree::Seq ArgsRegion = Tree.allocate(Region);
17943 SequenceTree::Seq OldRegion = Region;
17945 assert(CXXOCE->getNumArgs() >= 1 &&
17946 "An overloaded call operator must have at least one argument"
17947 " for the postfix-expression!");
17948 const Expr *PostfixExpr = CXXOCE->getArgs()[0];
17949 llvm::ArrayRef<const Expr *> Args(CXXOCE->getArgs() + 1,
17950 CXXOCE->getNumArgs() - 1);
17954 Region = PostfixExprRegion;
17955 SequencedSubexpression Sequenced(*this);
17956 Visit(PostfixExpr);
17960 Region = ArgsRegion;
17961 for (const Expr *Arg : Args)
17964 Region = OldRegion;
17965 Tree.merge(PostfixExprRegion);
17966 Tree.merge(ArgsRegion);
17968 assert(CXXOCE->getNumArgs() == 2 &&
17969 "Should only have two arguments here!");
17970 assert((SequencingKind == LHSBeforeRHS ||
17971 SequencingKind == RHSBeforeLHS) &&
17972 "Unexpected sequencing kind!");
17976 const Expr *E1 = CXXOCE->getArg(0);
17977 const Expr *E2 = CXXOCE->getArg(1);
17978 if (SequencingKind == RHSBeforeLHS)
17981 return VisitSequencedExpressions(E1, E2);
17988 SequencedSubexpression Sequenced(*
this);
17991 return VisitExpr(CCE);
17994 SequenceExpressionsInOrder(
18000 return VisitExpr(ILE);
18003 SequenceExpressionsInOrder(ILE->
inits());
18015 SequenceTree::Seq
Parent = Region;
18016 for (
const Expr *E : ExpressionList) {
18020 Elts.push_back(Region);
18026 for (
unsigned I = 0; I < Elts.size(); ++I)
18027 Tree.merge(Elts[I]);
18031SequenceChecker::UsageInfo::UsageInfo() =
default;
18035void Sema::CheckUnsequencedOperations(
const Expr *E) {
18037 WorkList.push_back(E);
18038 while (!WorkList.empty()) {
18039 const Expr *Item = WorkList.pop_back_val();
18040 SequenceChecker(*
this, Item, WorkList);
18045 bool IsConstexpr) {
18047 IsConstexpr || isa<ConstantExpr>(E));
18048 CheckImplicitConversions(E, CheckLoc);
18050 CheckUnsequencedOperations(E);
18052 CheckForIntOverflow(E);
18066 if (
const auto *PointerTy = dyn_cast<PointerType>(PType)) {
18070 if (
const auto *ReferenceTy = dyn_cast<ReferenceType>(PType)) {
18074 if (
const auto *ParenTy = dyn_cast<ParenType>(PType)) {
18088 S.
Diag(Loc, diag::err_array_star_in_function_definition);
18097 bool CheckParameterNames) {
18098 bool HasInvalidParm =
false;
18100 assert(Param &&
"null in a parameter list");
18109 if (!Param->isInvalidDecl() &&
18111 diag::err_typecheck_decl_incomplete_type) ||
18113 diag::err_abstract_type_in_decl,
18115 Param->setInvalidDecl();
18116 HasInvalidParm =
true;
18121 if (CheckParameterNames && Param->getIdentifier() ==
nullptr &&
18125 Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c23);
18133 QualType PType = Param->getOriginalType();
18141 if (!Param->isInvalidDecl()) {
18143 if (!ClassDecl->isInvalidDecl() &&
18144 !ClassDecl->hasIrrelevantDestructor() &&
18145 !ClassDecl->isDependentContext() &&
18146 ClassDecl->isParamDestroyedInCallee()) {
18158 if (
const auto *
Attr = Param->getAttr<PassObjectSizeAttr>())
18159 if (!Param->getType().isConstQualified())
18160 Diag(Param->getLocation(), diag::err_attribute_pointers_only)
18164 if (
LangOpts.CPlusPlus && !Param->isInvalidDecl()) {
18169 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC->
getParent()))
18170 CheckShadowInheritedFields(Param->getLocation(), Param->getDeclName(),
18175 if (!Param->isInvalidDecl() &&
18177 Param->setInvalidDecl();
18178 HasInvalidParm =
true;
18179 Diag(Param->getLocation(), diag::err_wasm_table_as_function_parameter);
18183 return HasInvalidParm;
18186std::optional<std::pair<
18195static std::pair<CharUnits, CharUnits>
18203 if (
Base->isVirtual()) {
18210 BaseAlignment = std::min(BaseAlignment, NonVirtualAlignment);
18217 DerivedType =
Base->getType();
18220 return std::make_pair(BaseAlignment, Offset);
18224static std::optional<std::pair<CharUnits, CharUnits>>
18230 return std::nullopt;
18235 return std::nullopt;
18239 CharUnits Offset = EltSize * IdxRes->getExtValue();
18242 return std::make_pair(
P->first,
P->second + Offset);
18248 return std::make_pair(
18249 P->first.alignmentAtOffset(
P->second).alignmentAtOffset(EltSize),
18255std::optional<std::pair<
18263 case Stmt::CStyleCastExprClass:
18264 case Stmt::CXXStaticCastExprClass:
18265 case Stmt::ImplicitCastExprClass: {
18266 auto *CE = cast<CastExpr>(E);
18267 const Expr *From = CE->getSubExpr();
18268 switch (CE->getCastKind()) {
18273 case CK_UncheckedDerivedToBase:
18274 case CK_DerivedToBase: {
18284 case Stmt::ArraySubscriptExprClass: {
18285 auto *ASE = cast<ArraySubscriptExpr>(E);
18289 case Stmt::DeclRefExprClass: {
18290 if (
auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
18293 if (!VD->getType()->isReferenceType()) {
18295 if (VD->hasDependentAlignment())
18304 case Stmt::MemberExprClass: {
18305 auto *ME = cast<MemberExpr>(E);
18306 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
18310 std::optional<std::pair<CharUnits, CharUnits>>
P;
18319 return std::make_pair(
P->first,
18322 case Stmt::UnaryOperatorClass: {
18323 auto *UO = cast<UnaryOperator>(E);
18332 case Stmt::BinaryOperatorClass: {
18333 auto *BO = cast<BinaryOperator>(E);
18344 return std::nullopt;
18349std::optional<std::pair<
18358 case Stmt::CStyleCastExprClass:
18359 case Stmt::CXXStaticCastExprClass:
18360 case Stmt::ImplicitCastExprClass: {
18361 auto *CE = cast<CastExpr>(E);
18362 const Expr *From = CE->getSubExpr();
18363 switch (CE->getCastKind()) {
18368 case CK_ArrayToPointerDecay:
18370 case CK_UncheckedDerivedToBase:
18371 case CK_DerivedToBase: {
18381 case Stmt::CXXThisExprClass: {
18386 case Stmt::UnaryOperatorClass: {
18387 auto *UO = cast<UnaryOperator>(E);
18392 case Stmt::BinaryOperatorClass: {
18393 auto *BO = cast<BinaryOperator>(E);
18401 if (Opcode == BO_Add && !RHS->getType()->isIntegralOrEnumerationType())
18402 std::swap(LHS, RHS);
18412 return std::nullopt;
18417 std::optional<std::pair<CharUnits, CharUnits>>
P =
18421 return P->first.alignmentAtOffset(
P->second);
18441 if (!DestPtr)
return;
18447 if (DestAlign.
isOne())
return;
18451 if (!SrcPtr)
return;
18462 if (SrcAlign >= DestAlign)
return;
18467 <<
static_cast<unsigned>(DestAlign.
getQuantity())
18471void Sema::CheckArrayAccess(
const Expr *BaseExpr,
const Expr *IndexExpr,
18473 bool AllowOnePastEnd,
bool IndexNegated) {
18482 const Type *EffectiveType =
18489 StrictFlexArraysLevel =
getLangOpts().getStrictFlexArraysLevel();
18491 const Type *BaseType =
18493 bool IsUnboundedArray =
18495 Context, StrictFlexArraysLevel,
18505 llvm::APSInt index =
Result.Val.getInt();
18506 if (IndexNegated) {
18507 index.setIsUnsigned(
false);
18511 if (IsUnboundedArray) {
18514 if (index.isUnsigned() || !index.isNegative()) {
18516 unsigned AddrBits = ASTC.getTargetInfo().getPointerWidth(
18518 if (index.getBitWidth() < AddrBits)
18519 index = index.zext(AddrBits);
18520 std::optional<CharUnits> ElemCharUnits =
18521 ASTC.getTypeSizeInCharsIfKnown(EffectiveType);
18524 if (!ElemCharUnits || ElemCharUnits->isZero())
18526 llvm::APInt ElemBytes(index.getBitWidth(), ElemCharUnits->getQuantity());
18531 if (index.getActiveBits() <= AddrBits) {
18533 llvm::APInt Product(index);
18535 Product = Product.umul_ov(ElemBytes, Overflow);
18536 if (!Overflow && Product.getActiveBits() <= AddrBits)
18542 llvm::APInt MaxElems = llvm::APInt::getMaxValue(AddrBits);
18543 MaxElems = MaxElems.zext(std::max(AddrBits + 1, ElemBytes.getBitWidth()));
18545 ElemBytes = ElemBytes.zextOrTrunc(MaxElems.getBitWidth());
18546 MaxElems = MaxElems.udiv(ElemBytes);
18549 ASE ? diag::warn_array_index_exceeds_max_addressable_bounds
18550 : diag::warn_ptr_arith_exceeds_max_addressable_bounds;
18556 <<
toString(index, 10,
true) << AddrBits
18557 << (
unsigned)ASTC.toBits(*ElemCharUnits)
18560 << (
unsigned)MaxElems.getLimitedValue(~0
U)
18565 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18567 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18569 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18570 ND = ME->getMemberDecl();
18574 PDiag(diag::note_array_declared_here) << ND);
18579 if (index.isUnsigned() || !index.isNegative()) {
18589 llvm::APInt size = ArrayTy->
getSize();
18591 if (BaseType != EffectiveType) {
18599 if (!ptrarith_typesize)
18602 if (ptrarith_typesize != array_typesize) {
18604 uint64_t ratio = array_typesize / ptrarith_typesize;
18608 if (ptrarith_typesize * ratio == array_typesize)
18609 size *= llvm::APInt(size.getBitWidth(), ratio);
18613 if (size.getBitWidth() > index.getBitWidth())
18614 index = index.zext(size.getBitWidth());
18615 else if (size.getBitWidth() < index.getBitWidth())
18616 size = size.zext(index.getBitWidth());
18622 if (AllowOnePastEnd ? index.ule(size) : index.ult(size))
18639 unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds
18640 : diag::warn_ptr_arith_exceeds_bounds;
18641 unsigned CastMsg = (!ASE || BaseType == EffectiveType) ? 0 : 1;
18649 unsigned DiagID = diag::warn_array_index_precedes_bounds;
18651 DiagID = diag::warn_ptr_arith_precedes_bounds;
18652 if (index.isNegative()) index = -index;
18662 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18664 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18666 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18667 ND = ME->getMemberDecl();
18671 PDiag(diag::note_array_declared_here) << ND);
18674void Sema::CheckArrayAccess(
const Expr *
expr) {
18675 int AllowOnePastEnd = 0;
18677 expr =
expr->IgnoreParenImpCasts();
18678 switch (
expr->getStmtClass()) {
18679 case Stmt::ArraySubscriptExprClass: {
18682 AllowOnePastEnd > 0);
18686 case Stmt::MemberExprClass: {
18687 expr = cast<MemberExpr>(
expr)->getBase();
18690 case Stmt::OMPArraySectionExprClass: {
18694 nullptr, AllowOnePastEnd > 0);
18697 case Stmt::UnaryOperatorClass: {
18713 case Stmt::ConditionalOperatorClass: {
18716 CheckArrayAccess(lhs);
18718 CheckArrayAccess(rhs);
18721 case Stmt::CXXOperatorCallExprClass: {
18722 const auto *OCE = cast<CXXOperatorCallExpr>(
expr);
18723 for (
const auto *Arg : OCE->arguments())
18724 CheckArrayAccess(Arg);
18737struct RetainCycleOwner {
18741 bool Indirect =
false;
18743 RetainCycleOwner() =
default;
18745 void setLocsFrom(
Expr *e) {
18762 owner.Variable = var;
18764 owner.setLocsFrom(ref);
18772 switch (
cast->getCastKind()) {
18774 case CK_LValueBitCast:
18775 case CK_LValueToRValue:
18776 case CK_ARCReclaimReturnedObject:
18777 e =
cast->getSubExpr();
18794 if (ref->isFreeIvar()) owner.setLocsFrom(ref);
18795 owner.Indirect =
true;
18799 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) {
18800 VarDecl *var = dyn_cast<VarDecl>(ref->getDecl());
18801 if (!var)
return false;
18805 if (
MemberExpr *member = dyn_cast<MemberExpr>(e)) {
18806 if (member->isArrow())
return false;
18809 e = member->getBase();
18816 = dyn_cast<ObjCPropertyRefExpr>(pseudo->getSyntacticForm()
18818 if (!pre)
return false;
18821 if (!property->isRetaining() &&
18822 !(property->getPropertyIvarDecl() &&
18823 property->getPropertyIvarDecl()->getType()
18827 owner.Indirect =
true;
18830 if (!owner.Variable)
18836 e =
const_cast<Expr*
>(cast<OpaqueValueExpr>(pre->
getBase())
18837 ->getSourceExpr());
18851 Expr *Capturer =
nullptr;
18852 bool VarWillBeReased =
false;
18859 if (ref->
getDecl() == Variable && !Capturer)
18864 if (Capturer)
return;
18870 void VisitBlockExpr(
BlockExpr *block) {
18877 if (Capturer)
return;
18883 if (!Variable || VarWillBeReased || BinOp->
getOpcode() != BO_Assign)
18886 if (
const DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(LHS)) {
18887 if (DRE->
getDecl() != Variable)
18891 std::optional<llvm::APSInt>
Value;
18893 (RHS && (
Value = RHS->getIntegerConstantExpr(Context)) &&
18905 assert(owner.Variable && owner.Loc.isValid());
18912 if (
Cmd.isUnarySelector() &&
Cmd.getNameForSlot(0) ==
"copy") {
18913 e = ME->getInstanceReceiver();
18918 }
else if (
CallExpr *CE = dyn_cast<CallExpr>(e)) {
18923 if (FnI && FnI->
isStr(
"_Block_copy")) {
18930 BlockExpr *block = dyn_cast<BlockExpr>(e);
18934 FindCaptureVisitor visitor(S.
Context, owner.Variable);
18936 return visitor.VarWillBeReased ? nullptr : visitor.Capturer;
18940 RetainCycleOwner &owner) {
18942 assert(owner.Variable && owner.Loc.isValid());
18946 S.
Diag(owner.Loc, diag::note_arc_retain_cycle_owner)
18947 << owner.Indirect << owner.Range;
18956 str = str.ltrim(
'_');
18957 if (str.starts_with(
"set"))
18958 str = str.substr(3);
18959 else if (str.starts_with(
"add")) {
18961 if (sel.
getNumArgs() == 1 && str.starts_with(
"addOperationWithBlock"))
18963 str = str.substr(3);
18967 if (str.empty())
return true;
18971static std::optional<int>
18973 bool IsMutableArray = S.
NSAPIObj->isSubclassOfNSClass(
18974 Message->getReceiverInterface(),
18976 if (!IsMutableArray) {
18977 return std::nullopt;
18980 Selector Sel = Message->getSelector();
18982 std::optional<NSAPI::NSArrayMethodKind> MKOpt =
18983 S.
NSAPIObj->getNSArrayMethodKind(Sel);
18985 return std::nullopt;
18999 return std::nullopt;
19002 return std::nullopt;
19005static std::optional<int>
19007 bool IsMutableDictionary = S.
NSAPIObj->isSubclassOfNSClass(
19008 Message->getReceiverInterface(),
19010 if (!IsMutableDictionary) {
19011 return std::nullopt;
19014 Selector Sel = Message->getSelector();
19016 std::optional<NSAPI::NSDictionaryMethodKind> MKOpt =
19017 S.
NSAPIObj->getNSDictionaryMethodKind(Sel);
19019 return std::nullopt;
19031 return std::nullopt;
19034 return std::nullopt;
19039 bool IsMutableSet = S.
NSAPIObj->isSubclassOfNSClass(
19040 Message->getReceiverInterface(),
19043 bool IsMutableOrderedSet = S.
NSAPIObj->isSubclassOfNSClass(
19044 Message->getReceiverInterface(),
19046 if (!IsMutableSet && !IsMutableOrderedSet) {
19047 return std::nullopt;
19050 Selector Sel = Message->getSelector();
19052 std::optional<NSAPI::NSSetMethodKind> MKOpt =
19053 S.
NSAPIObj->getNSSetMethodKind(Sel);
19055 return std::nullopt;
19070 return std::nullopt;
19074 if (!Message->isInstanceMessage()) {
19078 std::optional<int> ArgOpt;
19086 int ArgIndex = *ArgOpt;
19088 Expr *Arg = Message->getArg(ArgIndex)->IgnoreImpCasts();
19094 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19095 if (ArgRE->isObjCSelfExpr()) {
19096 Diag(Message->getSourceRange().getBegin(),
19097 diag::warn_objc_circular_container)
19098 << ArgRE->getDecl() << StringRef(
"'super'");
19102 Expr *Receiver = Message->getInstanceReceiver()->IgnoreImpCasts();
19108 if (
DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {
19109 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19110 if (ReceiverRE->getDecl() == ArgRE->getDecl()) {
19112 Diag(Message->getSourceRange().getBegin(),
19113 diag::warn_objc_circular_container)
19115 if (!ArgRE->isObjCSelfExpr()) {
19117 diag::note_objc_circular_container_declared_here)
19122 }
else if (
ObjCIvarRefExpr *IvarRE = dyn_cast<ObjCIvarRefExpr>(Receiver)) {
19124 if (IvarRE->getDecl() == IvarArgRE->getDecl()) {
19126 Diag(Message->getSourceRange().getBegin(),
19127 diag::warn_objc_circular_container)
19130 diag::note_objc_circular_container_declared_here)
19145 RetainCycleOwner owner;
19158 for (
unsigned i = 0, e = msg->
getNumArgs(); i != e; ++i) {
19161 if (MD && MD->
parameters()[i]->hasAttr<NoEscapeAttr>())
19170 RetainCycleOwner owner;
19179 RetainCycleOwner Owner;
19193 Expr *RHS,
bool isProperty) {
19205 S.
Diag(Loc, diag::warn_arc_literal_assign)
19207 << (isProperty ? 0 : 1)
19215 Expr *RHS,
bool isProperty) {
19218 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19219 S.
Diag(Loc, diag::warn_arc_retained_assign)
19221 << (isProperty ? 0 : 1)
19225 RHS =
cast->getSubExpr();
19296 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19297 Diag(Loc, diag::warn_arc_retained_property_assign)
19301 RHS =
cast->getSubExpr();
19324 bool StmtLineInvalid;
19327 if (StmtLineInvalid)
19330 bool BodyLineInvalid;
19333 if (BodyLineInvalid)
19337 if (StmtLine != BodyLine)
19352 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19361 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19365 const Stmt *PossibleBody) {
19371 if (
const ForStmt *FS = dyn_cast<ForStmt>(S)) {
19372 StmtLoc = FS->getRParenLoc();
19373 Body = FS->getBody();
19374 DiagID = diag::warn_empty_for_body;
19375 }
else if (
const WhileStmt *WS = dyn_cast<WhileStmt>(S)) {
19376 StmtLoc = WS->getRParenLoc();
19377 Body = WS->getBody();
19378 DiagID = diag::warn_empty_while_body;
19383 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19406 bool ProbableTypo = isa<CompoundStmt>(PossibleBody);
19407 if (!ProbableTypo) {
19408 bool BodyColInvalid;
19411 if (BodyColInvalid)
19414 bool StmtColInvalid;
19417 if (StmtColInvalid)
19420 if (BodyCol > StmtCol)
19421 ProbableTypo =
true;
19424 if (ProbableTypo) {
19426 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19435 if (
Diags.
isIgnored(diag::warn_sizeof_pointer_expr_memaccess, OpLoc))
19447 if (
const auto *CE = dyn_cast<CallExpr>(RHSExpr);
19449 RHSExpr = CE->
getArg(0);
19450 else if (
const auto *CXXSCE = dyn_cast<CXXStaticCastExpr>(RHSExpr);
19451 CXXSCE && CXXSCE->isXValue())
19452 RHSExpr = CXXSCE->getSubExpr();
19456 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
19457 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
19460 if (LHSDeclRef && RHSDeclRef) {
19467 auto D =
Diag(OpLoc, diag::warn_self_move)
19483 const Expr *LHSBase = LHSExpr;
19484 const Expr *RHSBase = RHSExpr;
19485 const MemberExpr *LHSME = dyn_cast<MemberExpr>(LHSExpr);
19486 const MemberExpr *RHSME = dyn_cast<MemberExpr>(RHSExpr);
19487 if (!LHSME || !RHSME)
19490 while (LHSME && RHSME) {
19497 LHSME = dyn_cast<MemberExpr>(LHSBase);
19498 RHSME = dyn_cast<MemberExpr>(RHSBase);
19501 LHSDeclRef = dyn_cast<DeclRefExpr>(LHSBase);
19502 RHSDeclRef = dyn_cast<DeclRefExpr>(RHSBase);
19503 if (LHSDeclRef && RHSDeclRef) {
19510 Diag(OpLoc, diag::warn_self_move)
19516 if (isa<CXXThisExpr>(LHSBase) && isa<CXXThisExpr>(RHSBase))
19517 Diag(OpLoc, diag::warn_self_move)
19540 bool AreUnionMembers =
false) {
19541 [[maybe_unused]]
const Type *Field1Parent =
19543 [[maybe_unused]]
const Type *Field2Parent =
19548 "Can't evaluate layout compatibility between a struct field and a "
19551 (AreUnionMembers && Field1Parent->
isUnionType())) &&
19552 "AreUnionMembers should be 'true' for union fields (only).");
19565 if (Bits1 != Bits2)
19569 if (Field1->
hasAttr<clang::NoUniqueAddressAttr>() ||
19570 Field2->
hasAttr<clang::NoUniqueAddressAttr>())
19573 if (!AreUnionMembers &&
19585 if (
const CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(RD1)) {
19590 if (D1CXX->getNumBases() != D2CXX->
getNumBases())
19595 Base1 = D1CXX->bases_begin(),
19596 BaseEnd1 = D1CXX->bases_end(),
19599 ++Base1, ++Base2) {
19603 }
else if (
const CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(RD2)) {
19605 if (D2CXX->getNumBases() > 0)
19614 for ( ; Field1 != Field1End && Field2 != Field2End; ++Field1, ++Field2) {
19618 if (Field1 != Field1End || Field2 != Field2End)
19629 for (
auto *Field2 : RD2->
fields())
19630 UnmatchedFields.insert(Field2);
19632 for (
auto *Field1 : RD1->
fields()) {
19634 I = UnmatchedFields.begin(),
19635 E = UnmatchedFields.end();
19637 for ( ; I != E; ++I) {
19639 bool Result = UnmatchedFields.erase(*I);
19649 return UnmatchedFields.empty();
19675 if (
C.hasSameType(T1, T2))
19684 if (TC1 == Type::Enum) {
19686 cast<EnumType>(T1)->getDecl(),
19687 cast<EnumType>(T2)->getDecl());
19688 }
else if (TC1 == Type::Record) {
19693 cast<RecordType>(T1)->getDecl(),
19694 cast<RecordType>(T2)->getDecl());
19708 QualType BaseT =
Base->getType()->getCanonicalTypeUnqualified();
19739 const ValueDecl **VD, uint64_t *MagicValue,
19740 bool isConstantEvaluated) {
19748 case Stmt::UnaryOperatorClass: {
19757 case Stmt::DeclRefExprClass: {
19758 const DeclRefExpr *DRE = cast<DeclRefExpr>(TypeExpr);
19763 case Stmt::IntegerLiteralClass: {
19765 llvm::APInt MagicValueAPInt = IL->
getValue();
19766 if (MagicValueAPInt.getActiveBits() <= 64) {
19767 *MagicValue = MagicValueAPInt.getZExtValue();
19773 case Stmt::BinaryConditionalOperatorClass:
19774 case Stmt::ConditionalOperatorClass: {
19776 cast<AbstractConditionalOperator>(TypeExpr);
19779 isConstantEvaluated)) {
19789 case Stmt::BinaryOperatorClass: {
19792 TypeExpr = BO->
getRHS();
19822 const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
19825 bool isConstantEvaluated) {
19826 FoundWrongKind =
false;
19831 uint64_t MagicValue;
19833 if (!
FindTypeTagExpr(TypeExpr, Ctx, &VD, &MagicValue, isConstantEvaluated))
19837 if (TypeTagForDatatypeAttr *I = VD->
getAttr<TypeTagForDatatypeAttr>()) {
19838 if (I->getArgumentKind() != ArgumentKind) {
19839 FoundWrongKind =
true;
19842 TypeInfo.Type = I->getMatchingCType();
19843 TypeInfo.LayoutCompatible = I->getLayoutCompatible();
19844 TypeInfo.MustBeNull = I->getMustBeNull();
19855 MagicValues->find(std::make_pair(ArgumentKind, MagicValue));
19856 if (I == MagicValues->end())
19865 bool LayoutCompatible,
19867 if (!TypeTagForDatatypeMagicValues)
19868 TypeTagForDatatypeMagicValues.reset(
19869 new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);
19872 (*TypeTagForDatatypeMagicValues)[Magic] =
19888 return (T1Kind == BuiltinType::SChar && T2Kind == BuiltinType::Char_S) ||
19889 (T1Kind == BuiltinType::UChar && T2Kind == BuiltinType::Char_U) ||
19890 (T1Kind == BuiltinType::Char_U && T2Kind == BuiltinType::UChar) ||
19891 (T1Kind == BuiltinType::Char_S && T2Kind == BuiltinType::SChar);
19894void Sema::CheckArgumentWithTypeTag(
const ArgumentWithTypeTagAttr *
Attr,
19898 bool IsPointerAttr =
Attr->getIsPointer();
19901 unsigned TypeTagIdxAST =
Attr->getTypeTagIdx().getASTIndex();
19902 if (TypeTagIdxAST >= ExprArgs.size()) {
19903 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19904 << 0 <<
Attr->getTypeTagIdx().getSourceIndex();
19907 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
19908 bool FoundWrongKind;
19911 TypeTagForDatatypeMagicValues.get(), FoundWrongKind,
19913 if (FoundWrongKind)
19915 diag::warn_type_tag_for_datatype_wrong_kind)
19921 unsigned ArgumentIdxAST =
Attr->getArgumentIdx().getASTIndex();
19922 if (ArgumentIdxAST >= ExprArgs.size()) {
19923 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19924 << 1 <<
Attr->getArgumentIdx().getSourceIndex();
19927 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
19928 if (IsPointerAttr) {
19930 if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgumentExpr))
19931 if (ICE->getType()->isVoidPointerType() &&
19932 ICE->getCastKind() == CK_BitCast)
19933 ArgumentExpr = ICE->getSubExpr();
19946 diag::warn_type_safety_null_pointer_required)
19958 bool mismatch =
false;
19981 Diag(ArgumentExpr->
getExprLoc(), diag::warn_type_safety_type_mismatch)
19982 << ArgumentType << ArgumentKind
19983 <<
TypeInfo.LayoutCompatible << RequiredType
19990 MisalignedMembers.emplace_back(E, RD, MD, Alignment);
19994 for (MisalignedMember &m : MisalignedMembers) {
20000 Diag(m.E->getBeginLoc(), diag::warn_taking_address_of_packed_member)
20003 MisalignedMembers.clear();
20010 if (isa<UnaryOperator>(E) &&
20011 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
20012 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
20013 if (isa<MemberExpr>(Op)) {
20014 auto *MA = llvm::find(MisalignedMembers, MisalignedMember(Op));
20015 if (MA != MisalignedMembers.end() &&
20020 MisalignedMembers.erase(MA);
20029 const auto *ME = dyn_cast<MemberExpr>(E);
20041 bool AnyIsPacked =
false;
20043 QualType BaseType = ME->getBase()->getType();
20053 auto *FD = dyn_cast<FieldDecl>(MD);
20059 AnyIsPacked || (RD->
hasAttr<PackedAttr>() || MD->
hasAttr<PackedAttr>());
20060 ReverseMemberChain.push_back(FD);
20063 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParens());
20065 assert(TopME &&
"We did not compute a topmost MemberExpr!");
20072 const auto *DRE = dyn_cast<DeclRefExpr>(TopBase);
20076 if (!DRE && !isa<CXXThisExpr>(TopBase))
20083 if (ExpectedAlignment.
isOne())
20088 for (
const FieldDecl *FD : llvm::reverse(ReverseMemberChain))
20093 ReverseMemberChain.back()->getParent()->getTypeForDecl());
20097 if (DRE && !TopME->
isArrow()) {
20100 CompleteObjectAlignment =
20105 if (Offset % ExpectedAlignment != 0 ||
20108 CompleteObjectAlignment < ExpectedAlignment) {
20119 for (
FieldDecl *FDI : ReverseMemberChain) {
20120 if (FDI->hasAttr<PackedAttr>() ||
20121 FDI->getParent()->hasAttr<PackedAttr>()) {
20123 Alignment = std::min(
20129 assert(FD &&
"We did not find a packed FieldDecl!");
20130 Action(E, FD->
getParent(), FD, Alignment);
20134void Sema::CheckAddressOfPackedMember(
Expr *rhs) {
20135 using namespace std::placeholders;
20138 rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*
this), _1,
20142bool Sema::PrepareBuiltinElementwiseMathOneArgCall(
CallExpr *TheCall) {
20160bool Sema::BuiltinElementwiseMath(
CallExpr *TheCall) {
20174 TheCall->
setType(VecTy0->getElementType());
20198 diag::err_typecheck_call_different_arg_types)
20209bool Sema::BuiltinElementwiseTernaryMath(
CallExpr *TheCall,
20210 bool CheckForFloatArgs) {
20215 for (
int I = 0; I < 3; ++I) {
20219 Args[I] = Converted.
get();
20222 if (CheckForFloatArgs) {
20223 int ArgOrdinal = 1;
20224 for (
Expr *Arg : Args) {
20226 Arg->
getType(), ArgOrdinal++))
20230 int ArgOrdinal = 1;
20231 for (
Expr *Arg : Args) {
20238 for (
int I = 1; I < 3; ++I) {
20239 if (Args[0]->getType().getCanonicalType() !=
20240 Args[I]->getType().getCanonicalType()) {
20241 return Diag(Args[0]->getBeginLoc(),
20242 diag::err_typecheck_call_different_arg_types)
20243 << Args[0]->getType() << Args[I]->getType();
20246 TheCall->
setArg(I, Args[I]);
20249 TheCall->
setType(Args[0]->getType());
20253bool Sema::PrepareBuiltinReduceMathOneArgCall(
CallExpr *TheCall) {
20265bool Sema::BuiltinNonDeterministicValue(
CallExpr *TheCall) {
20274 << 1 << 0 << TyArg;
20288 Expr *Matrix = MatrixArg.
get();
20293 << 1 << 1 << Matrix->
getType();
20300 MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
20303 TheCall->
setType(ResultType);
20306 TheCall->
setArg(0, Matrix);
20311static std::optional<unsigned>
20314 std::optional<llvm::APSInt>
Value =
20321 uint64_t Dim =
Value->getZExtValue();
20340 unsigned PtrArgIdx = 0;
20346 bool ArgError =
false;
20353 PtrExpr = PtrConv.
get();
20354 TheCall->
setArg(0, PtrExpr);
20365 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20372 << PtrArgIdx + 1 << 2
20379 auto ApplyArgumentConversions = [
this](
Expr *E) {
20388 ExprResult RowsConv = ApplyArgumentConversions(RowsExpr);
20390 RowsExpr = RowsConv.
get();
20391 TheCall->
setArg(1, RowsExpr);
20393 RowsExpr =
nullptr;
20395 ExprResult ColumnsConv = ApplyArgumentConversions(ColumnsExpr);
20397 ColumnsExpr = ColumnsConv.
get();
20398 TheCall->
setArg(2, ColumnsExpr);
20400 ColumnsExpr =
nullptr;
20411 std::optional<unsigned> MaybeRows;
20415 std::optional<unsigned> MaybeColumns;
20420 ExprResult StrideConv = ApplyArgumentConversions(StrideExpr);
20423 StrideExpr = StrideConv.
get();
20424 TheCall->
setArg(3, StrideExpr);
20427 if (std::optional<llvm::APSInt>
Value =
20430 if (Stride < *MaybeRows) {
20432 diag::err_builtin_matrix_stride_too_small);
20438 if (ArgError || !MaybeRows || !MaybeColumns)
20451 unsigned PtrArgIdx = 1;
20456 bool ArgError =
false;
20462 MatrixExpr = MatrixConv.
get();
20463 TheCall->
setArg(0, MatrixExpr);
20473 << 1 << 1 << MatrixExpr->
getType();
20481 PtrExpr = PtrConv.
get();
20482 TheCall->
setArg(1, PtrExpr);
20493 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20498 Diag(PtrExpr->
getBeginLoc(), diag::err_builtin_matrix_store_to_const);
20505 diag::err_builtin_matrix_pointer_arg_mismatch)
20506 << ElementTy << MatrixTy->getElementType();
20521 StrideExpr = StrideConv.
get();
20522 TheCall->
setArg(2, StrideExpr);
20527 if (std::optional<llvm::APSInt>
Value =
20530 if (Stride < MatrixTy->getNumRows()) {
20532 diag::err_builtin_matrix_stride_too_small);
20549 const auto *ATy = dyn_cast<ArrayType>(ArgExpr->
getType());
20550 if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
20552 diag::err_wasm_builtin_arg_must_be_table_type)
20555 ElTy = ATy->getElementType();
20561 unsigned ArgIndex) {
20565 diag::err_wasm_builtin_arg_must_be_integer_type)
20573bool Sema::BuiltinWasmTableGet(
CallExpr *TheCall) {
20596bool Sema::BuiltinWasmTableSet(
CallExpr *TheCall) {
20614bool Sema::BuiltinWasmTableSize(
CallExpr *TheCall) {
20628bool Sema::BuiltinWasmTableGrow(
CallExpr *TheCall) {
20639 diag::err_wasm_builtin_arg_must_match_table_element_type)
20652bool Sema::BuiltinWasmTableFill(
CallExpr *TheCall) {
20666 diag::err_wasm_builtin_arg_must_match_table_element_type)
20679bool Sema::BuiltinWasmTableCopy(
CallExpr *TheCall) {
20694 diag::err_wasm_builtin_arg_must_match_table_element_type)
20698 for (
int I = 2; I <= 4; I++) {
20718 if (!Caller || !Caller->
hasAttr<EnforceTCBAttr>())
20723 llvm::StringSet<> CalleeTCBs;
20724 for (
const auto *A :
Callee->specific_attrs<EnforceTCBAttr>())
20725 CalleeTCBs.insert(A->getTCBName());
20726 for (
const auto *A :
Callee->specific_attrs<EnforceTCBLeafAttr>())
20727 CalleeTCBs.insert(A->getTCBName());
20731 for (
const auto *A : Caller->
specific_attrs<EnforceTCBAttr>()) {
20732 StringRef CallerTCB = A->getTCBName();
20733 if (CalleeTCBs.count(CallerTCB) == 0) {
20734 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...
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)
@ 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
OpenMP 5.0 [2.1.5, Array Sections].
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Expr * getLowerBound()
Get lower bound of array section.
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.
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.
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.