64#include "llvm/ADT/APFloat.h"
65#include "llvm/ADT/APInt.h"
66#include "llvm/ADT/APSInt.h"
67#include "llvm/ADT/ArrayRef.h"
68#include "llvm/ADT/DenseMap.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/STLExtras.h"
71#include "llvm/ADT/SmallBitVector.h"
72#include "llvm/ADT/SmallPtrSet.h"
73#include "llvm/ADT/SmallString.h"
74#include "llvm/ADT/SmallVector.h"
75#include "llvm/ADT/StringExtras.h"
76#include "llvm/ADT/StringRef.h"
77#include "llvm/ADT/StringSet.h"
78#include "llvm/ADT/StringSwitch.h"
79#include "llvm/Support/AtomicOrdering.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/Compiler.h"
82#include "llvm/Support/ConvertUTF.h"
83#include "llvm/Support/ErrorHandling.h"
84#include "llvm/Support/Format.h"
85#include "llvm/Support/Locale.h"
86#include "llvm/Support/MathExtras.h"
87#include "llvm/Support/SaveAndRestore.h"
88#include "llvm/Support/raw_ostream.h"
89#include "llvm/TargetParser/RISCVTargetParser.h"
90#include "llvm/TargetParser/Triple.h"
104using namespace clang;
108 unsigned ByteNo)
const {
122 unsigned MinArgCount) {
123 unsigned ArgCount =
Call->getNumArgs();
124 if (ArgCount >= MinArgCount)
127 return S.
Diag(
Call->getEndLoc(), diag::err_typecheck_call_too_few_args)
128 << 0 << MinArgCount << ArgCount
129 << 0 <<
Call->getSourceRange();
136 unsigned ArgCount =
Call->getNumArgs();
137 if (ArgCount <= MaxArgCount)
140 diag::err_typecheck_call_too_many_args_at_most)
141 << 0 << MaxArgCount << ArgCount
142 << 0 <<
Call->getSourceRange();
149 unsigned MaxArgCount) {
157 unsigned ArgCount =
Call->getNumArgs();
158 if (ArgCount == DesiredArgCount)
163 assert(ArgCount > DesiredArgCount &&
"should have diagnosed this");
167 Call->getArg(ArgCount - 1)->getEndLoc());
169 return S.
Diag(Range.getBegin(), diag::err_typecheck_call_too_many_args)
170 << 0 << DesiredArgCount << ArgCount
171 << 0 <<
Call->getArg(1)->getSourceRange();
175 if (
Value->isTypeDependent())
206 if (!Literal || !Literal->isOrdinary()) {
219 S.
Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
227 auto *Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
228 if (!Literal || !Literal->isWide()) {
229 S.
Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
230 << Arg->getSourceRange();
264 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(
295 bool IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;
297 auto IsValidIntegerType = [](
QualType Ty) {
298 return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
305 if ((!SrcTy->
isPointerType() && !IsValidIntegerType(SrcTy)) ||
309 S.
Diag(Source->
getExprLoc(), diag::err_typecheck_expect_scalar_operand)
315 if (!IsValidIntegerType(AlignOp->
getType())) {
326 llvm::APSInt AlignValue = AlignResult.
Val.
getInt();
327 llvm::APSInt MaxValue(
328 llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
329 if (AlignValue < 1) {
330 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_too_small) << 1;
333 if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
338 if (!AlignValue.isPowerOf2()) {
339 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_not_power_of_two);
342 if (AlignValue == 1) {
343 S.
Diag(AlignOp->
getExprLoc(), diag::warn_alignment_builtin_useless)
344 << IsBooleanAlignBuiltin;
369 unsigned BuiltinID) {
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);
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->
getSize().getZExtValue();
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();
1938 auto RT =
Call->getArg(0)->getType();
1939 if (!RT->isPointerType() || RT->getPointeeType()
1941 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_to_addr_invalid_arg)
1942 <<
Call->getArg(0) <<
Call->getDirectCallee() <<
Call->getSourceRange();
1947 S.
Diag(
Call->getArg(0)->getBeginLoc(),
1948 diag::warn_opencl_generic_address_space_arg)
1949 <<
Call->getDirectCallee()->getNameInfo().getAsString()
1950 <<
Call->getArg(0)->getSourceRange();
1953 RT = RT->getPointeeType();
1954 auto Qual = RT.getQualifiers();
1955 switch (BuiltinID) {
1956 case Builtin::BIto_global:
1959 case Builtin::BIto_local:
1962 case Builtin::BIto_private:
1966 llvm_unreachable(
"Invalid builtin function");
1969 RT.getUnqualifiedType(), Qual)));
1975enum PointerAuthOpKind {
2020 llvm::raw_svector_ostream Str(
Value);
2029 Result = KeyValue->getZExtValue();
2034 PointerAuthOpKind OpKind) {
2042 auto AllowsPointer = [](PointerAuthOpKind OpKind) {
2043 return OpKind != PAO_BlendInteger;
2045 auto AllowsInteger = [](PointerAuthOpKind OpKind) {
2046 return OpKind == PAO_Discriminator || OpKind == PAO_BlendInteger ||
2047 OpKind == PAO_SignGeneric;
2056 }
else if (AllowsInteger(OpKind) &&
2063 <<
unsigned(OpKind == PAO_Discriminator ? 1
2064 : OpKind == PAO_BlendPointer ? 2
2065 : OpKind == PAO_BlendInteger ? 3
2067 <<
unsigned(AllowsInteger(OpKind) ? (AllowsPointer(OpKind) ? 2 : 1) : 0)
2078 if ((OpKind == PAO_Sign || OpKind == PAO_Auth) &&
2081 ? diag::warn_ptrauth_sign_null_pointer
2082 : diag::warn_ptrauth_auth_null_pointer)
2098 Call->setType(
Call->getArgs()[0]->getType());
2129 PointerAuthOpKind OpKind) {
2139 Call->setType(
Call->getArgs()[0]->getType());
2155 Call->setType(
Call->getArgs()[0]->getType());
2180 auto DiagSelect = [&]() -> std::optional<unsigned> {
2187 return std::optional<unsigned>{};
2202 diag::err_incomplete_type))
2206 "Unhandled non-object pointer case");
2224 llvm::Triple::ObjectFormatType CurObjFormat =
2226 if (llvm::is_contained(UnsupportedObjectFormatTypes, CurObjFormat)) {
2239 llvm::Triple::ArchType CurArch =
2241 if (llvm::is_contained(SupportedArchs, CurArch))
2251bool Sema::CheckTSBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
2258 case llvm::Triple::arm:
2259 case llvm::Triple::armeb:
2260 case llvm::Triple::thumb:
2261 case llvm::Triple::thumbeb:
2262 return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
2263 case llvm::Triple::aarch64:
2264 case llvm::Triple::aarch64_32:
2265 case llvm::Triple::aarch64_be:
2266 return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
2267 case llvm::Triple::bpfeb:
2268 case llvm::Triple::bpfel:
2269 return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
2270 case llvm::Triple::hexagon:
2271 return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
2272 case llvm::Triple::mips:
2273 case llvm::Triple::mipsel:
2274 case llvm::Triple::mips64:
2275 case llvm::Triple::mips64el:
2276 return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
2277 case llvm::Triple::systemz:
2278 return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
2279 case llvm::Triple::x86:
2280 case llvm::Triple::x86_64:
2281 return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
2282 case llvm::Triple::ppc:
2283 case llvm::Triple::ppcle:
2284 case llvm::Triple::ppc64:
2285 case llvm::Triple::ppc64le:
2286 return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
2287 case llvm::Triple::amdgcn:
2288 return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
2289 case llvm::Triple::riscv32:
2290 case llvm::Triple::riscv64:
2291 return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
2292 case llvm::Triple::loongarch32:
2293 case llvm::Triple::loongarch64:
2294 return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
2295 case llvm::Triple::wasm32:
2296 case llvm::Triple::wasm64:
2297 return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
2298 case llvm::Triple::nvptx:
2299 case llvm::Triple::nvptx64:
2300 return CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
2311 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2312 << ArgIndex << 0 << ArgTy;
2322 EltTy = VecTy->getElementType();
2325 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2326 << ArgIndex << 5 << ArgTy;
2336 const TargetInfo *AuxTI,
unsigned BuiltinID) {
2337 assert((BuiltinID == Builtin::BI__builtin_cpu_supports ||
2338 BuiltinID == Builtin::BI__builtin_cpu_is) &&
2339 "Expecting __builtin_cpu_...");
2341 bool IsCPUSupports = BuiltinID == Builtin::BI__builtin_cpu_supports;
2343 auto SupportsBI = [=](
const TargetInfo *TInfo) {
2344 return TInfo && ((IsCPUSupports && TInfo->supportsCpuSupports()) ||
2345 (!IsCPUSupports && TInfo->supportsCpuIs()));
2347 if (!SupportsBI(&TI) && SupportsBI(AuxTI))
2351 return S.
Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
2356 ? diag::err_builtin_aix_os_unsupported
2357 : diag::err_builtin_target_unsupported)
2362 if (!isa<StringLiteral>(Arg))
2363 return S.
Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
2367 StringRef Feature = cast<StringLiteral>(Arg)->getString();
2403Sema::CheckBuiltinFunctionCall(
FunctionDecl *FDecl,
unsigned BuiltinID,
2408 unsigned ICEArguments = 0;
2415 for (
unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
2417 if ((ICEArguments & (1 << ArgNo)) == 0)
continue;
2422 if (ArgNo < TheCall->getNumArgs() &&
2423 SemaBuiltinConstantArg(TheCall, ArgNo,
Result))
2425 ICEArguments &= ~(1 << ArgNo);
2429 switch (BuiltinID) {
2430 case Builtin::BI__builtin_cpu_supports:
2431 case Builtin::BI__builtin_cpu_is:
2436 case Builtin::BI__builtin_cpu_init:
2443 case Builtin::BI__builtin___CFStringMakeConstantString:
2447 *
this, BuiltinID, TheCall,
2448 {llvm::Triple::GOFF, llvm::Triple::XCOFF}))
2451 "Wrong # arguments to builtin CFStringMakeConstantString");
2452 if (CheckObjCString(TheCall->
getArg(0)))
2455 case Builtin::BI__builtin_ms_va_start:
2456 case Builtin::BI__builtin_stdarg_start:
2457 case Builtin::BI__builtin_va_start:
2458 if (SemaBuiltinVAStart(BuiltinID, TheCall))
2461 case Builtin::BI__va_start: {
2463 case llvm::Triple::aarch64:
2464 case llvm::Triple::arm:
2465 case llvm::Triple::thumb:
2466 if (SemaBuiltinVAStartARMMicrosoft(TheCall))
2470 if (SemaBuiltinVAStart(BuiltinID, TheCall))
2478 case Builtin::BI_interlockedbittestandset_acq:
2479 case Builtin::BI_interlockedbittestandset_rel:
2480 case Builtin::BI_interlockedbittestandset_nf:
2481 case Builtin::BI_interlockedbittestandreset_acq:
2482 case Builtin::BI_interlockedbittestandreset_rel:
2483 case Builtin::BI_interlockedbittestandreset_nf:
2485 *
this, BuiltinID, TheCall,
2486 {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
2491 case Builtin::BI_bittest64:
2492 case Builtin::BI_bittestandcomplement64:
2493 case Builtin::BI_bittestandreset64:
2494 case Builtin::BI_bittestandset64:
2495 case Builtin::BI_interlockedbittestandreset64:
2496 case Builtin::BI_interlockedbittestandset64:
2498 {llvm::Triple::x86_64, llvm::Triple::arm,
2499 llvm::Triple::thumb,
2500 llvm::Triple::aarch64}))
2504 case Builtin::BI__builtin_set_flt_rounds:
2506 {llvm::Triple::x86, llvm::Triple::x86_64,
2507 llvm::Triple::arm, llvm::Triple::thumb,
2508 llvm::Triple::aarch64}))
2512 case Builtin::BI__builtin_isgreater:
2513 case Builtin::BI__builtin_isgreaterequal:
2514 case Builtin::BI__builtin_isless:
2515 case Builtin::BI__builtin_islessequal:
2516 case Builtin::BI__builtin_islessgreater:
2517 case Builtin::BI__builtin_isunordered:
2518 if (SemaBuiltinUnorderedCompare(TheCall, BuiltinID))
2521 case Builtin::BI__builtin_fpclassify:
2522 if (SemaBuiltinFPClassification(TheCall, 6, BuiltinID))
2525 case Builtin::BI__builtin_isfpclass:
2526 if (SemaBuiltinFPClassification(TheCall, 2, BuiltinID))
2529 case Builtin::BI__builtin_isfinite:
2530 case Builtin::BI__builtin_isinf:
2531 case Builtin::BI__builtin_isinf_sign:
2532 case Builtin::BI__builtin_isnan:
2533 case Builtin::BI__builtin_issignaling:
2534 case Builtin::BI__builtin_isnormal:
2535 case Builtin::BI__builtin_issubnormal:
2536 case Builtin::BI__builtin_iszero:
2537 case Builtin::BI__builtin_signbit:
2538 case Builtin::BI__builtin_signbitf:
2539 case Builtin::BI__builtin_signbitl:
2540 if (SemaBuiltinFPClassification(TheCall, 1, BuiltinID))
2543 case Builtin::BI__builtin_shufflevector:
2547 case Builtin::BI__builtin_prefetch:
2548 if (SemaBuiltinPrefetch(TheCall))
2551 case Builtin::BI__builtin_alloca_with_align:
2552 case Builtin::BI__builtin_alloca_with_align_uninitialized:
2553 if (SemaBuiltinAllocaWithAlign(TheCall))
2556 case Builtin::BI__builtin_alloca:
2557 case Builtin::BI__builtin_alloca_uninitialized:
2561 case Builtin::BI__arithmetic_fence:
2562 if (SemaBuiltinArithmeticFence(TheCall))
2565 case Builtin::BI__assume:
2566 case Builtin::BI__builtin_assume:
2567 if (SemaBuiltinAssume(TheCall))
2570 case Builtin::BI__builtin_assume_aligned:
2571 if (SemaBuiltinAssumeAligned(TheCall))
2574 case Builtin::BI__builtin_dynamic_object_size:
2575 case Builtin::BI__builtin_object_size:
2576 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
2579 case Builtin::BI__builtin_longjmp:
2580 if (SemaBuiltinLongjmp(TheCall))
2583 case Builtin::BI__builtin_setjmp:
2584 if (SemaBuiltinSetjmp(TheCall))
2587 case Builtin::BI__builtin_classify_type:
2591 case Builtin::BI__builtin_complex:
2592 if (SemaBuiltinComplex(TheCall))
2595 case Builtin::BI__builtin_constant_p: {
2603 case Builtin::BI__builtin_launder:
2605 case Builtin::BI__sync_fetch_and_add:
2606 case Builtin::BI__sync_fetch_and_add_1:
2607 case Builtin::BI__sync_fetch_and_add_2:
2608 case Builtin::BI__sync_fetch_and_add_4:
2609 case Builtin::BI__sync_fetch_and_add_8:
2610 case Builtin::BI__sync_fetch_and_add_16:
2611 case Builtin::BI__sync_fetch_and_sub:
2612 case Builtin::BI__sync_fetch_and_sub_1:
2613 case Builtin::BI__sync_fetch_and_sub_2:
2614 case Builtin::BI__sync_fetch_and_sub_4:
2615 case Builtin::BI__sync_fetch_and_sub_8:
2616 case Builtin::BI__sync_fetch_and_sub_16:
2617 case Builtin::BI__sync_fetch_and_or:
2618 case Builtin::BI__sync_fetch_and_or_1:
2619 case Builtin::BI__sync_fetch_and_or_2:
2620 case Builtin::BI__sync_fetch_and_or_4:
2621 case Builtin::BI__sync_fetch_and_or_8:
2622 case Builtin::BI__sync_fetch_and_or_16:
2623 case Builtin::BI__sync_fetch_and_and:
2624 case Builtin::BI__sync_fetch_and_and_1:
2625 case Builtin::BI__sync_fetch_and_and_2:
2626 case Builtin::BI__sync_fetch_and_and_4:
2627 case Builtin::BI__sync_fetch_and_and_8:
2628 case Builtin::BI__sync_fetch_and_and_16:
2629 case Builtin::BI__sync_fetch_and_xor:
2630 case Builtin::BI__sync_fetch_and_xor_1:
2631 case Builtin::BI__sync_fetch_and_xor_2:
2632 case Builtin::BI__sync_fetch_and_xor_4:
2633 case Builtin::BI__sync_fetch_and_xor_8:
2634 case Builtin::BI__sync_fetch_and_xor_16:
2635 case Builtin::BI__sync_fetch_and_nand:
2636 case Builtin::BI__sync_fetch_and_nand_1:
2637 case Builtin::BI__sync_fetch_and_nand_2:
2638 case Builtin::BI__sync_fetch_and_nand_4:
2639 case Builtin::BI__sync_fetch_and_nand_8:
2640 case Builtin::BI__sync_fetch_and_nand_16:
2641 case Builtin::BI__sync_add_and_fetch:
2642 case Builtin::BI__sync_add_and_fetch_1:
2643 case Builtin::BI__sync_add_and_fetch_2:
2644 case Builtin::BI__sync_add_and_fetch_4:
2645 case Builtin::BI__sync_add_and_fetch_8:
2646 case Builtin::BI__sync_add_and_fetch_16:
2647 case Builtin::BI__sync_sub_and_fetch:
2648 case Builtin::BI__sync_sub_and_fetch_1:
2649 case Builtin::BI__sync_sub_and_fetch_2:
2650 case Builtin::BI__sync_sub_and_fetch_4:
2651 case Builtin::BI__sync_sub_and_fetch_8:
2652 case Builtin::BI__sync_sub_and_fetch_16:
2653 case Builtin::BI__sync_and_and_fetch:
2654 case Builtin::BI__sync_and_and_fetch_1:
2655 case Builtin::BI__sync_and_and_fetch_2:
2656 case Builtin::BI__sync_and_and_fetch_4:
2657 case Builtin::BI__sync_and_and_fetch_8:
2658 case Builtin::BI__sync_and_and_fetch_16:
2659 case Builtin::BI__sync_or_and_fetch:
2660 case Builtin::BI__sync_or_and_fetch_1:
2661 case Builtin::BI__sync_or_and_fetch_2:
2662 case Builtin::BI__sync_or_and_fetch_4:
2663 case Builtin::BI__sync_or_and_fetch_8:
2664 case Builtin::BI__sync_or_and_fetch_16:
2665 case Builtin::BI__sync_xor_and_fetch:
2666 case Builtin::BI__sync_xor_and_fetch_1:
2667 case Builtin::BI__sync_xor_and_fetch_2:
2668 case Builtin::BI__sync_xor_and_fetch_4:
2669 case Builtin::BI__sync_xor_and_fetch_8:
2670 case Builtin::BI__sync_xor_and_fetch_16:
2671 case Builtin::BI__sync_nand_and_fetch:
2672 case Builtin::BI__sync_nand_and_fetch_1:
2673 case Builtin::BI__sync_nand_and_fetch_2:
2674 case Builtin::BI__sync_nand_and_fetch_4:
2675 case Builtin::BI__sync_nand_and_fetch_8:
2676 case Builtin::BI__sync_nand_and_fetch_16:
2677 case Builtin::BI__sync_val_compare_and_swap:
2678 case Builtin::BI__sync_val_compare_and_swap_1:
2679 case Builtin::BI__sync_val_compare_and_swap_2:
2680 case Builtin::BI__sync_val_compare_and_swap_4:
2681 case Builtin::BI__sync_val_compare_and_swap_8:
2682 case Builtin::BI__sync_val_compare_and_swap_16:
2683 case Builtin::BI__sync_bool_compare_and_swap:
2684 case Builtin::BI__sync_bool_compare_and_swap_1:
2685 case Builtin::BI__sync_bool_compare_and_swap_2:
2686 case Builtin::BI__sync_bool_compare_and_swap_4:
2687 case Builtin::BI__sync_bool_compare_and_swap_8:
2688 case Builtin::BI__sync_bool_compare_and_swap_16:
2689 case Builtin::BI__sync_lock_test_and_set:
2690 case Builtin::BI__sync_lock_test_and_set_1:
2691 case Builtin::BI__sync_lock_test_and_set_2:
2692 case Builtin::BI__sync_lock_test_and_set_4:
2693 case Builtin::BI__sync_lock_test_and_set_8:
2694 case Builtin::BI__sync_lock_test_and_set_16:
2695 case Builtin::BI__sync_lock_release:
2696 case Builtin::BI__sync_lock_release_1:
2697 case Builtin::BI__sync_lock_release_2:
2698 case Builtin::BI__sync_lock_release_4:
2699 case Builtin::BI__sync_lock_release_8:
2700 case Builtin::BI__sync_lock_release_16:
2701 case Builtin::BI__sync_swap:
2702 case Builtin::BI__sync_swap_1:
2703 case Builtin::BI__sync_swap_2:
2704 case Builtin::BI__sync_swap_4:
2705 case Builtin::BI__sync_swap_8:
2706 case Builtin::BI__sync_swap_16:
2707 return SemaBuiltinAtomicOverloaded(TheCallResult);
2708 case Builtin::BI__sync_synchronize:
2712 case Builtin::BI__builtin_nontemporal_load:
2713 case Builtin::BI__builtin_nontemporal_store:
2714 return SemaBuiltinNontemporalOverloaded(TheCallResult);
2715 case Builtin::BI__builtin_memcpy_inline: {
2728 case Builtin::BI__builtin_memset_inline: {
2739#define BUILTIN(ID, TYPE, ATTRS)
2740#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
2741 case Builtin::BI##ID: \
2742 return SemaAtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
2743#include "clang/Basic/Builtins.inc"
2744 case Builtin::BI__annotation:
2748 case Builtin::BI__builtin_annotation:
2752 case Builtin::BI__builtin_addressof:
2756 case Builtin::BI__builtin_function_start:
2760 case Builtin::BI__builtin_is_aligned:
2761 case Builtin::BI__builtin_align_up:
2762 case Builtin::BI__builtin_align_down:
2766 case Builtin::BI__builtin_add_overflow:
2767 case Builtin::BI__builtin_sub_overflow:
2768 case Builtin::BI__builtin_mul_overflow:
2772 case Builtin::BI__builtin_operator_new:
2773 case Builtin::BI__builtin_operator_delete: {
2774 bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
2776 SemaBuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
2781 case Builtin::BI__builtin_dump_struct:
2783 case Builtin::BI__builtin_expect_with_probability: {
2794 Diag(ProbArg->
getBeginLoc(), diag::err_probability_not_constant_float)
2801 bool LoseInfo =
false;
2802 Probability.convert(llvm::APFloat::IEEEdouble(),
2803 llvm::RoundingMode::Dynamic, &LoseInfo);
2804 if (!(Probability >= llvm::APFloat(0.0) &&
2805 Probability <= llvm::APFloat(1.0))) {
2812 case Builtin::BI__builtin_preserve_access_index:
2816 case Builtin::BI__builtin_call_with_static_chain:
2820 case Builtin::BI__exception_code:
2821 case Builtin::BI_exception_code:
2823 diag::err_seh___except_block))
2826 case Builtin::BI__exception_info:
2827 case Builtin::BI_exception_info:
2829 diag::err_seh___except_filter))
2832 case Builtin::BI__GetExceptionInfo:
2844 case Builtin::BIaddressof:
2845 case Builtin::BI__addressof:
2846 case Builtin::BIforward:
2847 case Builtin::BIforward_like:
2848 case Builtin::BImove:
2849 case Builtin::BImove_if_noexcept:
2850 case Builtin::BIas_const: {
2858 bool ReturnsPointer = BuiltinID == Builtin::BIaddressof ||
2859 BuiltinID == Builtin::BI__addressof;
2861 (ReturnsPointer ?
Result->isAnyPointerType()
2862 :
Result->isReferenceType()) &&
2864 Result->getPointeeType()))) {
2865 Diag(TheCall->
getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2871 case Builtin::BI__builtin_ptrauth_strip:
2873 case Builtin::BI__builtin_ptrauth_blend_discriminator:
2875 case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
2877 case Builtin::BI__builtin_ptrauth_auth:
2879 case Builtin::BI__builtin_ptrauth_sign_generic_data:
2881 case Builtin::BI__builtin_ptrauth_auth_and_resign:
2884 case Builtin::BIread_pipe:
2885 case Builtin::BIwrite_pipe:
2891 case Builtin::BIreserve_read_pipe:
2892 case Builtin::BIreserve_write_pipe:
2893 case Builtin::BIwork_group_reserve_read_pipe:
2894 case Builtin::BIwork_group_reserve_write_pipe:
2898 case Builtin::BIsub_group_reserve_read_pipe:
2899 case Builtin::BIsub_group_reserve_write_pipe:
2904 case Builtin::BIcommit_read_pipe:
2905 case Builtin::BIcommit_write_pipe:
2906 case Builtin::BIwork_group_commit_read_pipe:
2907 case Builtin::BIwork_group_commit_write_pipe:
2911 case Builtin::BIsub_group_commit_read_pipe:
2912 case Builtin::BIsub_group_commit_write_pipe:
2917 case Builtin::BIget_pipe_num_packets:
2918 case Builtin::BIget_pipe_max_packets:
2922 case Builtin::BIto_global:
2923 case Builtin::BIto_local:
2924 case Builtin::BIto_private:
2929 case Builtin::BIenqueue_kernel:
2933 case Builtin::BIget_kernel_work_group_size:
2934 case Builtin::BIget_kernel_preferred_work_group_size_multiple:
2938 case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
2939 case Builtin::BIget_kernel_sub_group_count_for_ndrange:
2943 case Builtin::BI__builtin_os_log_format:
2946 case Builtin::BI__builtin_os_log_format_buffer_size:
2947 if (SemaBuiltinOSLogFormat(TheCall))
2950 case Builtin::BI__builtin_frame_address:
2951 case Builtin::BI__builtin_return_address: {
2952 if (SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
2960 Result.Val.getInt() != 0)
2962 << ((BuiltinID == Builtin::BI__builtin_return_address)
2963 ?
"__builtin_return_address"
2964 :
"__builtin_frame_address")
2969 case Builtin::BI__builtin_nondeterministic_value: {
2970 if (SemaBuiltinNonDeterministicValue(TheCall))
2977 case Builtin::BI__builtin_elementwise_abs: {
2978 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2985 EltTy = VecTy->getElementType();
2988 diag::err_builtin_invalid_arg_type)
2997 case Builtin::BI__builtin_elementwise_ceil:
2998 case Builtin::BI__builtin_elementwise_cos:
2999 case Builtin::BI__builtin_elementwise_exp:
3000 case Builtin::BI__builtin_elementwise_exp2:
3001 case Builtin::BI__builtin_elementwise_floor:
3002 case Builtin::BI__builtin_elementwise_log:
3003 case Builtin::BI__builtin_elementwise_log2:
3004 case Builtin::BI__builtin_elementwise_log10:
3005 case Builtin::BI__builtin_elementwise_roundeven:
3006 case Builtin::BI__builtin_elementwise_round:
3007 case Builtin::BI__builtin_elementwise_rint:
3008 case Builtin::BI__builtin_elementwise_nearbyint:
3009 case Builtin::BI__builtin_elementwise_sin:
3010 case Builtin::BI__builtin_elementwise_sqrt:
3011 case Builtin::BI__builtin_elementwise_trunc:
3012 case Builtin::BI__builtin_elementwise_canonicalize: {
3013 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3022 case Builtin::BI__builtin_elementwise_fma: {
3023 if (SemaBuiltinElementwiseTernaryMath(TheCall))
3030 case Builtin::BI__builtin_elementwise_pow: {
3031 if (SemaBuiltinElementwiseMath(TheCall))
3045 case Builtin::BI__builtin_elementwise_add_sat:
3046 case Builtin::BI__builtin_elementwise_sub_sat: {
3047 if (SemaBuiltinElementwiseMath(TheCall))
3055 EltTy = VecTy->getElementType();
3065 case Builtin::BI__builtin_elementwise_min:
3066 case Builtin::BI__builtin_elementwise_max:
3067 if (SemaBuiltinElementwiseMath(TheCall))
3071 case Builtin::BI__builtin_elementwise_bitreverse: {
3072 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3080 EltTy = VecTy->getElementType();
3090 case Builtin::BI__builtin_elementwise_copysign: {
3110 diag::err_typecheck_call_different_arg_types)
3111 << MagnitudeTy << SignTy;
3119 case Builtin::BI__builtin_reduce_max:
3120 case Builtin::BI__builtin_reduce_min: {
3121 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3132 TheCall->
setType(TyA->getElementType());
3138 case Builtin::BI__builtin_reduce_add:
3139 case Builtin::BI__builtin_reduce_mul:
3140 case Builtin::BI__builtin_reduce_xor:
3141 case Builtin::BI__builtin_reduce_or:
3142 case Builtin::BI__builtin_reduce_and: {
3143 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3148 if (!TyA || !TyA->getElementType()->isIntegerType()) {
3153 TheCall->
setType(TyA->getElementType());
3157 case Builtin::BI__builtin_matrix_transpose:
3158 return SemaBuiltinMatrixTranspose(TheCall, TheCallResult);
3160 case Builtin::BI__builtin_matrix_column_major_load:
3161 return SemaBuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
3163 case Builtin::BI__builtin_matrix_column_major_store:
3164 return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
3166 case Builtin::BI__builtin_get_device_side_mangled_name: {
3167 auto Check = [](
CallExpr *TheCall) {
3173 auto *D = DRE->getDecl();
3174 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
3176 return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
3177 D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
3179 if (!Check(TheCall)) {
3181 diag::err_hip_invalid_args_builtin_mangled_name);
3186 case Builtin::BI__builtin_popcountg:
3200 "Aux Target Builtin, but not an aux target?");
3202 if (CheckTSBuiltinFunctionCall(
3213 return TheCallResult;
3217static unsigned RFT(
unsigned t,
bool shift =
false,
bool ForceQuad =
false) {
3219 int IsQuad = ForceQuad ?
true :
Type.isQuad();
3220 switch (
Type.getEltType()) {
3223 return shift ? 7 : (8 << IsQuad) - 1;
3226 return shift ? 15 : (4 << IsQuad) - 1;
3228 return shift ? 31 : (2 << IsQuad) - 1;
3231 return shift ? 63 : (1 << IsQuad) - 1;
3233 return shift ? 127 : (1 << IsQuad) - 1;
3235 assert(!shift &&
"cannot shift float types!");
3236 return (4 << IsQuad) - 1;
3238 assert(!shift &&
"cannot shift float types!");
3239 return (2 << IsQuad) - 1;
3241 assert(!shift &&
"cannot shift float types!");
3242 return (1 << IsQuad) - 1;
3244 assert(!shift &&
"cannot shift float types!");
3245 return (4 << IsQuad) - 1;
3247 llvm_unreachable(
"Invalid NeonTypeFlag!");
3254 bool IsPolyUnsigned,
bool IsInt64Long) {
3288 llvm_unreachable(
"Invalid NeonTypeFlag!");
3312bool Sema::ParseSVEImmChecks(
3315 bool HasError =
false;
3316 for (
auto &I : ImmChecks) {
3317 int ArgNum, CheckTy, ElementSizeInBits;
3318 std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;
3324 auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
3325 int ErrDiag) ->
bool {
3333 if (SemaBuiltinConstantArg(TheCall, ArgNum, Imm))
3336 if (!CheckImm(Imm.getSExtValue()))
3342 case SVETypeFlags::ImmCheck0_31:
3343 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
3346 case SVETypeFlags::ImmCheck0_13:
3347 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
3350 case SVETypeFlags::ImmCheck1_16:
3351 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
3354 case SVETypeFlags::ImmCheck0_7:
3355 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
3358 case SVETypeFlags::ImmCheck1_1:
3359 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 1))
3362 case SVETypeFlags::ImmCheck1_3:
3363 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 3))
3366 case SVETypeFlags::ImmCheck1_7:
3367 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 7))
3370 case SVETypeFlags::ImmCheckExtract:
3371 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3372 (2048 / ElementSizeInBits) - 1))
3375 case SVETypeFlags::ImmCheckShiftRight:
3376 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
3379 case SVETypeFlags::ImmCheckShiftRightNarrow:
3380 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1,
3381 ElementSizeInBits / 2))
3384 case SVETypeFlags::ImmCheckShiftLeft:
3385 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3386 ElementSizeInBits - 1))
3389 case SVETypeFlags::ImmCheckLaneIndex:
3390 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3391 (128 / (1 * ElementSizeInBits)) - 1))
3394 case SVETypeFlags::ImmCheckLaneIndexCompRotate:
3395 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3396 (128 / (2 * ElementSizeInBits)) - 1))
3399 case SVETypeFlags::ImmCheckLaneIndexDot:
3400 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3401 (128 / (4 * ElementSizeInBits)) - 1))
3404 case SVETypeFlags::ImmCheckComplexRot90_270:
3405 if (CheckImmediateInSet([](
int64_t V) {
return V == 90 ||
V == 270; },
3406 diag::err_rotation_argument_to_cadd))
3409 case SVETypeFlags::ImmCheckComplexRotAll90:
3410 if (CheckImmediateInSet(
3412 return V == 0 ||
V == 90 ||
V == 180 ||
V == 270;
3414 diag::err_rotation_argument_to_cmla))
3417 case SVETypeFlags::ImmCheck0_1:
3418 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
3421 case SVETypeFlags::ImmCheck0_2:
3422 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
3425 case SVETypeFlags::ImmCheck0_3:
3426 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
3429 case SVETypeFlags::ImmCheck0_0:
3430 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 0))
3433 case SVETypeFlags::ImmCheck0_15:
3434 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 15))
3437 case SVETypeFlags::ImmCheck0_255:
3438 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 255))
3441 case SVETypeFlags::ImmCheck2_4_Mul2:
3442 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 2, 4) ||
3443 SemaBuiltinConstantArgMultiple(TheCall, ArgNum, 2))
3453 if (FD->
hasAttr<ArmLocallyStreamingAttr>())
3470 llvm::StringMap<bool> CallerFeatureMap;
3479 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3485 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3491 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3500 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZA());
3507 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZT0());
3511 switch (BuiltinID) {
3514#define GET_SME_BUILTIN_GET_STATE
3515#include "clang/Basic/arm_sme_builtins_za_state.inc"
3516#undef GET_SME_BUILTIN_GET_STATE
3520bool Sema::CheckSMEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3524 switch (BuiltinID) {
3525#define GET_SME_STREAMING_ATTRS
3526#include "clang/Basic/arm_sme_streaming_attrs.inc"
3527#undef GET_SME_STREAMING_ATTRS
3535 diag::warn_attribute_arm_za_builtin_no_za_state)
3540 diag::warn_attribute_arm_zt0_builtin_no_zt0_state)
3547 switch (BuiltinID) {
3550#define GET_SME_IMMEDIATE_CHECK
3551#include "clang/Basic/arm_sme_sema_rangechecks.inc"
3552#undef GET_SME_IMMEDIATE_CHECK
3555 return ParseSVEImmChecks(TheCall, ImmChecks);
3558bool Sema::CheckSVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3562 switch (BuiltinID) {
3563#define GET_SVE_STREAMING_ATTRS
3564#include "clang/Basic/arm_sve_streaming_attrs.inc"
3565#undef GET_SVE_STREAMING_ATTRS
3573 switch (BuiltinID) {
3576#define GET_SVE_IMMEDIATE_CHECK
3577#include "clang/Basic/arm_sve_sema_rangechecks.inc"
3578#undef GET_SVE_IMMEDIATE_CHECK
3581 return ParseSVEImmChecks(TheCall, ImmChecks);
3584bool Sema::CheckNeonBuiltinFunctionCall(
const TargetInfo &TI,
3585 unsigned BuiltinID,
CallExpr *TheCall) {
3588 switch (BuiltinID) {
3591#define GET_NEON_BUILTINS
3592#define TARGET_BUILTIN(id, ...) case NEON::BI##id:
3593#define BUILTIN(id, ...) case NEON::BI##id:
3594#include "clang/Basic/arm_neon.inc"
3597#undef TARGET_BUILTIN
3599#undef GET_NEON_BUILTINS
3607 bool HasConstPtr =
false;
3608 switch (BuiltinID) {
3609#define GET_NEON_OVERLOAD_CHECK
3610#include "clang/Basic/arm_neon.inc"
3611#include "clang/Basic/arm_fp16.inc"
3612#undef GET_NEON_OVERLOAD_CHECK
3619 if (SemaBuiltinConstantArg(TheCall, ImmArg,
Result))
3622 TV =
Result.getLimitedValue(64);
3623 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3628 if (PtrArgNum >= 0) {
3632 Arg = ICE->getSubExpr();
3636 llvm::Triple::ArchType Arch = TI.
getTriple().getArch();
3637 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3638 Arch == llvm::Triple::aarch64_32 ||
3639 Arch == llvm::Triple::aarch64_be;
3657 unsigned i = 0, l = 0, u = 0;
3658 switch (BuiltinID) {
3661 #define GET_NEON_IMMEDIATE_CHECK
3662 #include "clang/Basic/arm_neon.inc"
3663 #include "clang/Basic/arm_fp16.inc"
3664 #undef GET_NEON_IMMEDIATE_CHECK
3667 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
3670bool Sema::CheckMVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3671 switch (BuiltinID) {
3674 #include "clang/Basic/arm_mve_builtin_sema.inc"
3678bool Sema::CheckCDEBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3681 switch (BuiltinID) {
3684#include "clang/Basic/arm_cde_builtin_sema.inc"
3690 return CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
true);
3693bool Sema::CheckARMCoprocessorImmediate(
const TargetInfo &TI,
3694 const Expr *CoprocArg,
bool WantCDE) {
3703 int64_t CoprocNo = CoprocNoAP.getExtValue();
3704 assert(CoprocNo >= 0 &&
"Coprocessor immediate must be non-negative");
3707 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3709 if (IsCDECoproc != WantCDE)
3716bool Sema::CheckARMBuiltinExclusiveCall(
unsigned BuiltinID,
CallExpr *TheCall,
3717 unsigned MaxWidth) {
3718 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3719 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3720 BuiltinID == ARM::BI__builtin_arm_strex ||
3721 BuiltinID == ARM::BI__builtin_arm_stlex ||
3722 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3723 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3724 BuiltinID == AArch64::BI__builtin_arm_strex ||
3725 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3726 "unexpected ARM builtin");
3727 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3728 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3729 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3730 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3742 Expr *PointerArg = TheCall->
getArg(IsLdrex ? 0 : 1);
3746 PointerArg = PointerArgRes.
get();
3766 CastNeeded = CK_BitCast;
3767 Diag(DRE->
getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3777 PointerArg = PointerArgRes.
get();
3779 TheCall->
setArg(IsLdrex ? 0 : 1, PointerArg);
3784 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3791 assert(MaxWidth == 64 &&
"Diagnostic unexpectedly inaccurate");
3792 Diag(DRE->
getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3831bool Sema::CheckARMBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3833 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3834 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3835 BuiltinID == ARM::BI__builtin_arm_strex ||
3836 BuiltinID == ARM::BI__builtin_arm_stlex) {
3837 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3840 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3841 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3842 SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
3845 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3846 BuiltinID == ARM::BI__builtin_arm_wsr64)
3847 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3,
false);
3849 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3850 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3851 BuiltinID == ARM::BI__builtin_arm_wsr ||
3852 BuiltinID == ARM::BI__builtin_arm_wsrp)
3853 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3855 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3857 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3859 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3865 switch (BuiltinID) {
3866 default:
return false;
3867 case ARM::BI__builtin_arm_ssat:
3868 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 32);
3869 case ARM::BI__builtin_arm_usat:
3870 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
3871 case ARM::BI__builtin_arm_ssat16:
3872 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
3873 case ARM::BI__builtin_arm_usat16:
3874 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
3875 case ARM::BI__builtin_arm_vcvtr_f:
3876 case ARM::BI__builtin_arm_vcvtr_d:
3877 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
3878 case ARM::BI__builtin_arm_dmb:
3879 case ARM::BI__builtin_arm_dsb:
3880 case ARM::BI__builtin_arm_isb:
3881 case ARM::BI__builtin_arm_dbg:
3882 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15);
3883 case ARM::BI__builtin_arm_cdp:
3884 case ARM::BI__builtin_arm_cdp2:
3885 case ARM::BI__builtin_arm_mcr:
3886 case ARM::BI__builtin_arm_mcr2:
3887 case ARM::BI__builtin_arm_mrc:
3888 case ARM::BI__builtin_arm_mrc2:
3889 case ARM::BI__builtin_arm_mcrr:
3890 case ARM::BI__builtin_arm_mcrr2:
3891 case ARM::BI__builtin_arm_mrrc:
3892 case ARM::BI__builtin_arm_mrrc2:
3893 case ARM::BI__builtin_arm_ldc:
3894 case ARM::BI__builtin_arm_ldcl:
3895 case ARM::BI__builtin_arm_ldc2:
3896 case ARM::BI__builtin_arm_ldc2l:
3897 case ARM::BI__builtin_arm_stc:
3898 case ARM::BI__builtin_arm_stcl:
3899 case ARM::BI__builtin_arm_stc2:
3900 case ARM::BI__builtin_arm_stc2l:
3901 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15) ||
3902 CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
3907bool Sema::CheckAArch64BuiltinFunctionCall(
const TargetInfo &TI,
3910 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3911 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3912 BuiltinID == AArch64::BI__builtin_arm_strex ||
3913 BuiltinID == AArch64::BI__builtin_arm_stlex) {
3914 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
3917 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
3918 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3919 SemaBuiltinConstantArgRange(TheCall, 2, 0, 3) ||
3920 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
3921 SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
3924 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
3925 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
3926 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
3927 BuiltinID == AArch64::BI__builtin_arm_wsr128)
3928 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3931 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
3932 BuiltinID == AArch64::BI__builtin_arm_addg ||
3933 BuiltinID == AArch64::BI__builtin_arm_gmi ||
3934 BuiltinID == AArch64::BI__builtin_arm_ldg ||
3935 BuiltinID == AArch64::BI__builtin_arm_stg ||
3936 BuiltinID == AArch64::BI__builtin_arm_subp) {
3937 return SemaBuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
3940 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
3941 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
3942 BuiltinID == AArch64::BI__builtin_arm_wsr ||
3943 BuiltinID == AArch64::BI__builtin_arm_wsrp)
3944 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3949 if (BuiltinID == AArch64::BI_ReadStatusReg ||
3950 BuiltinID == AArch64::BI_WriteStatusReg)
3951 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
3953 if (BuiltinID == AArch64::BI__getReg)
3954 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
3956 if (BuiltinID == AArch64::BI__break)
3957 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
3959 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3962 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
3965 if (CheckSMEBuiltinFunctionCall(BuiltinID, TheCall))
3970 unsigned i = 0, l = 0, u = 0;
3971 switch (BuiltinID) {
3972 default:
return false;
3973 case AArch64::BI__builtin_arm_dmb:
3974 case AArch64::BI__builtin_arm_dsb:
3975 case AArch64::BI__builtin_arm_isb: l = 0; u = 15;
break;
3976 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535;
break;
3979 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
4016 if (!RT->getDecl()->getDeclName().isEmpty())
4019 if (!ET->getDecl()->getDeclName().isEmpty())
4035 const auto *UO = dyn_cast<UnaryOperator>(Arg->
IgnoreParens());
4039 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
4042 if (CE->getCastKind() != CK_IntegralToPointer &&
4043 CE->getCastKind() != CK_NullToPointer)
4047 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
4052 dyn_cast<EnumConstantDecl>(DR->getDecl());
4063 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
4066bool Sema::CheckBPFBuiltinFunctionCall(
unsigned BuiltinID,
4068 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
4069 BuiltinID == BPF::BI__builtin_btf_type_id ||
4070 BuiltinID == BPF::BI__builtin_preserve_type_info ||
4071 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
4072 "unexpected BPF builtin");
4082 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
4083 kind = diag::err_preserve_field_info_not_const;
4084 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
4085 kind = diag::err_btf_type_id_not_const;
4086 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
4087 kind = diag::err_preserve_type_info_not_const;
4089 kind = diag::err_preserve_enum_value_not_const;
4095 Arg = TheCall->
getArg(0);
4096 bool InvalidArg =
false;
4097 bool ReturnUnsignedInt =
true;
4098 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
4101 kind = diag::err_preserve_field_info_not_field;
4103 }
else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
4106 kind = diag::err_preserve_type_info_invalid;
4108 }
else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
4111 kind = diag::err_preserve_enum_value_invalid;
4113 ReturnUnsignedInt =
false;
4114 }
else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
4115 ReturnUnsignedInt =
false;
4123 if (ReturnUnsignedInt)
4130bool Sema::CheckHexagonBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4143 { Hexagon::BI__builtin_circ_ldd, {{ 3,
true, 4, 3 }} },
4144 { Hexagon::BI__builtin_circ_ldw, {{ 3,
true, 4, 2 }} },
4145 { Hexagon::BI__builtin_circ_ldh, {{ 3,
true, 4, 1 }} },
4146 { Hexagon::BI__builtin_circ_lduh, {{ 3,
true, 4, 1 }} },
4147 { Hexagon::BI__builtin_circ_ldb, {{ 3,
true, 4, 0 }} },
4148 { Hexagon::BI__builtin_circ_ldub, {{ 3,
true, 4, 0 }} },
4149 { Hexagon::BI__builtin_circ_std, {{ 3,
true, 4, 3 }} },
4150 { Hexagon::BI__builtin_circ_stw, {{ 3,
true, 4, 2 }} },
4151 { Hexagon::BI__builtin_circ_sth, {{ 3,
true, 4, 1 }} },
4152 { Hexagon::BI__builtin_circ_sthhi, {{ 3,
true, 4, 1 }} },
4153 { Hexagon::BI__builtin_circ_stb, {{ 3,
true, 4, 0 }} },
4155 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1,
true, 4, 0 }} },
4156 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1,
true, 4, 0 }} },
4157 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1,
true, 4, 1 }} },
4158 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1,
true, 4, 1 }} },
4159 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1,
true, 4, 2 }} },
4160 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1,
true, 4, 3 }} },
4161 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1,
true, 4, 0 }} },
4162 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1,
true, 4, 1 }} },
4163 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1,
true, 4, 1 }} },
4164 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1,
true, 4, 2 }} },
4165 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1,
true, 4, 3 }} },
4167 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1,
true, 8, 0 }} },
4168 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1,
false, 16, 0 }} },
4169 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1,
false, 16, 0 }} },
4170 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0,
true, 8, 0 }} },
4171 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1,
false, 5, 0 }} },
4172 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1,
false, 8, 0 }} },
4173 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1,
true, 8, 0 }} },
4174 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1,
false, 5, 0 }} },
4175 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1,
false, 5, 0 }} },
4176 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1,
false, 5, 0 }} },
4177 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1,
false, 8, 0 }} },
4178 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1,
true, 8, 0 }} },
4179 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1,
false, 7, 0 }} },
4180 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1,
true, 8, 0 }} },
4181 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1,
true, 8, 0 }} },
4182 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1,
false, 7, 0 }} },
4183 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1,
true, 8, 0 }} },
4184 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1,
true, 8, 0 }} },
4185 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1,
false, 7, 0 }} },
4186 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1,
false, 6, 0 }} },
4187 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2,
true, 8, 0 }} },
4188 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1,
false, 6, 0 }} },
4189 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1,
false, 5, 0 }} },
4190 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0,
false, 10, 0 }} },
4191 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0,
false, 10, 0 }} },
4192 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1,
false, 5, 0 }} },
4193 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0,
false, 10, 0 }} },
4194 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0,
false, 10, 0 }} },
4195 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2,
false, 6, 0 }} },
4196 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1,
false, 6, 2 }} },
4197 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2,
false, 3, 0 }} },
4198 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2,
false, 6, 0 }} },
4199 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2,
false, 6, 0 }} },
4200 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1,
false, 6, 0 }} },
4201 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2,
false, 6, 0 }} },
4202 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2,
false, 6, 0 }} },
4203 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2,
false, 6, 0 }} },
4204 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2,
false, 5, 0 }} },
4205 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2,
false, 5, 0 }} },
4206 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1,
false, 5, 0 }} },
4207 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2,
false, 5, 0 }} },
4208 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2,
false, 5, 0 }} },
4209 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1,
false, 5, 0 }} },
4210 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2,
false, 5, 0 }} },
4211 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1,
false, 4, 0 }} },
4212 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1,
false, 5, 0 }} },
4213 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2,
false, 6, 0 }} },
4214 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2,
false, 6, 0 }} },
4215 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1,
false, 6, 0 }} },
4216 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2,
false, 6, 0 }} },
4217 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2,
false, 6, 0 }} },
4218 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
4219 {{ 1,
false, 6, 0 }} },
4220 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1,
false, 6, 0 }} },
4221 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2,
false, 5, 0 }} },
4222 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2,
false, 5, 0 }} },
4223 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1,
false, 5, 0 }} },
4224 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2,
false, 5, 0 }} },
4225 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2,
false, 5, 0 }} },
4226 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
4227 {{ 1,
false, 5, 0 }} },
4228 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1,
false, 5, 0 }} },
4229 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1,
false, 5, 0 }} },
4230 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1,
false, 4, 0 }} },
4231 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1,
false, 5, 0 }} },
4232 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1,
false, 5, 0 }} },
4233 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1,
false, 5, 0 },
4234 { 2,
false, 5, 0 }} },
4235 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1,
false, 6, 0 },
4236 { 2,
false, 6, 0 }} },
4237 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2,
false, 5, 0 },
4238 { 3,
false, 5, 0 }} },
4239 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2,
false, 6, 0 },
4240 { 3,
false, 6, 0 }} },
4241 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2,
false, 6, 0 }} },
4242 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2,
false, 6, 0 }} },
4243 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1,
false, 6, 0 }} },
4244 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2,
false, 6, 0 }} },
4245 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2,
false, 6, 0 }} },
4246 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2,
false, 6, 0 }} },
4247 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2,
false, 5, 0 }} },
4248 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2,
false, 5, 0 }} },
4249 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1,
false, 5, 0 }} },
4250 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2,
false, 5, 0 }} },
4251 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2,
false, 5, 0 }} },
4252 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2,
false, 5, 0 }} },
4253 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1,
false, 4, 0 }} },
4254 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1,
false, 5, 0 }} },
4255 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1,
false, 5, 0 }} },
4256 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
4257 {{ 2,
false, 4, 0 },
4258 { 3,
false, 5, 0 }} },
4259 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
4260 {{ 2,
false, 4, 0 },
4261 { 3,
false, 5, 0 }} },
4262 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
4263 {{ 2,
false, 4, 0 },
4264 { 3,
false, 5, 0 }} },
4265 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
4266 {{ 2,
false, 4, 0 },
4267 { 3,
false, 5, 0 }} },
4268 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1,
false, 5, 0 }} },
4269 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1,
false, 5, 0 }} },
4270 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2,
false, 3, 0 }} },
4271 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2,
false, 3, 0 }} },
4272 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2,
false, 5, 0 }} },
4273 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2,
false, 5, 0 }} },
4274 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2,
false, 5, 0 }} },
4275 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2,
false, 5, 0 }} },
4276 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1,
true , 6, 0 }} },
4277 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1,
true, 6, 0 }} },
4278 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1,
false, 5, 0 },
4279 { 2,
false, 5, 0 }} },
4280 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1,
false, 6, 0 },
4281 { 2,
false, 6, 0 }} },
4282 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0,
true, 6, 0 }} },
4283 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1,
false, 5, 0 }} },
4284 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2,
false, 5, 0 }} },
4285 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2,
false, 5, 0 }} },
4286 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2,
false, 5, 0 }} },
4287 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2,
false, 5, 0 }} },
4288 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3,
false, 2, 0 }} },
4289 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2,
false, 2, 0 }} },
4290 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
4291 {{ 1,
false, 4, 0 }} },
4292 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1,
false, 4, 0 }} },
4293 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
4294 {{ 1,
false, 4, 0 }} },
4295 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1,
false, 6, 0 }} },
4296 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2,
false, 6, 0 }} },
4297 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2,
false, 6, 0 }} },
4298 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2,
false, 6, 0 }} },
4299 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2,
false, 6, 0 }} },
4300 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2,
false, 6, 0 }} },
4301 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1,
false, 5, 0 }} },
4302 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2,
false, 5, 0 }} },
4303 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2,
false, 5, 0 }} },
4304 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2,
false, 5, 0 }} },
4305 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2,
false, 5, 0 }} },
4306 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2,
false, 5, 0 }} },
4307 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2,
false, 3, 0 }} },
4308 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2,
false, 3, 0 }} },
4309 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2,
false, 3, 0 }} },
4310 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2,
false, 3, 0 }} },
4311 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2,
false, 1, 0 }} },
4312 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2,
false, 1, 0 }} },
4313 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3,
false, 1, 0 }} },
4314 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
4315 {{ 3,
false, 1, 0 }} },
4316 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2,
false, 1, 0 }} },
4317 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2,
false, 1, 0 }} },
4318 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3,
false, 1, 0 }} },
4319 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
4320 {{ 3,
false, 1, 0 }} },
4321 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2,
false, 1, 0 }} },
4322 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2,
false, 1, 0 }} },
4323 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3,
false, 1, 0 }} },
4324 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
4325 {{ 3,
false, 1, 0 }} },
4327 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2,
false, 2, 0 }} },
4328 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
4329 {{ 2,
false, 2, 0 }} },
4330 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
4331 {{ 3,
false, 2, 0 }} },
4332 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
4333 {{ 3,
false, 2, 0 }} },
4334 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2,
false, 2, 0 }} },
4335 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
4336 {{ 2,
false, 2, 0 }} },
4337 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
4338 {{ 3,
false, 2, 0 }} },
4339 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
4340 {{ 3,
false, 2, 0 }} },
4341 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2,
false, 3, 0 }} },
4342 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2,
false, 3, 0 }} },
4343 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3,
false, 3, 0 }} },
4344 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
4345 {{ 3,
false, 3, 0 }} },
4346 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2,
false, 3, 0 }} },
4347 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2,
false, 3, 0 }} },
4348 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3,
false, 3, 0 }} },
4349 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
4350 {{ 3,
false, 3, 0 }} },
4355 static const bool SortOnce =
4358 return LHS.BuiltinID < RHS.BuiltinID;
4364 Infos, [=](
const BuiltinInfo &BI) {
return BI.BuiltinID < BuiltinID; });
4365 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
4370 for (
const ArgInfo &A : F->Infos) {
4372 if (A.BitWidth == 0)
4375 int32_t
Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
4376 int32_t
Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
4378 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4380 unsigned M = 1 << A.Align;
4383 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4384 Error |= SemaBuiltinConstantArgMultiple(TheCall, A.OpNum, M);
4390bool Sema::CheckHexagonBuiltinFunctionCall(
unsigned BuiltinID,
4392 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
4395bool Sema::CheckLoongArchBuiltinFunctionCall(
const TargetInfo &TI,
4398 switch (BuiltinID) {
4402 case LoongArch::BI__builtin_loongarch_cacop_d:
4403 case LoongArch::BI__builtin_loongarch_cacop_w: {
4404 SemaBuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
4405 SemaBuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12),
4409 case LoongArch::BI__builtin_loongarch_break:
4410 case LoongArch::BI__builtin_loongarch_dbar:
4411 case LoongArch::BI__builtin_loongarch_ibar:
4412 case LoongArch::BI__builtin_loongarch_syscall:
4414 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 32767);
4415 case LoongArch::BI__builtin_loongarch_csrrd_w:
4416 case LoongArch::BI__builtin_loongarch_csrrd_d:
4417 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 16383);
4418 case LoongArch::BI__builtin_loongarch_csrwr_w:
4419 case LoongArch::BI__builtin_loongarch_csrwr_d:
4420 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 16383);
4421 case LoongArch::BI__builtin_loongarch_csrxchg_w:
4422 case LoongArch::BI__builtin_loongarch_csrxchg_d:
4423 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 16383);
4424 case LoongArch::BI__builtin_loongarch_lddir_d:
4425 case LoongArch::BI__builtin_loongarch_ldpte_d:
4426 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4427 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
4428 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
4429 return SemaBuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
4432 case LoongArch::BI__builtin_lsx_vbitclri_b:
4433 case LoongArch::BI__builtin_lsx_vbitrevi_b:
4434 case LoongArch::BI__builtin_lsx_vbitseti_b:
4435 case LoongArch::BI__builtin_lsx_vsat_b:
4436 case LoongArch::BI__builtin_lsx_vsat_bu:
4437 case LoongArch::BI__builtin_lsx_vslli_b:
4438 case LoongArch::BI__builtin_lsx_vsrai_b:
4439 case LoongArch::BI__builtin_lsx_vsrari_b:
4440 case LoongArch::BI__builtin_lsx_vsrli_b:
4441 case LoongArch::BI__builtin_lsx_vsllwil_h_b:
4442 case LoongArch::BI__builtin_lsx_vsllwil_hu_bu:
4443 case LoongArch::BI__builtin_lsx_vrotri_b:
4444 case LoongArch::BI__builtin_lsx_vsrlri_b:
4445 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 7);
4446 case LoongArch::BI__builtin_lsx_vbitclri_h:
4447 case LoongArch::BI__builtin_lsx_vbitrevi_h:
4448 case LoongArch::BI__builtin_lsx_vbitseti_h:
4449 case LoongArch::BI__builtin_lsx_vsat_h:
4450 case LoongArch::BI__builtin_lsx_vsat_hu:
4451 case LoongArch::BI__builtin_lsx_vslli_h:
4452 case LoongArch::BI__builtin_lsx_vsrai_h:
4453 case LoongArch::BI__builtin_lsx_vsrari_h:
4454 case LoongArch::BI__builtin_lsx_vsrli_h:
4455 case LoongArch::BI__builtin_lsx_vsllwil_w_h:
4456 case LoongArch::BI__builtin_lsx_vsllwil_wu_hu:
4457 case LoongArch::BI__builtin_lsx_vrotri_h:
4458 case LoongArch::BI__builtin_lsx_vsrlri_h:
4459 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
4460 case LoongArch::BI__builtin_lsx_vssrarni_b_h:
4461 case LoongArch::BI__builtin_lsx_vssrarni_bu_h:
4462 case LoongArch::BI__builtin_lsx_vssrani_b_h:
4463 case LoongArch::BI__builtin_lsx_vssrani_bu_h:
4464 case LoongArch::BI__builtin_lsx_vsrarni_b_h:
4465 case LoongArch::BI__builtin_lsx_vsrlni_b_h:
4466 case LoongArch::BI__builtin_lsx_vsrlrni_b_h:
4467 case LoongArch::BI__builtin_lsx_vssrlni_b_h:
4468 case LoongArch::BI__builtin_lsx_vssrlni_bu_h:
4469 case LoongArch::BI__builtin_lsx_vssrlrni_b_h:
4470 case LoongArch::BI__builtin_lsx_vssrlrni_bu_h:
4471 case LoongArch::BI__builtin_lsx_vsrani_b_h:
4472 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
4473 case LoongArch::BI__builtin_lsx_vslei_bu:
4474 case LoongArch::BI__builtin_lsx_vslei_hu:
4475 case LoongArch::BI__builtin_lsx_vslei_wu:
4476 case LoongArch::BI__builtin_lsx_vslei_du:
4477 case LoongArch::BI__builtin_lsx_vslti_bu:
4478 case LoongArch::BI__builtin_lsx_vslti_hu:
4479 case LoongArch::BI__builtin_lsx_vslti_wu:
4480 case LoongArch::BI__builtin_lsx_vslti_du:
4481 case LoongArch::BI__builtin_lsx_vmaxi_bu:
4482 case LoongArch::BI__builtin_lsx_vmaxi_hu:
4483 case LoongArch::BI__builtin_lsx_vmaxi_wu:
4484 case LoongArch::BI__builtin_lsx_vmaxi_du:
4485 case LoongArch::BI__builtin_lsx_vmini_bu:
4486 case LoongArch::BI__builtin_lsx_vmini_hu:
4487 case LoongArch::BI__builtin_lsx_vmini_wu:
4488 case LoongArch::BI__builtin_lsx_vmini_du:
4489 case LoongArch::BI__builtin_lsx_vaddi_bu:
4490 case LoongArch::BI__builtin_lsx_vaddi_hu:
4491 case LoongArch::BI__builtin_lsx_vaddi_wu:
4492 case LoongArch::BI__builtin_lsx_vaddi_du:
4493 case LoongArch::BI__builtin_lsx_vbitclri_w:
4494 case LoongArch::BI__builtin_lsx_vbitrevi_w:
4495 case LoongArch::BI__builtin_lsx_vbitseti_w:
4496 case LoongArch::BI__builtin_lsx_vsat_w:
4497 case LoongArch::BI__builtin_lsx_vsat_wu:
4498 case LoongArch::BI__builtin_lsx_vslli_w:
4499 case LoongArch::BI__builtin_lsx_vsrai_w:
4500 case LoongArch::BI__builtin_lsx_vsrari_w:
4501 case LoongArch::BI__builtin_lsx_vsrli_w:
4502 case LoongArch::BI__builtin_lsx_vsllwil_d_w:
4503 case LoongArch::BI__builtin_lsx_vsllwil_du_wu:
4504 case LoongArch::BI__builtin_lsx_vsrlri_w:
4505 case LoongArch::BI__builtin_lsx_vrotri_w:
4506 case LoongArch::BI__builtin_lsx_vsubi_bu:
4507 case LoongArch::BI__builtin_lsx_vsubi_hu:
4508 case LoongArch::BI__builtin_lsx_vbsrl_v:
4509 case LoongArch::BI__builtin_lsx_vbsll_v:
4510 case LoongArch::BI__builtin_lsx_vsubi_wu:
4511 case LoongArch::BI__builtin_lsx_vsubi_du:
4512 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4513 case LoongArch::BI__builtin_lsx_vssrarni_h_w:
4514 case LoongArch::BI__builtin_lsx_vssrarni_hu_w:
4515 case LoongArch::BI__builtin_lsx_vssrani_h_w:
4516 case LoongArch::BI__builtin_lsx_vssrani_hu_w:
4517 case LoongArch::BI__builtin_lsx_vsrarni_h_w:
4518 case LoongArch::BI__builtin_lsx_vsrani_h_w:
4519 case LoongArch::BI__builtin_lsx_vfrstpi_b:
4520 case LoongArch::BI__builtin_lsx_vfrstpi_h:
4521 case LoongArch::BI__builtin_lsx_vsrlni_h_w:
4522 case LoongArch::BI__builtin_lsx_vsrlrni_h_w:
4523 case LoongArch::BI__builtin_lsx_vssrlni_h_w:
4524 case LoongArch::BI__builtin_lsx_vssrlni_hu_w:
4525 case LoongArch::BI__builtin_lsx_vssrlrni_h_w:
4526 case LoongArch::BI__builtin_lsx_vssrlrni_hu_w:
4527 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4528 case LoongArch::BI__builtin_lsx_vbitclri_d:
4529 case LoongArch::BI__builtin_lsx_vbitrevi_d:
4530 case LoongArch::BI__builtin_lsx_vbitseti_d:
4531 case LoongArch::BI__builtin_lsx_vsat_d:
4532 case LoongArch::BI__builtin_lsx_vsat_du:
4533 case LoongArch::BI__builtin_lsx_vslli_d:
4534 case LoongArch::BI__builtin_lsx_vsrai_d:
4535 case LoongArch::BI__builtin_lsx_vsrli_d:
4536 case LoongArch::BI__builtin_lsx_vsrari_d:
4537 case LoongArch::BI__builtin_lsx_vrotri_d:
4538 case LoongArch::BI__builtin_lsx_vsrlri_d:
4539 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 63);
4540 case LoongArch::BI__builtin_lsx_vssrarni_w_d:
4541 case LoongArch::BI__builtin_lsx_vssrarni_wu_d:
4542 case LoongArch::BI__builtin_lsx_vssrani_w_d:
4543 case LoongArch::BI__builtin_lsx_vssrani_wu_d:
4544 case LoongArch::BI__builtin_lsx_vsrarni_w_d:
4545 case LoongArch::BI__builtin_lsx_vsrlni_w_d:
4546 case LoongArch::BI__builtin_lsx_vsrlrni_w_d:
4547 case LoongArch::BI__builtin_lsx_vssrlni_w_d:
4548 case LoongArch::BI__builtin_lsx_vssrlni_wu_d:
4549 case LoongArch::BI__builtin_lsx_vssrlrni_w_d:
4550 case LoongArch::BI__builtin_lsx_vssrlrni_wu_d:
4551 case LoongArch::BI__builtin_lsx_vsrani_w_d:
4552 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 63);
4553 case LoongArch::BI__builtin_lsx_vssrarni_d_q:
4554 case LoongArch::BI__builtin_lsx_vssrarni_du_q:
4555 case LoongArch::BI__builtin_lsx_vssrani_d_q:
4556 case LoongArch::BI__builtin_lsx_vssrani_du_q:
4557 case LoongArch::BI__builtin_lsx_vsrarni_d_q:
4558 case LoongArch::BI__builtin_lsx_vssrlni_d_q:
4559 case LoongArch::BI__builtin_lsx_vssrlni_du_q:
4560 case LoongArch::BI__builtin_lsx_vssrlrni_d_q:
4561 case LoongArch::BI__builtin_lsx_vssrlrni_du_q:
4562 case LoongArch::BI__builtin_lsx_vsrani_d_q:
4563 case LoongArch::BI__builtin_lsx_vsrlrni_d_q:
4564 case LoongArch::BI__builtin_lsx_vsrlni_d_q:
4565 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 127);
4566 case LoongArch::BI__builtin_lsx_vseqi_b:
4567 case LoongArch::BI__builtin_lsx_vseqi_h:
4568 case LoongArch::BI__builtin_lsx_vseqi_w:
4569 case LoongArch::BI__builtin_lsx_vseqi_d:
4570 case LoongArch::BI__builtin_lsx_vslti_b:
4571 case LoongArch::BI__builtin_lsx_vslti_h:
4572 case LoongArch::BI__builtin_lsx_vslti_w:
4573 case LoongArch::BI__builtin_lsx_vslti_d:
4574 case LoongArch::BI__builtin_lsx_vslei_b:
4575 case LoongArch::BI__builtin_lsx_vslei_h:
4576 case LoongArch::BI__builtin_lsx_vslei_w:
4577 case LoongArch::BI__builtin_lsx_vslei_d:
4578 case LoongArch::BI__builtin_lsx_vmaxi_b:
4579 case LoongArch::BI__builtin_lsx_vmaxi_h:
4580 case LoongArch::BI__builtin_lsx_vmaxi_w:
4581 case LoongArch::BI__builtin_lsx_vmaxi_d:
4582 case LoongArch::BI__builtin_lsx_vmini_b:
4583 case LoongArch::BI__builtin_lsx_vmini_h:
4584 case LoongArch::BI__builtin_lsx_vmini_w:
4585 case LoongArch::BI__builtin_lsx_vmini_d:
4586 return SemaBuiltinConstantArgRange(TheCall, 1, -16, 15);
4587 case LoongArch::BI__builtin_lsx_vandi_b:
4588 case LoongArch::BI__builtin_lsx_vnori_b:
4589 case LoongArch::BI__builtin_lsx_vori_b:
4590 case LoongArch::BI__builtin_lsx_vshuf4i_b:
4591 case LoongArch::BI__builtin_lsx_vshuf4i_h:
4592 case LoongArch::BI__builtin_lsx_vshuf4i_w:
4593 case LoongArch::BI__builtin_lsx_vxori_b:
4594 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 255);
4595 case LoongArch::BI__builtin_lsx_vbitseli_b:
4596 case LoongArch::BI__builtin_lsx_vshuf4i_d:
4597 case LoongArch::BI__builtin_lsx_vextrins_b:
4598 case LoongArch::BI__builtin_lsx_vextrins_h:
4599 case LoongArch::BI__builtin_lsx_vextrins_w:
4600 case LoongArch::BI__builtin_lsx_vextrins_d:
4601 case LoongArch::BI__builtin_lsx_vpermi_w:
4602 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 255);
4603 case LoongArch::BI__builtin_lsx_vpickve2gr_b:
4604 case LoongArch::BI__builtin_lsx_vpickve2gr_bu:
4605 case LoongArch::BI__builtin_lsx_vreplvei_b:
4606 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
4607 case LoongArch::BI__builtin_lsx_vinsgr2vr_b:
4608 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
4609 case LoongArch::BI__builtin_lsx_vpickve2gr_h:
4610 case LoongArch::BI__builtin_lsx_vpickve2gr_hu:
4611 case LoongArch::BI__builtin_lsx_vreplvei_h:
4612 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 7);
4613 case LoongArch::BI__builtin_lsx_vinsgr2vr_h:
4614 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
4615 case LoongArch::BI__builtin_lsx_vpickve2gr_w:
4616 case LoongArch::BI__builtin_lsx_vpickve2gr_wu:
4617 case LoongArch::BI__builtin_lsx_vreplvei_w:
4618 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
4619 case LoongArch::BI__builtin_lsx_vinsgr2vr_w:
4620 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4621 case LoongArch::BI__builtin_lsx_vpickve2gr_d:
4622 case LoongArch::BI__builtin_lsx_vpickve2gr_du:
4623 case LoongArch::BI__builtin_lsx_vreplvei_d:
4624 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
4625 case LoongArch::BI__builtin_lsx_vinsgr2vr_d:
4626 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
4627 case LoongArch::BI__builtin_lsx_vstelm_b:
4628 return SemaBuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4629 SemaBuiltinConstantArgRange(TheCall, 3, 0, 15);
4630 case LoongArch::BI__builtin_lsx_vstelm_h:
4631 return SemaBuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4632 SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
4633 case LoongArch::BI__builtin_lsx_vstelm_w:
4634 return SemaBuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4635 SemaBuiltinConstantArgRange(TheCall, 3, 0, 3);
4636 case LoongArch::BI__builtin_lsx_vstelm_d:
4637 return SemaBuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4638 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1);
4639 case LoongArch::BI__builtin_lsx_vldrepl_b:
4640 case LoongArch::BI__builtin_lsx_vld:
4641 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4642 case LoongArch::BI__builtin_lsx_vldrepl_h:
4643 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4644 case LoongArch::BI__builtin_lsx_vldrepl_w:
4645 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4646 case LoongArch::BI__builtin_lsx_vldrepl_d:
4647 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4648 case LoongArch::BI__builtin_lsx_vst:
4649 return SemaBuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4650 case LoongArch::BI__builtin_lsx_vldi:
4651 return SemaBuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4652 case LoongArch::BI__builtin_lsx_vrepli_b:
4653 case LoongArch::BI__builtin_lsx_vrepli_h:
4654 case LoongArch::BI__builtin_lsx_vrepli_w:
4655 case LoongArch::BI__builtin_lsx_vrepli_d:
4656 return SemaBuiltinConstantArgRange(TheCall, 0, -512, 511);
4659 case LoongArch::BI__builtin_lasx_xvbitclri_b:
4660 case LoongArch::BI__builtin_lasx_xvbitrevi_b:
4661 case LoongArch::BI__builtin_lasx_xvbitseti_b:
4662 case LoongArch::BI__builtin_lasx_xvsat_b:
4663 case LoongArch::BI__builtin_lasx_xvsat_bu:
4664 case LoongArch::BI__builtin_lasx_xvslli_b:
4665 case LoongArch::BI__builtin_lasx_xvsrai_b:
4666 case LoongArch::BI__builtin_lasx_xvsrari_b:
4667 case LoongArch::BI__builtin_lasx_xvsrli_b:
4668 case LoongArch::BI__builtin_lasx_xvsllwil_h_b:
4669 case LoongArch::BI__builtin_lasx_xvsllwil_hu_bu:
4670 case LoongArch::BI__builtin_lasx_xvrotri_b:
4671 case LoongArch::BI__builtin_lasx_xvsrlri_b:
4672 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 7);
4673 case LoongArch::BI__builtin_lasx_xvbitclri_h:
4674 case LoongArch::BI__builtin_lasx_xvbitrevi_h:
4675 case LoongArch::BI__builtin_lasx_xvbitseti_h:
4676 case LoongArch::BI__builtin_lasx_xvsat_h:
4677 case LoongArch::BI__builtin_lasx_xvsat_hu:
4678 case LoongArch::BI__builtin_lasx_xvslli_h:
4679 case LoongArch::BI__builtin_lasx_xvsrai_h:
4680 case LoongArch::BI__builtin_lasx_xvsrari_h:
4681 case LoongArch::BI__builtin_lasx_xvsrli_h:
4682 case LoongArch::BI__builtin_lasx_xvsllwil_w_h:
4683 case LoongArch::BI__builtin_lasx_xvsllwil_wu_hu:
4684 case LoongArch::BI__builtin_lasx_xvrotri_h:
4685 case LoongArch::BI__builtin_lasx_xvsrlri_h:
4686 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
4687 case LoongArch::BI__builtin_lasx_xvssrarni_b_h:
4688 case LoongArch::BI__builtin_lasx_xvssrarni_bu_h:
4689 case LoongArch::BI__builtin_lasx_xvssrani_b_h:
4690 case LoongArch::BI__builtin_lasx_xvssrani_bu_h:
4691 case LoongArch::BI__builtin_lasx_xvsrarni_b_h:
4692 case LoongArch::BI__builtin_lasx_xvsrlni_b_h:
4693 case LoongArch::BI__builtin_lasx_xvsrlrni_b_h:
4694 case LoongArch::BI__builtin_lasx_xvssrlni_b_h:
4695 case LoongArch::BI__builtin_lasx_xvssrlni_bu_h:
4696 case LoongArch::BI__builtin_lasx_xvssrlrni_b_h:
4697 case LoongArch::BI__builtin_lasx_xvssrlrni_bu_h:
4698 case LoongArch::BI__builtin_lasx_xvsrani_b_h:
4699 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
4700 case LoongArch::BI__builtin_lasx_xvslei_bu:
4701 case LoongArch::BI__builtin_lasx_xvslei_hu:
4702 case LoongArch::BI__builtin_lasx_xvslei_wu:
4703 case LoongArch::BI__builtin_lasx_xvslei_du:
4704 case LoongArch::BI__builtin_lasx_xvslti_bu:
4705 case LoongArch::BI__builtin_lasx_xvslti_hu:
4706 case LoongArch::BI__builtin_lasx_xvslti_wu:
4707 case LoongArch::BI__builtin_lasx_xvslti_du:
4708 case LoongArch::BI__builtin_lasx_xvmaxi_bu:
4709 case LoongArch::BI__builtin_lasx_xvmaxi_hu:
4710 case LoongArch::BI__builtin_lasx_xvmaxi_wu:
4711 case LoongArch::BI__builtin_lasx_xvmaxi_du:
4712 case LoongArch::BI__builtin_lasx_xvmini_bu:
4713 case LoongArch::BI__builtin_lasx_xvmini_hu:
4714 case LoongArch::BI__builtin_lasx_xvmini_wu:
4715 case LoongArch::BI__builtin_lasx_xvmini_du:
4716 case LoongArch::BI__builtin_lasx_xvaddi_bu:
4717 case LoongArch::BI__builtin_lasx_xvaddi_hu:
4718 case LoongArch::BI__builtin_lasx_xvaddi_wu:
4719 case LoongArch::BI__builtin_lasx_xvaddi_du:
4720 case LoongArch::BI__builtin_lasx_xvbitclri_w:
4721 case LoongArch::BI__builtin_lasx_xvbitrevi_w:
4722 case LoongArch::BI__builtin_lasx_xvbitseti_w:
4723 case LoongArch::BI__builtin_lasx_xvsat_w:
4724 case LoongArch::BI__builtin_lasx_xvsat_wu:
4725 case LoongArch::BI__builtin_lasx_xvslli_w:
4726 case LoongArch::BI__builtin_lasx_xvsrai_w:
4727 case LoongArch::BI__builtin_lasx_xvsrari_w:
4728 case LoongArch::BI__builtin_lasx_xvsrli_w:
4729 case LoongArch::BI__builtin_lasx_xvsllwil_d_w:
4730 case LoongArch::BI__builtin_lasx_xvsllwil_du_wu:
4731 case LoongArch::BI__builtin_lasx_xvsrlri_w:
4732 case LoongArch::BI__builtin_lasx_xvrotri_w:
4733 case LoongArch::BI__builtin_lasx_xvsubi_bu:
4734 case LoongArch::BI__builtin_lasx_xvsubi_hu:
4735 case LoongArch::BI__builtin_lasx_xvsubi_wu:
4736 case LoongArch::BI__builtin_lasx_xvsubi_du:
4737 case LoongArch::BI__builtin_lasx_xvbsrl_v:
4738 case LoongArch::BI__builtin_lasx_xvbsll_v:
4739 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4740 case LoongArch::BI__builtin_lasx_xvssrarni_h_w:
4741 case LoongArch::BI__builtin_lasx_xvssrarni_hu_w:
4742 case LoongArch::BI__builtin_lasx_xvssrani_h_w:
4743 case LoongArch::BI__builtin_lasx_xvssrani_hu_w:
4744 case LoongArch::BI__builtin_lasx_xvsrarni_h_w:
4745 case LoongArch::BI__builtin_lasx_xvsrani_h_w:
4746 case LoongArch::BI__builtin_lasx_xvfrstpi_b:
4747 case LoongArch::BI__builtin_lasx_xvfrstpi_h:
4748 case LoongArch::BI__builtin_lasx_xvsrlni_h_w:
4749 case LoongArch::BI__builtin_lasx_xvsrlrni_h_w:
4750 case LoongArch::BI__builtin_lasx_xvssrlni_h_w:
4751 case LoongArch::BI__builtin_lasx_xvssrlni_hu_w:
4752 case LoongArch::BI__builtin_lasx_xvssrlrni_h_w:
4753 case LoongArch::BI__builtin_lasx_xvssrlrni_hu_w:
4754 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4755 case LoongArch::BI__builtin_lasx_xvbitclri_d:
4756 case LoongArch::BI__builtin_lasx_xvbitrevi_d:
4757 case LoongArch::BI__builtin_lasx_xvbitseti_d:
4758 case LoongArch::BI__builtin_lasx_xvsat_d:
4759 case LoongArch::BI__builtin_lasx_xvsat_du:
4760 case LoongArch::BI__builtin_lasx_xvslli_d:
4761 case LoongArch::BI__builtin_lasx_xvsrai_d:
4762 case LoongArch::BI__builtin_lasx_xvsrli_d:
4763 case LoongArch::BI__builtin_lasx_xvsrari_d:
4764 case LoongArch::BI__builtin_lasx_xvrotri_d:
4765 case LoongArch::BI__builtin_lasx_xvsrlri_d:
4766 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 63);
4767 case LoongArch::BI__builtin_lasx_xvssrarni_w_d:
4768 case LoongArch::BI__builtin_lasx_xvssrarni_wu_d:
4769 case LoongArch::BI__builtin_lasx_xvssrani_w_d:
4770 case LoongArch::BI__builtin_lasx_xvssrani_wu_d:
4771 case LoongArch::BI__builtin_lasx_xvsrarni_w_d:
4772 case LoongArch::BI__builtin_lasx_xvsrlni_w_d:
4773 case LoongArch::BI__builtin_lasx_xvsrlrni_w_d:
4774 case LoongArch::BI__builtin_lasx_xvssrlni_w_d:
4775 case LoongArch::BI__builtin_lasx_xvssrlni_wu_d:
4776 case LoongArch::BI__builtin_lasx_xvssrlrni_w_d:
4777 case LoongArch::BI__builtin_lasx_xvssrlrni_wu_d:
4778 case LoongArch::BI__builtin_lasx_xvsrani_w_d:
4779 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 63);
4780 case LoongArch::BI__builtin_lasx_xvssrarni_d_q:
4781 case LoongArch::BI__builtin_lasx_xvssrarni_du_q:
4782 case LoongArch::BI__builtin_lasx_xvssrani_d_q:
4783 case LoongArch::BI__builtin_lasx_xvssrani_du_q:
4784 case LoongArch::BI__builtin_lasx_xvsrarni_d_q:
4785 case LoongArch::BI__builtin_lasx_xvssrlni_d_q:
4786 case LoongArch::BI__builtin_lasx_xvssrlni_du_q:
4787 case LoongArch::BI__builtin_lasx_xvssrlrni_d_q:
4788 case LoongArch::BI__builtin_lasx_xvssrlrni_du_q:
4789 case LoongArch::BI__builtin_lasx_xvsrani_d_q:
4790 case LoongArch::BI__builtin_lasx_xvsrlni_d_q:
4791 case LoongArch::BI__builtin_lasx_xvsrlrni_d_q:
4792 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 127);
4793 case LoongArch::BI__builtin_lasx_xvseqi_b:
4794 case LoongArch::BI__builtin_lasx_xvseqi_h:
4795 case LoongArch::BI__builtin_lasx_xvseqi_w:
4796 case LoongArch::BI__builtin_lasx_xvseqi_d:
4797 case LoongArch::BI__builtin_lasx_xvslti_b:
4798 case LoongArch::BI__builtin_lasx_xvslti_h:
4799 case LoongArch::BI__builtin_lasx_xvslti_w:
4800 case LoongArch::BI__builtin_lasx_xvslti_d:
4801 case LoongArch::BI__builtin_lasx_xvslei_b:
4802 case LoongArch::BI__builtin_lasx_xvslei_h:
4803 case LoongArch::BI__builtin_lasx_xvslei_w:
4804 case LoongArch::BI__builtin_lasx_xvslei_d:
4805 case LoongArch::BI__builtin_lasx_xvmaxi_b:
4806 case LoongArch::BI__builtin_lasx_xvmaxi_h:
4807 case LoongArch::BI__builtin_lasx_xvmaxi_w:
4808 case LoongArch::BI__builtin_lasx_xvmaxi_d:
4809 case LoongArch::BI__builtin_lasx_xvmini_b:
4810 case LoongArch::BI__builtin_lasx_xvmini_h:
4811 case LoongArch::BI__builtin_lasx_xvmini_w:
4812 case LoongArch::BI__builtin_lasx_xvmini_d:
4813 return SemaBuiltinConstantArgRange(TheCall, 1, -16, 15);
4814 case LoongArch::BI__builtin_lasx_xvandi_b:
4815 case LoongArch::BI__builtin_lasx_xvnori_b:
4816 case LoongArch::BI__builtin_lasx_xvori_b:
4817 case LoongArch::BI__builtin_lasx_xvshuf4i_b:
4818 case LoongArch::BI__builtin_lasx_xvshuf4i_h:
4819 case LoongArch::BI__builtin_lasx_xvshuf4i_w:
4820 case LoongArch::BI__builtin_lasx_xvxori_b:
4821 case LoongArch::BI__builtin_lasx_xvpermi_d:
4822 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 255);
4823 case LoongArch::BI__builtin_lasx_xvbitseli_b:
4824 case LoongArch::BI__builtin_lasx_xvshuf4i_d:
4825 case LoongArch::BI__builtin_lasx_xvextrins_b:
4826 case LoongArch::BI__builtin_lasx_xvextrins_h:
4827 case LoongArch::BI__builtin_lasx_xvextrins_w:
4828 case LoongArch::BI__builtin_lasx_xvextrins_d:
4829 case LoongArch::BI__builtin_lasx_xvpermi_q:
4830 case LoongArch::BI__builtin_lasx_xvpermi_w:
4831 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 255);
4832 case LoongArch::BI__builtin_lasx_xvrepl128vei_b:
4833 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
4834 case LoongArch::BI__builtin_lasx_xvrepl128vei_h:
4835 case LoongArch::BI__builtin_lasx_xvpickve2gr_w:
4836 case LoongArch::BI__builtin_lasx_xvpickve2gr_wu:
4837 case LoongArch::BI__builtin_lasx_xvpickve_w_f:
4838 case LoongArch::BI__builtin_lasx_xvpickve_w:
4839 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 7);
4840 case LoongArch::BI__builtin_lasx_xvinsgr2vr_w:
4841 case LoongArch::BI__builtin_lasx_xvinsve0_w:
4842 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
4843 case LoongArch::BI__builtin_lasx_xvrepl128vei_w:
4844 case LoongArch::BI__builtin_lasx_xvpickve2gr_d:
4845 case LoongArch::BI__builtin_lasx_xvpickve2gr_du:
4846 case LoongArch::BI__builtin_lasx_xvpickve_d_f:
4847 case LoongArch::BI__builtin_lasx_xvpickve_d:
4848 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
4849 case LoongArch::BI__builtin_lasx_xvinsve0_d:
4850 case LoongArch::BI__builtin_lasx_xvinsgr2vr_d:
4851 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4852 case LoongArch::BI__builtin_lasx_xvstelm_b:
4853 return SemaBuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4854 SemaBuiltinConstantArgRange(TheCall, 3, 0, 31);
4855 case LoongArch::BI__builtin_lasx_xvstelm_h:
4856 return SemaBuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4857 SemaBuiltinConstantArgRange(TheCall, 3, 0, 15);
4858 case LoongArch::BI__builtin_lasx_xvstelm_w:
4859 return SemaBuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4860 SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
4861 case LoongArch::BI__builtin_lasx_xvstelm_d:
4862 return SemaBuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4863 SemaBuiltinConstantArgRange(TheCall, 3, 0, 3);
4864 case LoongArch::BI__builtin_lasx_xvrepl128vei_d:
4865 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
4866 case LoongArch::BI__builtin_lasx_xvldrepl_b:
4867 case LoongArch::BI__builtin_lasx_xvld:
4868 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4869 case LoongArch::BI__builtin_lasx_xvldrepl_h:
4870 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4871 case LoongArch::BI__builtin_lasx_xvldrepl_w:
4872 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4873 case LoongArch::BI__builtin_lasx_xvldrepl_d:
4874 return SemaBuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4875 case LoongArch::BI__builtin_lasx_xvst:
4876 return SemaBuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4877 case LoongArch::BI__builtin_lasx_xvldi:
4878 return SemaBuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4879 case LoongArch::BI__builtin_lasx_xvrepli_b:
4880 case LoongArch::BI__builtin_lasx_xvrepli_h:
4881 case LoongArch::BI__builtin_lasx_xvrepli_w:
4882 case LoongArch::BI__builtin_lasx_xvrepli_d:
4883 return SemaBuiltinConstantArgRange(TheCall, 0, -512, 511);
4888bool Sema::CheckMipsBuiltinFunctionCall(
const TargetInfo &TI,
4889 unsigned BuiltinID,
CallExpr *TheCall) {
4890 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
4891 CheckMipsBuiltinArgument(BuiltinID, TheCall);
4894bool Sema::CheckMipsBuiltinCpu(
const TargetInfo &TI,
unsigned BuiltinID,
4897 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
4898 BuiltinID <= Mips::BI__builtin_mips_lwx) {
4900 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_dsp);
4903 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
4904 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
4907 diag::err_mips_builtin_requires_dspr2);
4910 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
4911 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
4913 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_msa);
4928bool Sema::CheckMipsBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4929 unsigned i = 0, l = 0, u = 0, m = 0;
4930 switch (BuiltinID) {
4931 default:
return false;
4932 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63;
break;
4933 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63;
break;
4934 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31;
break;
4935 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3;
break;
4936 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31;
break;
4937 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31;
break;
4938 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31;
break;
4942 case Mips::BI__builtin_msa_bclri_b:
4943 case Mips::BI__builtin_msa_bnegi_b:
4944 case Mips::BI__builtin_msa_bseti_b:
4945 case Mips::BI__builtin_msa_sat_s_b:
4946 case Mips::BI__builtin_msa_sat_u_b:
4947 case Mips::BI__builtin_msa_slli_b:
4948 case Mips::BI__builtin_msa_srai_b:
4949 case Mips::BI__builtin_msa_srari_b:
4950 case Mips::BI__builtin_msa_srli_b:
4951 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7;
break;
4952 case Mips::BI__builtin_msa_binsli_b:
4953 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7;
break;
4955 case Mips::BI__builtin_msa_bclri_h:
4956 case Mips::BI__builtin_msa_bnegi_h:
4957 case Mips::BI__builtin_msa_bseti_h:
4958 case Mips::BI__builtin_msa_sat_s_h:
4959 case Mips::BI__builtin_msa_sat_u_h:
4960 case Mips::BI__builtin_msa_slli_h:
4961 case Mips::BI__builtin_msa_srai_h:
4962 case Mips::BI__builtin_msa_srari_h:
4963 case Mips::BI__builtin_msa_srli_h:
4964 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15;
break;
4965 case Mips::BI__builtin_msa_binsli_h:
4966 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15;
break;
4970 case Mips::BI__builtin_msa_cfcmsa:
4971 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31;
break;
4972 case Mips::BI__builtin_msa_clei_u_b:
4973 case Mips::BI__builtin_msa_clei_u_h:
4974 case Mips::BI__builtin_msa_clei_u_w:
4975 case Mips::BI__builtin_msa_clei_u_d:
4976 case Mips::BI__builtin_msa_clti_u_b:
4977 case Mips::BI__builtin_msa_clti_u_h:
4978 case Mips::BI__builtin_msa_clti_u_w:
4979 case Mips::BI__builtin_msa_clti_u_d:
4980 case Mips::BI__builtin_msa_maxi_u_b:
4981 case Mips::BI__builtin_msa_maxi_u_h:
4982 case Mips::BI__builtin_msa_maxi_u_w:
4983 case Mips::BI__builtin_msa_maxi_u_d:
4984 case Mips::BI__builtin_msa_mini_u_b:
4985 case Mips::BI__builtin_msa_mini_u_h:
4986 case Mips::BI__builtin_msa_mini_u_w:
4987 case Mips::BI__builtin_msa_mini_u_d:
4988 case Mips::BI__builtin_msa_addvi_b:
4989 case Mips::BI__builtin_msa_addvi_h:
4990 case Mips::BI__builtin_msa_addvi_w:
4991 case Mips::BI__builtin_msa_addvi_d:
4992 case Mips::BI__builtin_msa_bclri_w:
4993 case Mips::BI__builtin_msa_bnegi_w:
4994 case Mips::BI__builtin_msa_bseti_w:
4995 case Mips::BI__builtin_msa_sat_s_w:
4996 case Mips::BI__builtin_msa_sat_u_w:
4997 case Mips::BI__builtin_msa_slli_w:
4998 case Mips::BI__builtin_msa_srai_w:
4999 case Mips::BI__builtin_msa_srari_w:
5000 case Mips::BI__builtin_msa_srli_w:
5001 case Mips::BI__builtin_msa_srlri_w:
5002 case Mips::BI__builtin_msa_subvi_b:
5003 case Mips::BI__builtin_msa_subvi_h:
5004 case Mips::BI__builtin_msa_subvi_w:
5005 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31;
break;
5006 case Mips::BI__builtin_msa_binsli_w:
5007 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31;
break;
5009 case Mips::BI__builtin_msa_bclri_d:
5010 case Mips::BI__builtin_msa_bnegi_d:
5011 case Mips::BI__builtin_msa_bseti_d:
5012 case Mips::BI__builtin_msa_sat_s_d:
5013 case Mips::BI__builtin_msa_sat_u_d:
5014 case Mips::BI__builtin_msa_slli_d:
5015 case Mips::BI__builtin_msa_srai_d:
5016 case Mips::BI__builtin_msa_srari_d:
5017 case Mips::BI__builtin_msa_srli_d:
5018 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63;
break;
5019 case Mips::BI__builtin_msa_binsli_d:
5020 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63;
break;
5022 case Mips::BI__builtin_msa_ceqi_b:
5023 case Mips::BI__builtin_msa_ceqi_h:
5024 case Mips::BI__builtin_msa_ceqi_w:
5025 case Mips::BI__builtin_msa_ceqi_d:
5026 case Mips::BI__builtin_msa_clti_s_b:
5027 case Mips::BI__builtin_msa_clti_s_h:
5028 case Mips::BI__builtin_msa_clti_s_w:
5029 case Mips::BI__builtin_msa_clti_s_d:
5030 case Mips::BI__builtin_msa_clei_s_b:
5031 case Mips::BI__builtin_msa_clei_s_h:
5032 case Mips::BI__builtin_msa_clei_s_w:
5033 case Mips::BI__builtin_msa_clei_s_d:
5034 case Mips::BI__builtin_msa_maxi_s_b:
5035 case Mips::BI__builtin_msa_maxi_s_h:
5036 case Mips::BI__builtin_msa_maxi_s_w:
5037 case Mips::BI__builtin_msa_maxi_s_d:
5038 case Mips::BI__builtin_msa_mini_s_b:
5039 case Mips::BI__builtin_msa_mini_s_h:
5040 case Mips::BI__builtin_msa_mini_s_w:
5041 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15;
break;
5043 case Mips::BI__builtin_msa_andi_b:
5044 case Mips::BI__builtin_msa_nori_b:
5045 case Mips::BI__builtin_msa_ori_b:
5046 case Mips::BI__builtin_msa_shf_b:
5047 case Mips::BI__builtin_msa_shf_h:
5048 case Mips::BI__builtin_msa_shf_w:
5049 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255;
break;
5050 case Mips::BI__builtin_msa_bseli_b:
5051 case Mips::BI__builtin_msa_bmnzi_b:
5052 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255;
break;
5055 case Mips::BI__builtin_msa_copy_s_b:
5056 case Mips::BI__builtin_msa_copy_u_b:
5057 case Mips::BI__builtin_msa_insve_b:
5058 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15;
break;
5059 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15;
break;
5061 case Mips::BI__builtin_msa_copy_s_h:
5062 case Mips::BI__builtin_msa_copy_u_h:
5063 case Mips::BI__builtin_msa_insve_h:
5064 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7;
break;
5065 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7;
break;
5067 case Mips::BI__builtin_msa_copy_s_w:
5068 case Mips::BI__builtin_msa_copy_u_w:
5069 case Mips::BI__builtin_msa_insve_w:
5070 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3;
break;
5071 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3;
break;
5073 case Mips::BI__builtin_msa_copy_s_d:
5074 case Mips::BI__builtin_msa_copy_u_d:
5075 case Mips::BI__builtin_msa_insve_d:
5076 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1;
break;
5077 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1;
break;
5080 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255;
break;
5081 case Mips::BI__builtin_msa_ldi_h:
5082 case Mips::BI__builtin_msa_ldi_w:
5083 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511;
break;
5084 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1;
break;
5085 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2;
break;
5086 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5087 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5088 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5089 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5090 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1;
break;
5091 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2;
break;
5092 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5093 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5094 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5095 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5099 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
5101 return SemaBuiltinConstantArgRange(TheCall, i, l, u) ||
5102 SemaBuiltinConstantArgMultiple(TheCall, i, m);
5113 bool RequireICE =
false;
5121 unsigned size = strtoul(Str, &End, 10);
5122 assert(End != Str &&
"Missing constant parameter constraint");
5125 return Context.
IntTy;
5129 unsigned size = strtoul(Str, &End, 10);
5130 assert(End != Str &&
"Missing PowerPC MMA type size");
5134 #define PPC_VECTOR_TYPE(typeName, Id, size) \
5135 case size: Type = Context.Id##Ty; break;
5136 #include "clang/Basic/PPCTypes.def"
5137 default: llvm_unreachable(
"Invalid PowerPC MMA vector type");
5139 bool CheckVectorArgs =
false;
5140 while (!CheckVectorArgs) {
5149 CheckVectorArgs =
true;
5157 return Context.
DecodeTypeStr(--Str, Context, Error, RequireICE,
true);
5163 switch (BuiltinID) {
5164 case PPC::BI__builtin_divde:
5165 case PPC::BI__builtin_divdeu:
5166 case PPC::BI__builtin_bpermd:
5167 case PPC::BI__builtin_pdepd:
5168 case PPC::BI__builtin_pextd:
5169 case PPC::BI__builtin_ppc_ldarx:
5170 case PPC::BI__builtin_ppc_stdcx:
5171 case PPC::BI__builtin_ppc_tdw:
5172 case PPC::BI__builtin_ppc_trapd:
5173 case PPC::BI__builtin_ppc_cmpeqb:
5174 case PPC::BI__builtin_ppc_setb:
5175 case PPC::BI__builtin_ppc_mulhd:
5176 case PPC::BI__builtin_ppc_mulhdu:
5177 case PPC::BI__builtin_ppc_maddhd:
5178 case PPC::BI__builtin_ppc_maddhdu:
5179 case PPC::BI__builtin_ppc_maddld:
5180 case PPC::BI__builtin_ppc_load8r:
5181 case PPC::BI__builtin_ppc_store8r:
5182 case PPC::BI__builtin_ppc_insert_exp:
5183 case PPC::BI__builtin_ppc_extract_sig:
5184 case PPC::BI__builtin_ppc_addex:
5185 case PPC::BI__builtin_darn:
5186 case PPC::BI__builtin_darn_raw:
5187 case PPC::BI__builtin_ppc_compare_and_swaplp:
5188 case PPC::BI__builtin_ppc_fetch_and_addlp:
5189 case PPC::BI__builtin_ppc_fetch_and_andlp:
5190 case PPC::BI__builtin_ppc_fetch_and_orlp:
5191 case PPC::BI__builtin_ppc_fetch_and_swaplp:
5201bool Sema::SemaValueIsRunOfOnes(
CallExpr *TheCall,
unsigned ArgNum) {
5209 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
5213 if (
Result.isShiftedMask() || (~
Result).isShiftedMask())
5217 diag::err_argument_not_contiguous_bit_field)
5221bool Sema::CheckPPCBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
5223 unsigned i = 0, l = 0, u = 0;
5228 return Diag(TheCall->
getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
5231 switch (BuiltinID) {
5232 default:
return false;
5233 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
5234 case PPC::BI__builtin_altivec_crypto_vshasigmad:
5235 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
5236 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
5237 case PPC::BI__builtin_altivec_dss:
5238 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
5239 case PPC::BI__builtin_tbegin:
5240 case PPC::BI__builtin_tend:
5241 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
5242 case PPC::BI__builtin_tsr:
5243 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7);
5244 case PPC::BI__builtin_tabortwc:
5245 case PPC::BI__builtin_tabortdc:
5246 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
5247 case PPC::BI__builtin_tabortwci:
5248 case PPC::BI__builtin_tabortdci:
5249 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
5250 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
5254 case PPC::BI__builtin_unpack_longdouble:
5255 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 1))
5258 case PPC::BI__builtin_pack_longdouble:
5260 return Diag(TheCall->
getBeginLoc(), diag::err_ppc_builtin_requires_abi)
5263 case PPC::BI__builtin_altivec_dst:
5264 case PPC::BI__builtin_altivec_dstt:
5265 case PPC::BI__builtin_altivec_dstst:
5266 case PPC::BI__builtin_altivec_dststt:
5267 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
5268 case PPC::BI__builtin_vsx_xxpermdi:
5269 case PPC::BI__builtin_vsx_xxsldwi:
5270 return SemaBuiltinVSX(TheCall);
5271 case PPC::BI__builtin_unpack_vector_int128:
5272 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
5273 case PPC::BI__builtin_altivec_vgnb:
5274 return SemaBuiltinConstantArgRange(TheCall, 1, 2, 7);
5275 case PPC::BI__builtin_vsx_xxeval:
5276 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 255);
5277 case PPC::BI__builtin_altivec_vsldbi:
5278 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
5279 case PPC::BI__builtin_altivec_vsrdbi:
5280 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
5281 case PPC::BI__builtin_vsx_xxpermx:
5282 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
5283 case PPC::BI__builtin_ppc_tw:
5284 case PPC::BI__builtin_ppc_tdw:
5285 return SemaBuiltinConstantArgRange(TheCall, 2, 1, 31);
5286 case PPC::BI__builtin_ppc_cmprb:
5287 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
5290 case PPC::BI__builtin_ppc_rlwnm:
5291 return SemaValueIsRunOfOnes(TheCall, 2);
5292 case PPC::BI__builtin_ppc_rlwimi:
5293 case PPC::BI__builtin_ppc_rldimi:
5294 return SemaBuiltinConstantArg(TheCall, 2,
Result) ||
5295 SemaValueIsRunOfOnes(TheCall, 3);
5296 case PPC::BI__builtin_ppc_addex: {
5297 if (SemaBuiltinConstantArgRange(TheCall, 2, 0, 3))
5307 case PPC::BI__builtin_ppc_mtfsb0:
5308 case PPC::BI__builtin_ppc_mtfsb1:
5309 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
5310 case PPC::BI__builtin_ppc_mtfsf:
5311 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 255);
5312 case PPC::BI__builtin_ppc_mtfsfi:
5313 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7) ||
5314 SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
5315 case PPC::BI__builtin_ppc_alignx:
5316 return SemaBuiltinConstantArgPower2(TheCall, 0);
5317 case PPC::BI__builtin_ppc_rdlam:
5318 return SemaValueIsRunOfOnes(TheCall, 2);
5319 case PPC::BI__builtin_vsx_ldrmb:
5320 case PPC::BI__builtin_vsx_strmb:
5321 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
5322 case PPC::BI__builtin_altivec_vcntmbb:
5323 case PPC::BI__builtin_altivec_vcntmbh:
5324 case PPC::BI__builtin_altivec_vcntmbw:
5325 case PPC::BI__builtin_altivec_vcntmbd:
5326 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
5327 case PPC::BI__builtin_vsx_xxgenpcvbm:
5328 case PPC::BI__builtin_vsx_xxgenpcvhm:
5329 case PPC::BI__builtin_vsx_xxgenpcvwm:
5330 case PPC::BI__builtin_vsx_xxgenpcvdm:
5331 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
5332 case PPC::BI__builtin_ppc_test_data_class: {
5340 diag::err_ppc_invalid_test_data_class_type);
5341 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 127);
5343 case PPC::BI__builtin_ppc_maxfe:
5344 case PPC::BI__builtin_ppc_minfe:
5345 case PPC::BI__builtin_ppc_maxfl:
5346 case PPC::BI__builtin_ppc_minfl:
5347 case PPC::BI__builtin_ppc_maxfs:
5348 case PPC::BI__builtin_ppc_minfs: {
5350 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
5351 BuiltinID == PPC::BI__builtin_ppc_minfe))
5352 return Diag(TheCall->
getBeginLoc(), diag::err_target_unsupported_type)
5357 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
5358 BuiltinID == PPC::BI__builtin_ppc_minfl)
5360 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
5361 BuiltinID == PPC::BI__builtin_ppc_minfs)
5363 for (
unsigned I = 0, E = TheCall->
getNumArgs(); I < E; ++I)
5366 diag::err_typecheck_convert_incompatible)
5370#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
5371 case PPC::BI__builtin_##Name: \
5372 return SemaBuiltinPPCMMACall(TheCall, BuiltinID, Types);
5373#include "clang/Basic/BuiltinsPPC.def"
5375 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
5384 QualType CoreType =
Type.getCanonicalType().getUnqualifiedType();
5385#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
5387#include
"clang/Basic/PPCTypes.def"
5389 Diag(
TypeLoc, diag::err_ppc_invalid_use_mma_type);
5405 for (
unsigned i = 1; i < TheCall->
getNumArgs(); ++i) {
5409 if (VecTyA ==
nullptr && VecTyB ==
nullptr)
5412 if (VecTyA && VecTyB) {
5413 bool retValue =
false;
5414 if (VecTyA->getElementType() != VecTyB->getElementType()) {
5418 diag::err_vec_builtin_incompatible_vector)
5423 if (VecTyA->getNumElements() != VecTyB->getNumElements()) {
5427 S->
Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
5439 S->
Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
5449 for (
unsigned i = 0; i < TheCall->
getNumArgs(); ++i) {
5451 if (Check(PassedType)) {
5454 ExpectedType, VecTyA->getNumElements(), VecTyA->getVectorKind());
5456 diag::err_typecheck_convert_incompatible)
5466 return !PassedType->hasFloatingRepresentation();
5469 checkAllFloatTypes);
5496 switch (BuiltinID) {
5497 case Builtin::BI__builtin_hlsl_elementwise_any: {
5502 case Builtin::BI__builtin_hlsl_elementwise_clamp: {
5507 if (SemaBuiltinElementwiseTernaryMath(
5513 case Builtin::BI__builtin_hlsl_dot: {
5522 case Builtin::BI__builtin_hlsl_elementwise_rcp: {
5525 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5529 case Builtin::BI__builtin_hlsl_elementwise_rsqrt:
5530 case Builtin::BI__builtin_hlsl_elementwise_frac: {
5533 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5537 case Builtin::BI__builtin_hlsl_elementwise_isinf: {
5540 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5545 case Builtin::BI__builtin_hlsl_lerp: {
5550 if (SemaBuiltinElementwiseTernaryMath(TheCall))
5556 case Builtin::BI__builtin_hlsl_mad: {
5561 if (SemaBuiltinElementwiseTernaryMath(
5570bool Sema::CheckAMDGCNBuiltinFunctionCall(
unsigned BuiltinID,
5573 unsigned OrderIndex, ScopeIndex;
5574 switch (BuiltinID) {
5575 case AMDGPU::BI__builtin_amdgcn_get_fpenv:
5576 case AMDGPU::BI__builtin_amdgcn_set_fpenv:
5578 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
5579 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
5580 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
5581 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
5585 case AMDGPU::BI__builtin_amdgcn_fence:
5594 auto ArgExpr = Arg.
get();
5597 if (!ArgExpr->EvaluateAsInt(ArgResult,
Context))
5598 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
5599 << ArgExpr->getType();
5600 auto Ord = ArgResult.
Val.
getInt().getZExtValue();
5604 if (!llvm::isValidAtomicOrderingCABI(Ord))
5605 return Diag(ArgExpr->getBeginLoc(),
5606 diag::warn_atomic_op_has_invalid_memory_order)
5607 << 0 << ArgExpr->getSourceRange();
5608 switch (
static_cast<llvm::AtomicOrderingCABI
>(Ord)) {
5609 case llvm::AtomicOrderingCABI::relaxed:
5610 case llvm::AtomicOrderingCABI::consume:
5611 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
5612 return Diag(ArgExpr->getBeginLoc(),
5613 diag::warn_atomic_op_has_invalid_memory_order)
5614 << 0 << ArgExpr->getSourceRange();
5616 case llvm::AtomicOrderingCABI::acquire:
5617 case llvm::AtomicOrderingCABI::release:
5618 case llvm::AtomicOrderingCABI::acq_rel:
5619 case llvm::AtomicOrderingCABI::seq_cst:
5623 Arg = TheCall->
getArg(ScopeIndex);
5624 ArgExpr = Arg.
get();
5627 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1,
Context))
5628 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
5629 << ArgExpr->getType();
5634bool Sema::CheckRISCVLMUL(
CallExpr *TheCall,
unsigned ArgNum) {
5643 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
5647 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
5650 return Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
5656 assert((EGW == 128 || EGW == 256) &&
"EGW can only be 128 or 256 bits");
5662 unsigned MinElemCount = Info.
EC.getKnownMinValue();
5664 unsigned EGS = EGW / ElemSize;
5667 if (EGS <= MinElemCount)
5671 assert(EGS % MinElemCount == 0);
5672 unsigned VScaleFactor = EGS / MinElemCount;
5674 unsigned MinRequiredVLEN = VScaleFactor * llvm::RISCV::RVVBitsPerBlock;
5675 std::string RequiredExt =
"zvl" + std::to_string(MinRequiredVLEN) +
"b";
5678 diag::err_riscv_type_requires_extension) <<
Type << RequiredExt;
5683bool Sema::CheckRISCVBuiltinFunctionCall(
const TargetInfo &TI,
5688 bool FeatureMissing =
false;
5691 Features.split(ReqFeatures,
',', -1,
false);
5694 for (StringRef F : ReqFeatures) {
5696 F.split(ReqOpFeatures,
'|');
5698 if (llvm::none_of(ReqOpFeatures,
5699 [&TI](StringRef OF) {
return TI.
hasFeature(OF); })) {
5700 std::string FeatureStrs;
5701 bool IsExtension =
true;
5702 for (StringRef OF : ReqOpFeatures) {
5705 if (OF ==
"64bit") {
5706 assert(ReqOpFeatures.size() == 1 &&
"Expected '64bit' to be alone");
5708 IsExtension =
false;
5710 if (OF ==
"32bit") {
5711 assert(ReqOpFeatures.size() == 1 &&
"Expected '32bit' to be alone");
5713 IsExtension =
false;
5717 OF.consume_front(
"experimental-");
5718 std::string FeatureStr = OF.str();
5719 FeatureStr[0] = std::toupper(FeatureStr[0]);
5721 FeatureStrs += FeatureStrs.empty() ?
"" :
", ";
5723 FeatureStrs += FeatureStr;
5727 FeatureMissing =
true;
5728 Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_requires_extension)
5739 switch (BuiltinID) {
5742 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
5743 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
5744 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
5745 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
5746 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
5747 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
5748 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
5749 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
5750 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
5751 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
5752 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
5753 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
5754 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
5755 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
5756 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
5757 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
5758 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
5759 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
5760 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
5761 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
5762 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
5763 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
5764 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
5765 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
5766 case RISCVVector::BI__builtin_rvv_vmulh_vv:
5767 case RISCVVector::BI__builtin_rvv_vmulh_vx:
5768 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
5769 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
5770 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
5771 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
5772 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
5773 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
5774 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
5775 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
5776 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
5777 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
5778 case RISCVVector::BI__builtin_rvv_vsmul_vv:
5779 case RISCVVector::BI__builtin_rvv_vsmul_vx:
5780 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
5781 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
5782 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
5783 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
5784 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
5785 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
5786 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
5787 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
5788 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
5789 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
5795 diag::err_riscv_builtin_requires_extension)
5802 switch (BuiltinID) {
5803 case RISCVVector::BI__builtin_rvv_vsetvli:
5804 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3) ||
5805 CheckRISCVLMUL(TheCall, 2);
5806 case RISCVVector::BI__builtin_rvv_vsetvlimax:
5807 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5808 CheckRISCVLMUL(TheCall, 1);
5809 case RISCVVector::BI__builtin_rvv_vget_v: {
5820 MaxIndex = (VecInfo.
EC.getKnownMinValue() * VecInfo.
NumVectors) /
5821 (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors);
5822 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5824 case RISCVVector::BI__builtin_rvv_vset_v: {
5835 MaxIndex = (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors) /
5837 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5840 case RISCVVector::BI__builtin_rvv_vaeskf1_vi_tu:
5841 case RISCVVector::BI__builtin_rvv_vaeskf2_vi_tu:
5842 case RISCVVector::BI__builtin_rvv_vaeskf2_vi:
5843 case RISCVVector::BI__builtin_rvv_vsm4k_vi_tu: {
5848 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
5850 case RISCVVector::BI__builtin_rvv_vsm3c_vi_tu:
5851 case RISCVVector::BI__builtin_rvv_vsm3c_vi: {
5854 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
5856 case RISCVVector::BI__builtin_rvv_vaeskf1_vi:
5857 case RISCVVector::BI__builtin_rvv_vsm4k_vi: {
5860 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
5862 case RISCVVector::BI__builtin_rvv_vaesdf_vv:
5863 case RISCVVector::BI__builtin_rvv_vaesdf_vs:
5864 case RISCVVector::BI__builtin_rvv_vaesdm_vv:
5865 case RISCVVector::BI__builtin_rvv_vaesdm_vs:
5866 case RISCVVector::BI__builtin_rvv_vaesef_vv:
5867 case RISCVVector::BI__builtin_rvv_vaesef_vs:
5868 case RISCVVector::BI__builtin_rvv_vaesem_vv:
5869 case RISCVVector::BI__builtin_rvv_vaesem_vs:
5870 case RISCVVector::BI__builtin_rvv_vaesz_vs:
5871 case RISCVVector::BI__builtin_rvv_vsm4r_vv:
5872 case RISCVVector::BI__builtin_rvv_vsm4r_vs:
5873 case RISCVVector::BI__builtin_rvv_vaesdf_vv_tu:
5874 case RISCVVector::BI__builtin_rvv_vaesdf_vs_tu:
5875 case RISCVVector::BI__builtin_rvv_vaesdm_vv_tu:
5876 case RISCVVector::BI__builtin_rvv_vaesdm_vs_tu:
5877 case RISCVVector::BI__builtin_rvv_vaesef_vv_tu:
5878 case RISCVVector::BI__builtin_rvv_vaesef_vs_tu:
5879 case RISCVVector::BI__builtin_rvv_vaesem_vv_tu:
5880 case RISCVVector::BI__builtin_rvv_vaesem_vs_tu:
5881 case RISCVVector::BI__builtin_rvv_vaesz_vs_tu:
5882 case RISCVVector::BI__builtin_rvv_vsm4r_vv_tu:
5883 case RISCVVector::BI__builtin_rvv_vsm4r_vs_tu: {
5889 case RISCVVector::BI__builtin_rvv_vsha2ch_vv:
5890 case RISCVVector::BI__builtin_rvv_vsha2cl_vv:
5891 case RISCVVector::BI__builtin_rvv_vsha2ms_vv:
5892 case RISCVVector::BI__builtin_rvv_vsha2ch_vv_tu:
5893 case RISCVVector::BI__builtin_rvv_vsha2cl_vv_tu:
5894 case RISCVVector::BI__builtin_rvv_vsha2ms_vv_tu: {
5901 if (ElemSize == 64 && !TI.
hasFeature(
"zvknhb"))
5903 diag::err_riscv_builtin_requires_extension)
5911 case RISCVVector::BI__builtin_rvv_sf_vc_i_se:
5913 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5914 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5915 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5916 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15) ||
5917 CheckRISCVLMUL(TheCall, 5);
5918 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
5920 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5921 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5922 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
5923 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
5924 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
5926 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5927 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5928 SemaBuiltinConstantArgRange(TheCall, 2, -16, 15);
5929 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
5930 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
5932 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5933 SemaBuiltinConstantArgRange(TheCall, 2, -16, 15);
5934 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
5935 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
5936 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
5937 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
5938 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
5939 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
5941 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5942 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
5943 case RISCVVector::BI__builtin_rvv_sf_vc_x_se:
5945 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5946 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5947 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5948 CheckRISCVLMUL(TheCall, 5);
5949 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
5950 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
5952 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
5953 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
5955 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5956 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
5957 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
5958 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
5959 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
5960 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
5962 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
5963 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
5964 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
5965 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
5967 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
5968 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
5969 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
5970 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
5971 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
5972 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
5973 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
5974 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
5976 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
5977 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
5979 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1) ||
5980 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
5981 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
5982 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
5983 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
5984 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
5985 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
5986 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
5988 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
5989 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
5991 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
5993 case RISCV::BI__builtin_riscv_aes32dsi:
5994 case RISCV::BI__builtin_riscv_aes32dsmi:
5995 case RISCV::BI__builtin_riscv_aes32esi:
5996 case RISCV::BI__builtin_riscv_aes32esmi:
5997 case RISCV::BI__builtin_riscv_sm4ks:
5998 case RISCV::BI__builtin_riscv_sm4ed:
5999 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
6001 case RISCV::BI__builtin_riscv_aes64ks1i:
6002 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 10);
6004 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
6005 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
6006 case RISCVVector::BI__builtin_rvv_vaadd_vv:
6007 case RISCVVector::BI__builtin_rvv_vaadd_vx:
6008 case RISCVVector::BI__builtin_rvv_vasubu_vv:
6009 case RISCVVector::BI__builtin_rvv_vasubu_vx:
6010 case RISCVVector::BI__builtin_rvv_vasub_vv:
6011 case RISCVVector::BI__builtin_rvv_vasub_vx:
6012 case RISCVVector::BI__builtin_rvv_vsmul_vv:
6013 case RISCVVector::BI__builtin_rvv_vsmul_vx:
6014 case RISCVVector::BI__builtin_rvv_vssra_vv:
6015 case RISCVVector::BI__builtin_rvv_vssra_vx:
6016 case RISCVVector::BI__builtin_rvv_vssrl_vv:
6017 case RISCVVector::BI__builtin_rvv_vssrl_vx:
6018 case RISCVVector::BI__builtin_rvv_vnclip_wv:
6019 case RISCVVector::BI__builtin_rvv_vnclip_wx:
6020 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
6021 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
6022 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
6023 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
6024 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
6025 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
6026 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
6027 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
6028 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
6029 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
6030 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
6031 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
6032 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
6033 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
6034 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
6035 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
6036 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
6037 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
6038 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
6039 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
6040 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
6041 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
6042 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
6043 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
6044 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
6045 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
6046 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
6047 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
6048 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
6049 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
6050 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
6051 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
6052 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
6053 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
6054 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
6055 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
6056 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
6057 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
6058 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
6059 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 3);
6060 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
6061 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
6062 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
6063 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
6064 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
6065 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
6066 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
6067 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
6068 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
6069 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
6070 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
6071 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
6072 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
6073 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
6074 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
6075 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
6076 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
6077 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
6078 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
6079 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
6080 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
6081 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
6082 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
6083 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
6084 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
6085 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
6086 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
6087 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
6088 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
6089 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
6090 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
6091 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
6092 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
6093 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
6094 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
6095 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
6096 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
6097 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
6098 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
6099 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
6100 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
6101 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
6102 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
6103 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
6104 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
6105 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
6106 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
6107 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
6108 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
6109 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
6110 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
6111 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
6112 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
6113 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
6114 return SemaBuiltinConstantArgRange(TheCall, 4, 0, 3);
6115 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
6116 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
6117 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
6118 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
6119 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
6120 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
6121 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
6122 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
6123 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
6124 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
6125 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
6126 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
6127 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
6128 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 4);
6129 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
6130 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
6131 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
6132 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
6133 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
6134 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
6135 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
6136 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
6137 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
6138 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
6139 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
6140 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
6141 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
6142 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
6143 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
6144 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
6145 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
6146 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
6147 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
6148 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
6149 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
6150 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
6151 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
6152 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
6153 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
6154 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
6155 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
6156 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
6157 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
6158 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
6159 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
6160 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
6161 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
6162 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
6163 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
6164 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
6165 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
6166 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
6167 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
6168 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
6169 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
6170 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
6171 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
6172 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
6173 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
6174 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
6175 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
6176 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
6177 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
6178 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
6179 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 4);
6180 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
6181 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
6182 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
6183 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
6184 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
6185 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
6186 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
6187 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
6188 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
6189 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
6190 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
6191 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
6192 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
6193 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
6194 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
6195 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
6196 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
6197 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
6198 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
6199 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
6200 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
6201 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
6202 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
6203 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
6204 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
6205 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
6206 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
6207 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
6208 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
6209 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
6210 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
6211 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
6212 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
6213 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
6214 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
6215 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
6216 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
6217 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
6218 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
6219 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
6220 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
6221 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
6222 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
6223 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
6224 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
6225 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
6226 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
6227 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
6228 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
6229 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
6230 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
6231 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
6232 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
6233 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
6234 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
6235 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
6236 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
6237 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
6238 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
6239 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
6240 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
6241 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
6242 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
6243 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
6244 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
6245 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
6246 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
6247 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
6248 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
6249 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
6250 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
6251 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
6252 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
6253 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
6254 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
6255 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
6256 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
6257 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
6258 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
6259 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
6260 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
6261 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
6262 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
6263 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
6264 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
6265 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
6266 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
6267 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
6268 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
6269 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
6270 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
6271 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
6272 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
6273 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
6274 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
6275 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
6276 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
6277 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
6278 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
6279 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
6280 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
6281 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
6282 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
6283 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
6284 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
6285 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
6286 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
6287 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
6288 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
6289 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
6290 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
6291 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
6292 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
6293 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
6294 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
6295 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
6296 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
6297 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
6298 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
6299 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
6300 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
6301 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
6302 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
6303 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
6304 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
6305 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
6306 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
6307 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
6308 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
6309 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
6310 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
6311 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
6312 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
6313 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
6314 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
6315 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 4);
6316 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
6317 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
6318 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
6319 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
6320 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
6321 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
6322 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
6323 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
6324 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
6325 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
6326 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
6327 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
6328 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
6329 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
6330 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
6331 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
6332 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
6333 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
6334 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
6335 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
6336 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
6337 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
6338 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
6339 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
6340 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
6341 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
6342 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
6343 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
6344 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
6345 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
6346 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
6347 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
6348 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
6349 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
6350 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
6351 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
6352 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
6353 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
6354 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
6355 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
6356 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
6357 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
6358 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
6359 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
6360 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
6361 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
6362 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
6363 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
6364 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
6365 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
6366 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
6367 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
6368 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
6369 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
6370 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
6371 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
6372 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
6373 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
6374 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
6375 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
6376 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
6377 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
6378 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
6379 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
6380 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
6381 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
6382 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
6383 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
6384 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
6385 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
6386 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
6387 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
6388 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
6389 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
6390 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
6391 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
6392 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
6393 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
6394 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
6395 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
6396 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
6397 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
6398 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
6399 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
6400 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
6401 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
6402 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
6403 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
6404 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
6405 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
6406 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
6407 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
6408 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
6409 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
6410 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
6411 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
6412 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
6413 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
6414 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
6415 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
6416 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
6417 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
6418 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
6419 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
6420 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
6421 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
6422 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
6423 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
6424 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
6425 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
6426 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
6427 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
6428 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
6429 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
6430 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
6431 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
6432 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
6433 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
6434 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
6435 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
6436 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
6437 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
6438 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
6439 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
6440 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
6441 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
6442 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
6443 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
6444 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
6445 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
6446 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
6447 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
6448 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
6449 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
6450 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
6451 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
6452 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
6453 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
6454 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
6455 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
6456 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
6457 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
6458 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
6459 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
6460 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
6461 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
6462 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
6463 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
6464 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
6465 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
6466 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
6467 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
6468 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
6469 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
6470 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
6471 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
6472 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
6473 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
6474 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
6475 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
6476 return SemaBuiltinConstantArgRange(TheCall, 4, 0, 4);
6477 case RISCV::BI__builtin_riscv_ntl_load:
6478 case RISCV::BI__builtin_riscv_ntl_store:
6481 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
6482 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
6483 "Unexpected RISC-V nontemporal load/store builtin!");
6484 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
6485 unsigned NumArgs = IsStore ? 3 : 2;
6496 SemaBuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
6505 PointerArg = PointerArgResult.
get();
6509 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
6520 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
6545bool Sema::CheckSystemZBuiltinFunctionCall(
unsigned BuiltinID,
6547 if (BuiltinID == SystemZ::BI__builtin_tabort) {
6549 if (std::optional<llvm::APSInt> AbortCode =
6551 if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
6552 return Diag(Arg->
getBeginLoc(), diag::err_systemz_invalid_tabort_code)
6558 unsigned i = 0, l = 0, u = 0;
6559 switch (BuiltinID) {
6560 default:
return false;
6561 case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15;
break;
6562 case SystemZ::BI__builtin_s390_verimb:
6563 case SystemZ::BI__builtin_s390_verimh:
6564 case SystemZ::BI__builtin_s390_verimf:
6565 case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255;
break;
6566 case SystemZ::BI__builtin_s390_vfaeb:
6567 case SystemZ::BI__builtin_s390_vfaeh:
6568 case SystemZ::BI__builtin_s390_vfaef:
6569 case SystemZ::BI__builtin_s390_vfaebs:
6570 case SystemZ::BI__builtin_s390_vfaehs:
6571 case SystemZ::BI__builtin_s390_vfaefs:
6572 case SystemZ::BI__builtin_s390_vfaezb:
6573 case SystemZ::BI__builtin_s390_vfaezh:
6574 case SystemZ::BI__builtin_s390_vfaezf:
6575 case SystemZ::BI__builtin_s390_vfaezbs:
6576 case SystemZ::BI__builtin_s390_vfaezhs:
6577 case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15;
break;
6578 case SystemZ::BI__builtin_s390_vfisb:
6579 case SystemZ::BI__builtin_s390_vfidb:
6580 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15) ||
6581 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
6582 case SystemZ::BI__builtin_s390_vftcisb:
6583 case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095;
break;
6584 case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15;
break;
6585 case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15;
break;
6586 case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15;
break;
6587 case SystemZ::BI__builtin_s390_vstrcb:
6588 case SystemZ::BI__builtin_s390_vstrch:
6589 case SystemZ::BI__builtin_s390_vstrcf:
6590 case SystemZ::BI__builtin_s390_vstrczb:
6591 case SystemZ::BI__builtin_s390_vstrczh:
6592 case SystemZ::BI__builtin_s390_vstrczf:
6593 case SystemZ::BI__builtin_s390_vstrcbs:
6594 case SystemZ::BI__builtin_s390_vstrchs:
6595 case SystemZ::BI__builtin_s390_vstrcfs:
6596 case SystemZ::BI__builtin_s390_vstrczbs:
6597 case SystemZ::BI__builtin_s390_vstrczhs:
6598 case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15;
break;
6599 case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15;
break;
6600 case SystemZ::BI__builtin_s390_vfminsb:
6601 case SystemZ::BI__builtin_s390_vfmaxsb:
6602 case SystemZ::BI__builtin_s390_vfmindb:
6603 case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15;
break;
6604 case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7;
break;
6605 case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7;
break;
6606 case SystemZ::BI__builtin_s390_vclfnhs:
6607 case SystemZ::BI__builtin_s390_vclfnls:
6608 case SystemZ::BI__builtin_s390_vcfn:
6609 case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15;
break;
6610 case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15;
break;
6612 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
6615bool Sema::CheckWebAssemblyBuiltinFunctionCall(
const TargetInfo &TI,
6618 switch (BuiltinID) {
6619 case WebAssembly::BI__builtin_wasm_ref_null_extern:
6620 return BuiltinWasmRefNullExtern(TheCall);
6621 case WebAssembly::BI__builtin_wasm_ref_null_func:
6622 return BuiltinWasmRefNullFunc(TheCall);
6623 case WebAssembly::BI__builtin_wasm_table_get:
6624 return BuiltinWasmTableGet(TheCall);
6625 case WebAssembly::BI__builtin_wasm_table_set:
6626 return BuiltinWasmTableSet(TheCall);
6627 case WebAssembly::BI__builtin_wasm_table_size:
6628 return BuiltinWasmTableSize(TheCall);
6629 case WebAssembly::BI__builtin_wasm_table_grow:
6630 return BuiltinWasmTableGrow(TheCall);
6631 case WebAssembly::BI__builtin_wasm_table_fill:
6632 return BuiltinWasmTableFill(TheCall);
6633 case WebAssembly::BI__builtin_wasm_table_copy:
6634 return BuiltinWasmTableCopy(TheCall);
6646 unsigned MinElts = Info.
EC.getKnownMinValue();
6650 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64d";
6656 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64x";
6659 Diag(Loc, diag::err_riscv_type_requires_extension, D)
6660 << Ty <<
"zvfh or zvfhmin";
6663 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zvfbfmin";
6666 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32f";
6670 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32x";
6673bool Sema::CheckNVPTXBuiltinFunctionCall(
const TargetInfo &TI,
6676 switch (BuiltinID) {
6677 case NVPTX::BI__nvvm_cp_async_ca_shared_global_4:
6678 case NVPTX::BI__nvvm_cp_async_ca_shared_global_8:
6679 case NVPTX::BI__nvvm_cp_async_ca_shared_global_16:
6680 case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
6688bool Sema::CheckX86BuiltinRoundingOrSAE(
unsigned BuiltinID,
CallExpr *TheCall) {
6692 unsigned ArgNum = 0;
6693 switch (BuiltinID) {
6696 case X86::BI__builtin_ia32_vcvttsd2si32:
6697 case X86::BI__builtin_ia32_vcvttsd2si64:
6698 case X86::BI__builtin_ia32_vcvttsd2usi32:
6699 case X86::BI__builtin_ia32_vcvttsd2usi64:
6700 case X86::BI__builtin_ia32_vcvttss2si32:
6701 case X86::BI__builtin_ia32_vcvttss2si64:
6702 case X86::BI__builtin_ia32_vcvttss2usi32:
6703 case X86::BI__builtin_ia32_vcvttss2usi64:
6704 case X86::BI__builtin_ia32_vcvttsh2si32:
6705 case X86::BI__builtin_ia32_vcvttsh2si64:
6706 case X86::BI__builtin_ia32_vcvttsh2usi32:
6707 case X86::BI__builtin_ia32_vcvttsh2usi64:
6710 case X86::BI__builtin_ia32_maxpd512:
6711 case X86::BI__builtin_ia32_maxps512:
6712 case X86::BI__builtin_ia32_minpd512:
6713 case X86::BI__builtin_ia32_minps512:
6714 case X86::BI__builtin_ia32_maxph512:
6715 case X86::BI__builtin_ia32_minph512:
6718 case X86::BI__builtin_ia32_vcvtph2pd512_mask:
6719 case X86::BI__builtin_ia32_vcvtph2psx512_mask:
6720 case X86::BI__builtin_ia32_cvtps2pd512_mask:
6721 case X86::BI__builtin_ia32_cvttpd2dq512_mask:
6722 case X86::BI__builtin_ia32_cvttpd2qq512_mask:
6723 case X86::BI__builtin_ia32_cvttpd2udq512_mask:
6724 case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
6725 case X86::BI__builtin_ia32_cvttps2dq512_mask:
6726 case X86::BI__builtin_ia32_cvttps2qq512_mask:
6727 case X86::BI__builtin_ia32_cvttps2udq512_mask:
6728 case X86::BI__builtin_ia32_cvttps2uqq512_mask:
6729 case X86::BI__builtin_ia32_vcvttph2w512_mask:
6730 case X86::BI__builtin_ia32_vcvttph2uw512_mask:
6731 case X86::BI__builtin_ia32_vcvttph2dq512_mask:
6732 case X86::BI__builtin_ia32_vcvttph2udq512_mask:
6733 case X86::BI__builtin_ia32_vcvttph2qq512_mask:
6734 case X86::BI__builtin_ia32_vcvttph2uqq512_mask:
6735 case X86::BI__builtin_ia32_exp2pd_mask:
6736 case X86::BI__builtin_ia32_exp2ps_mask:
6737 case X86::BI__builtin_ia32_getexppd512_mask:
6738 case X86::BI__builtin_ia32_getexpps512_mask:
6739 case X86::BI__builtin_ia32_getexpph512_mask:
6740 case X86::BI__builtin_ia32_rcp28pd_mask:
6741 case X86::BI__builtin_ia32_rcp28ps_mask:
6742 case X86::BI__builtin_ia32_rsqrt28pd_mask:
6743 case X86::BI__builtin_ia32_rsqrt28ps_mask:
6744 case X86::BI__builtin_ia32_vcomisd:
6745 case X86::BI__builtin_ia32_vcomiss:
6746 case X86::BI__builtin_ia32_vcomish:
6747 case X86::BI__builtin_ia32_vcvtph2ps512_mask:
6750 case X86::BI__builtin_ia32_cmppd512_mask:
6751 case X86::BI__builtin_ia32_cmpps512_mask:
6752 case X86::BI__builtin_ia32_cmpsd_mask:
6753 case X86::BI__builtin_ia32_cmpss_mask:
6754 case X86::BI__builtin_ia32_cmpsh_mask:
6755 case X86::BI__builtin_ia32_vcvtsh2sd_round_mask:
6756 case X86::BI__builtin_ia32_vcvtsh2ss_round_mask:
6757 case X86::BI__builtin_ia32_cvtss2sd_round_mask:
6758 case X86::BI__builtin_ia32_getexpsd128_round_mask:
6759 case X86::BI__builtin_ia32_getexpss128_round_mask:
6760 case X86::BI__builtin_ia32_getexpsh128_round_mask:
6761 case X86::BI__builtin_ia32_getmantpd512_mask:
6762 case X86::BI__builtin_ia32_getmantps512_mask:
6763 case X86::BI__builtin_ia32_getmantph512_mask:
6764 case X86::BI__builtin_ia32_maxsd_round_mask:
6765 case X86::BI__builtin_ia32_maxss_round_mask:
6766 case X86::BI__builtin_ia32_maxsh_round_mask:
6767 case X86::BI__builtin_ia32_minsd_round_mask:
6768 case X86::BI__builtin_ia32_minss_round_mask:
6769 case X86::BI__builtin_ia32_minsh_round_mask:
6770 case X86::BI__builtin_ia32_rcp28sd_round_mask:
6771 case X86::BI__builtin_ia32_rcp28ss_round_mask:
6772 case X86::BI__builtin_ia32_reducepd512_mask:
6773 case X86::BI__builtin_ia32_reduceps512_mask:
6774 case X86::BI__builtin_ia32_reduceph512_mask:
6775 case X86::BI__builtin_ia32_rndscalepd_mask:
6776 case X86::BI__builtin_ia32_rndscaleps_mask:
6777 case X86::BI__builtin_ia32_rndscaleph_mask:
6778 case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
6779 case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
6782 case X86::BI__builtin_ia32_fixupimmpd512_mask:
6783 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
6784 case X86::BI__builtin_ia32_fixupimmps512_mask:
6785 case X86::BI__builtin_ia32_fixupimmps512_maskz:
6786 case X86::BI__builtin_ia32_fixupimmsd_mask:
6787 case X86::BI__builtin_ia32_fixupimmsd_maskz:
6788 case X86::BI__builtin_ia32_fixupimmss_mask:
6789 case X86::BI__builtin_ia32_fixupimmss_maskz:
6790 case X86::BI__builtin_ia32_getmantsd_round_mask:
6791 case X86::BI__builtin_ia32_getmantss_round_mask:
6792 case X86::BI__builtin_ia32_getmantsh_round_mask:
6793 case X86::BI__builtin_ia32_rangepd512_mask:
6794 case X86::BI__builtin_ia32_rangeps512_mask:
6795 case X86::BI__builtin_ia32_rangesd128_round_mask:
6796 case X86::BI__builtin_ia32_rangess128_round_mask:
6797 case X86::BI__builtin_ia32_reducesd_mask:
6798 case X86::BI__builtin_ia32_reducess_mask:
6799 case X86::BI__builtin_ia32_reducesh_mask:
6800 case X86::BI__builtin_ia32_rndscalesd_round_mask:
6801 case X86::BI__builtin_ia32_rndscaless_round_mask:
6802 case X86::BI__builtin_ia32_rndscalesh_round_mask:
6805 case X86::BI__builtin_ia32_vcvtsd2si64:
6806 case X86::BI__builtin_ia32_vcvtsd2si32:
6807 case X86::BI__builtin_ia32_vcvtsd2usi32:
6808 case X86::BI__builtin_ia32_vcvtsd2usi64:
6809 case X86::BI__builtin_ia32_vcvtss2si32:
6810 case X86::BI__builtin_ia32_vcvtss2si64:
6811 case X86::BI__builtin_ia32_vcvtss2usi32:
6812 case X86::BI__builtin_ia32_vcvtss2usi64:
6813 case X86::BI__builtin_ia32_vcvtsh2si32:
6814 case X86::BI__builtin_ia32_vcvtsh2si64:
6815 case X86::BI__builtin_ia32_vcvtsh2usi32:
6816 case X86::BI__builtin_ia32_vcvtsh2usi64:
6817 case X86::BI__builtin_ia32_sqrtpd512:
6818 case X86::BI__builtin_ia32_sqrtps512:
6819 case X86::BI__builtin_ia32_sqrtph512:
6823 case X86::BI__builtin_ia32_addph512:
6824 case X86::BI__builtin_ia32_divph512:
6825 case X86::BI__builtin_ia32_mulph512:
6826 case X86::BI__builtin_ia32_subph512:
6827 case X86::BI__builtin_ia32_addpd512:
6828 case X86::BI__builtin_ia32_addps512:
6829 case X86::BI__builtin_ia32_divpd512:
6830 case X86::BI__builtin_ia32_divps512:
6831 case X86::BI__builtin_ia32_mulpd512:
6832 case X86::BI__builtin_ia32_mulps512:
6833 case X86::BI__builtin_ia32_subpd512:
6834 case X86::BI__builtin_ia32_subps512:
6835 case X86::BI__builtin_ia32_cvtsi2sd64:
6836 case X86::BI__builtin_ia32_cvtsi2ss32:
6837 case X86::BI__builtin_ia32_cvtsi2ss64:
6838 case X86::BI__builtin_ia32_cvtusi2sd64:
6839 case X86::BI__builtin_ia32_cvtusi2ss32:
6840 case X86::BI__builtin_ia32_cvtusi2ss64:
6841 case X86::BI__builtin_ia32_vcvtusi2sh:
6842 case X86::BI__builtin_ia32_vcvtusi642sh:
6843 case X86::BI__builtin_ia32_vcvtsi2sh:
6844 case X86::BI__builtin_ia32_vcvtsi642sh:
6848 case X86::BI__builtin_ia32_cvtdq2ps512_mask:
6849 case X86::BI__builtin_ia32_cvtudq2ps512_mask:
6850 case X86::BI__builtin_ia32_vcvtpd2ph512_mask:
6851 case X86::BI__builtin_ia32_vcvtps2phx512_mask:
6852 case X86::BI__builtin_ia32_cvtpd2ps512_mask:
6853 case X86::BI__builtin_ia32_cvtpd2dq512_mask:
6854 case X86::BI__builtin_ia32_cvtpd2qq512_mask:
6855 case X86::BI__builtin_ia32_cvtpd2udq512_mask:
6856 case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
6857 case X86::BI__builtin_ia32_cvtps2dq512_mask:
6858 case X86::BI__builtin_ia32_cvtps2qq512_mask:
6859 case X86::BI__builtin_ia32_cvtps2udq512_mask:
6860 case X86::BI__builtin_ia32_cvtps2uqq512_mask:
6861 case X86::BI__builtin_ia32_cvtqq2pd512_mask:
6862 case X86::BI__builtin_ia32_cvtqq2ps512_mask:
6863 case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
6864 case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
6865 case X86::BI__builtin_ia32_vcvtdq2ph512_mask:
6866 case X86::BI__builtin_ia32_vcvtudq2ph512_mask:
6867 case X86::BI__builtin_ia32_vcvtw2ph512_mask:
6868 case X86::BI__builtin_ia32_vcvtuw2ph512_mask:
6869 case X86::BI__builtin_ia32_vcvtph2w512_mask:
6870 case X86::BI__builtin_ia32_vcvtph2uw512_mask:
6871 case X86::BI__builtin_ia32_vcvtph2dq512_mask:
6872 case X86::BI__builtin_ia32_vcvtph2udq512_mask:
6873 case X86::BI__builtin_ia32_vcvtph2qq512_mask:
6874 case X86::BI__builtin_ia32_vcvtph2uqq512_mask:
6875 case X86::BI__builtin_ia32_vcvtqq2ph512_mask:
6876 case X86::BI__builtin_ia32_vcvtuqq2ph512_mask:
6880 case X86::BI__builtin_ia32_addsh_round_mask:
6881 case X86::BI__builtin_ia32_addss_round_mask:
6882 case X86::BI__builtin_ia32_addsd_round_mask:
6883 case X86::BI__builtin_ia32_divsh_round_mask:
6884 case X86::BI__builtin_ia32_divss_round_mask:
6885 case X86::BI__builtin_ia32_divsd_round_mask:
6886 case X86::BI__builtin_ia32_mulsh_round_mask:
6887 case X86::BI__builtin_ia32_mulss_round_mask:
6888 case X86::BI__builtin_ia32_mulsd_round_mask:
6889 case X86::BI__builtin_ia32_subsh_round_mask:
6890 case X86::BI__builtin_ia32_subss_round_mask:
6891 case X86::BI__builtin_ia32_subsd_round_mask:
6892 case X86::BI__builtin_ia32_scalefph512_mask:
6893 case X86::BI__builtin_ia32_scalefpd512_mask:
6894 case X86::BI__builtin_ia32_scalefps512_mask:
6895 case X86::BI__builtin_ia32_scalefsd_round_mask:
6896 case X86::BI__builtin_ia32_scalefss_round_mask:
6897 case X86::BI__builtin_ia32_scalefsh_round_mask:
6898 case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
6899 case X86::BI__builtin_ia32_vcvtss2sh_round_mask:
6900 case X86::BI__builtin_ia32_vcvtsd2sh_round_mask:
6901 case X86::BI__builtin_ia32_sqrtsd_round_mask:
6902 case X86::BI__builtin_ia32_sqrtss_round_mask:
6903 case X86::BI__builtin_ia32_sqrtsh_round_mask:
6904 case X86::BI__builtin_ia32_vfmaddsd3_mask:
6905 case X86::BI__builtin_ia32_vfmaddsd3_maskz:
6906 case X86::BI__builtin_ia32_vfmaddsd3_mask3:
6907 case X86::BI__builtin_ia32_vfmaddss3_mask:
6908 case X86::BI__builtin_ia32_vfmaddss3_maskz:
6909 case X86::BI__builtin_ia32_vfmaddss3_mask3:
6910 case X86::BI__builtin_ia32_vfmaddsh3_mask:
6911 case X86::BI__builtin_ia32_vfmaddsh3_maskz:
6912 case X86::BI__builtin_ia32_vfmaddsh3_mask3:
6913 case X86::BI__builtin_ia32_vfmaddpd512_mask:
6914 case X86::BI__builtin_ia32_vfmaddpd512_maskz:
6915 case X86::BI__builtin_ia32_vfmaddpd512_mask3:
6916 case X86::BI__builtin_ia32_vfmsubpd512_mask3:
6917 case X86::BI__builtin_ia32_vfmaddps512_mask:
6918 case X86::BI__builtin_ia32_vfmaddps512_maskz:
6919 case X86::BI__builtin_ia32_vfmaddps512_mask3:
6920 case X86::BI__builtin_ia32_vfmsubps512_mask3:
6921 case X86::BI__builtin_ia32_vfmaddph512_mask:
6922 case X86::BI__builtin_ia32_vfmaddph512_maskz:
6923 case X86::BI__builtin_ia32_vfmaddph512_mask3:
6924 case X86::BI__builtin_ia32_vfmsubph512_mask3:
6925 case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
6926 case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
6927 case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
6928 case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
6929 case X86::BI__builtin_ia32_vfmaddsubps512_mask:
6930 case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
6931 case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
6932 case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
6933 case X86::BI__builtin_ia32_vfmaddsubph512_mask:
6934 case X86::BI__builtin_ia32_vfmaddsubph512_maskz:
6935 case X86::BI__builtin_ia32_vfmaddsubph512_mask3:
6936 case X86::BI__builtin_ia32_vfmsubaddph512_mask3:
6937 case X86::BI__builtin_ia32_vfmaddcsh_mask:
6938 case X86::BI__builtin_ia32_vfmaddcsh_round_mask:
6939 case X86::BI__builtin_ia32_vfmaddcsh_round_mask3:
6940 case X86::BI__builtin_ia32_vfmaddcph512_mask:
6941 case X86::BI__builtin_ia32_vfmaddcph512_maskz:
6942 case X86::BI__builtin_ia32_vfmaddcph512_mask3:
6943 case X86::BI__builtin_ia32_vfcmaddcsh_mask:
6944 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask:
6945 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask3:
6946 case X86::BI__builtin_ia32_vfcmaddcph512_mask:
6947 case X86::BI__builtin_ia32_vfcmaddcph512_maskz:
6948 case X86::BI__builtin_ia32_vfcmaddcph512_mask3:
6949 case X86::BI__builtin_ia32_vfmulcsh_mask:
6950 case X86::BI__builtin_ia32_vfmulcph512_mask:
6951 case X86::BI__builtin_ia32_vfcmulcsh_mask:
6952 case X86::BI__builtin_ia32_vfcmulcph512_mask:
6966 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
6975 (!HasRC &&
Result == 12) ||
6976 (HasRC &&
Result.getZExtValue() >= 8 &&
Result.getZExtValue() <= 11))
6979 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
6984bool Sema::CheckX86BuiltinGatherScatterScale(
unsigned BuiltinID,
6986 unsigned ArgNum = 0;
6987 switch (BuiltinID) {
6990 case X86::BI__builtin_ia32_gatherpfdpd:
6991 case X86::BI__builtin_ia32_gatherpfdps:
6992 case X86::BI__builtin_ia32_gatherpfqpd:
6993 case X86::BI__builtin_ia32_gatherpfqps:
6994 case X86::BI__builtin_ia32_scatterpfdpd:
6995 case X86::BI__builtin_ia32_scatterpfdps:
6996 case X86::BI__builtin_ia32_scatterpfqpd:
6997 case X86::BI__builtin_ia32_scatterpfqps:
7000 case X86::BI__builtin_ia32_gatherd_pd:
7001 case X86::BI__builtin_ia32_gatherd_pd256:
7002 case X86::BI__builtin_ia32_gatherq_pd:
7003 case X86::BI__builtin_ia32_gatherq_pd256:
7004 case X86::BI__builtin_ia32_gatherd_ps:
7005 case X86::BI__builtin_ia32_gatherd_ps256:
7006 case X86::BI__builtin_ia32_gatherq_ps:
7007 case X86::BI__builtin_ia32_gatherq_ps256:
7008 case X86::BI__builtin_ia32_gatherd_q:
7009 case X86::BI__builtin_ia32_gatherd_q256:
7010 case X86::BI__builtin_ia32_gatherq_q:
7011 case X86::BI__builtin_ia32_gatherq_q256:
7012 case X86::BI__builtin_ia32_gatherd_d:
7013 case X86::BI__builtin_ia32_gatherd_d256:
7014 case X86::BI__builtin_ia32_gatherq_d:
7015 case X86::BI__builtin_ia32_gatherq_d256:
7016 case X86::BI__builtin_ia32_gather3div2df:
7017 case X86::BI__builtin_ia32_gather3div2di:
7018 case X86::BI__builtin_ia32_gather3div4df:
7019 case X86::BI__builtin_ia32_gather3div4di:
7020 case X86::BI__builtin_ia32_gather3div4sf:
7021 case X86::BI__builtin_ia32_gather3div4si:
7022 case X86::BI__builtin_ia32_gather3div8sf:
7023 case X86::BI__builtin_ia32_gather3div8si:
7024 case X86::BI__builtin_ia32_gather3siv2df:
7025 case X86::BI__builtin_ia32_gather3siv2di:
7026 case X86::BI__builtin_ia32_gather3siv4df:
7027 case X86::BI__builtin_ia32_gather3siv4di:
7028 case X86::BI__builtin_ia32_gather3siv4sf:
7029 case X86::BI__builtin_ia32_gather3siv4si:
7030 case X86::BI__builtin_ia32_gather3siv8sf:
7031 case X86::BI__builtin_ia32_gather3siv8si:
7032 case X86::BI__builtin_ia32_gathersiv8df:
7033 case X86::BI__builtin_ia32_gathersiv16sf:
7034 case X86::BI__builtin_ia32_gatherdiv8df:
7035 case X86::BI__builtin_ia32_gatherdiv16sf:
7036 case X86::BI__builtin_ia32_gathersiv8di:
7037 case X86::BI__builtin_ia32_gathersiv16si:
7038 case X86::BI__builtin_ia32_gatherdiv8di:
7039 case X86::BI__builtin_ia32_gatherdiv16si:
7040 case X86::BI__builtin_ia32_scatterdiv2df:
7041 case X86::BI__builtin_ia32_scatterdiv2di:
7042 case X86::BI__builtin_ia32_scatterdiv4df:
7043 case X86::BI__builtin_ia32_scatterdiv4di:
7044 case X86::BI__builtin_ia32_scatterdiv4sf:
7045 case X86::BI__builtin_ia32_scatterdiv4si:
7046 case X86::BI__builtin_ia32_scatterdiv8sf:
7047 case X86::BI__builtin_ia32_scatterdiv8si:
7048 case X86::BI__builtin_ia32_scattersiv2df:
7049 case X86::BI__builtin_ia32_scattersiv2di:
7050 case X86::BI__builtin_ia32_scattersiv4df:
7051 case X86::BI__builtin_ia32_scattersiv4di:
7052 case X86::BI__builtin_ia32_scattersiv4sf:
7053 case X86::BI__builtin_ia32_scattersiv4si:
7054 case X86::BI__builtin_ia32_scattersiv8sf:
7055 case X86::BI__builtin_ia32_scattersiv8si:
7056 case X86::BI__builtin_ia32_scattersiv8df:
7057 case X86::BI__builtin_ia32_scattersiv16sf:
7058 case X86::BI__builtin_ia32_scatterdiv8df:
7059 case X86::BI__builtin_ia32_scatterdiv16sf:
7060 case X86::BI__builtin_ia32_scattersiv8di:
7061 case X86::BI__builtin_ia32_scattersiv16si:
7062 case X86::BI__builtin_ia32_scatterdiv8di:
7063 case X86::BI__builtin_ia32_scatterdiv16si:
7076 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
7082 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_scale)
7088bool Sema::CheckX86BuiltinTileArgumentsRange(
CallExpr *TheCall,
7090 for (
int ArgNum : ArgNums) {
7097bool Sema::CheckX86BuiltinTileDuplicate(
CallExpr *TheCall,
7101 std::bitset<TileRegHigh + 1> ArgValues;
7102 for (
int ArgNum : ArgNums) {
7108 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
7110 int ArgExtValue =
Result.getExtValue();
7112 "Incorrect tile register num.");
7113 if (ArgValues.test(ArgExtValue))
7115 diag::err_x86_builtin_tile_arg_duplicate)
7117 ArgValues.set(ArgExtValue);
7122bool Sema::CheckX86BuiltinTileRangeAndDuplicate(
CallExpr *TheCall,
7124 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
7125 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
7128bool Sema::CheckX86BuiltinTileArguments(
unsigned BuiltinID,
CallExpr *TheCall) {
7129 switch (BuiltinID) {
7132 case X86::BI__builtin_ia32_tileloadd64:
7133 case X86::BI__builtin_ia32_tileloaddt164:
7134 case X86::BI__builtin_ia32_tilestored64:
7135 case X86::BI__builtin_ia32_tilezero:
7136 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
7137 case X86::BI__builtin_ia32_tdpbssd:
7138 case X86::BI__builtin_ia32_tdpbsud:
7139 case X86::BI__builtin_ia32_tdpbusd:
7140 case X86::BI__builtin_ia32_tdpbuud:
7141 case X86::BI__builtin_ia32_tdpbf16ps:
7142 case X86::BI__builtin_ia32_tdpfp16ps:
7143 case X86::BI__builtin_ia32_tcmmimfp16ps:
7144 case X86::BI__builtin_ia32_tcmmrlfp16ps:
7145 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
7150 switch (BuiltinID) {
7151 case X86::BI__builtin_ia32_readeflags_u32:
7152 case X86::BI__builtin_ia32_writeeflags_u32:
7159bool Sema::CheckX86BuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
7162 const llvm::Triple &TT = TI.
getTriple();
7165 diag::err_32_bit_builtin_64_bit_tgt);
7168 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
7172 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
7176 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
7181 int i = 0, l = 0, u = 0;
7182 switch (BuiltinID) {
7185 case X86::BI__builtin_ia32_vec_ext_v2si:
7186 case X86::BI__builtin_ia32_vec_ext_v2di:
7187 case X86::BI__builtin_ia32_vextractf128_pd256:
7188 case X86::BI__builtin_ia32_vextractf128_ps256:
7189 case X86::BI__builtin_ia32_vextractf128_si256:
7190 case X86::BI__builtin_ia32_extract128i256:
7191 case X86::BI__builtin_ia32_extractf64x4_mask:
7192 case X86::BI__builtin_ia32_extracti64x4_mask:
7193 case X86::BI__builtin_ia32_extractf32x8_mask:
7194 case X86::BI__builtin_ia32_extracti32x8_mask:
7195 case X86::BI__builtin_ia32_extractf64x2_256_mask:
7196 case X86::BI__builtin_ia32_extracti64x2_256_mask:
7197 case X86::BI__builtin_ia32_extractf32x4_256_mask:
7198 case X86::BI__builtin_ia32_extracti32x4_256_mask:
7199 i = 1; l = 0; u = 1;
7201 case X86::BI__builtin_ia32_vec_set_v2di:
7202 case X86::BI__builtin_ia32_vinsertf128_pd256:
7203 case X86::BI__builtin_ia32_vinsertf128_ps256:
7204 case X86::BI__builtin_ia32_vinsertf128_si256:
7205 case X86::BI__builtin_ia32_insert128i256:
7206 case X86::BI__builtin_ia32_insertf32x8:
7207 case X86::BI__builtin_ia32_inserti32x8:
7208 case X86::BI__builtin_ia32_insertf64x4:
7209 case X86::BI__builtin_ia32_inserti64x4:
7210 case X86::BI__builtin_ia32_insertf64x2_256:
7211 case X86::BI__builtin_ia32_inserti64x2_256:
7212 case X86::BI__builtin_ia32_insertf32x4_256:
7213 case X86::BI__builtin_ia32_inserti32x4_256:
7214 i = 2; l = 0; u = 1;
7216 case X86::BI__builtin_ia32_vpermilpd:
7217 case X86::BI__builtin_ia32_vec_ext_v4hi:
7218 case X86::BI__builtin_ia32_vec_ext_v4si:
7219 case X86::BI__builtin_ia32_vec_ext_v4sf:
7220 case X86::BI__builtin_ia32_vec_ext_v4di:
7221 case X86::BI__builtin_ia32_extractf32x4_mask:
7222 case X86::BI__builtin_ia32_extracti32x4_mask:
7223 case X86::BI__builtin_ia32_extractf64x2_512_mask:
7224 case X86::BI__builtin_ia32_extracti64x2_512_mask:
7225 i = 1; l = 0; u = 3;
7227 case X86::BI_mm_prefetch:
7228 case X86::BI__builtin_ia32_vec_ext_v8hi:
7229 case X86::BI__builtin_ia32_vec_ext_v8si:
7230 i = 1; l = 0; u = 7;
7232 case X86::BI__builtin_ia32_sha1rnds4:
7233 case X86::BI__builtin_ia32_blendpd:
7234 case X86::BI__builtin_ia32_shufpd:
7235 case X86::BI__builtin_ia32_vec_set_v4hi:
7236 case X86::BI__builtin_ia32_vec_set_v4si:
7237 case X86::BI__builtin_ia32_vec_set_v4di:
7238 case X86::BI__builtin_ia32_shuf_f32x4_256:
7239 case X86::BI__builtin_ia32_shuf_f64x2_256:
7240 case X86::BI__builtin_ia32_shuf_i32x4_256:
7241 case X86::BI__builtin_ia32_shuf_i64x2_256:
7242 case X86::BI__builtin_ia32_insertf64x2_512:
7243 case X86::BI__builtin_ia32_inserti64x2_512:
7244 case X86::BI__builtin_ia32_insertf32x4:
7245 case X86::BI__builtin_ia32_inserti32x4:
7246 i = 2; l = 0; u = 3;
7248 case X86::BI__builtin_ia32_vpermil2pd:
7249 case X86::BI__builtin_ia32_vpermil2pd256:
7250 case X86::BI__builtin_ia32_vpermil2ps:
7251 case X86::BI__builtin_ia32_vpermil2ps256:
7252 i = 3; l = 0; u = 3;
7254 case X86::BI__builtin_ia32_cmpb128_mask:
7255 case X86::BI__builtin_ia32_cmpw128_mask:
7256 case X86::BI__builtin_ia32_cmpd128_mask:
7257 case X86::BI__builtin_ia32_cmpq128_mask:
7258 case X86::BI__builtin_ia32_cmpb256_mask:
7259 case X86::BI__builtin_ia32_cmpw256_mask:
7260 case X86::BI__builtin_ia32_cmpd256_mask:
7261 case X86::BI__builtin_ia32_cmpq256_mask:
7262 case X86::BI__builtin_ia32_cmpb512_mask:
7263 case X86::BI__builtin_ia32_cmpw512_mask:
7264 case X86::BI__builtin_ia32_cmpd512_mask:
7265 case X86::BI__builtin_ia32_cmpq512_mask:
7266 case X86::BI__builtin_ia32_ucmpb128_mask:
7267 case X86::BI__builtin_ia32_ucmpw128_mask:
7268 case X86::BI__builtin_ia32_ucmpd128_mask:
7269 case X86::BI__builtin_ia32_ucmpq128_mask:
7270 case X86::BI__builtin_ia32_ucmpb256_mask:
7271 case X86::BI__builtin_ia32_ucmpw256_mask:
7272 case X86::BI__builtin_ia32_ucmpd256_mask:
7273 case X86::BI__builtin_ia32_ucmpq256_mask:
7274 case X86::BI__builtin_ia32_ucmpb512_mask:
7275 case X86::BI__builtin_ia32_ucmpw512_mask:
7276 case X86::BI__builtin_ia32_ucmpd512_mask:
7277 case X86::BI__builtin_ia32_ucmpq512_mask:
7278 case X86::BI__builtin_ia32_vpcomub:
7279 case X86::BI__builtin_ia32_vpcomuw:
7280 case X86::BI__builtin_ia32_vpcomud:
7281 case X86::BI__builtin_ia32_vpcomuq:
7282 case X86::BI__builtin_ia32_vpcomb:
7283 case X86::BI__builtin_ia32_vpcomw:
7284 case X86::BI__builtin_ia32_vpcomd:
7285 case X86::BI__builtin_ia32_vpcomq:
7286 case X86::BI__builtin_ia32_vec_set_v8hi:
7287 case X86::BI__builtin_ia32_vec_set_v8si:
7288 i = 2; l = 0; u = 7;
7290 case X86::BI__builtin_ia32_vpermilpd256:
7291 case X86::BI__builtin_ia32_roundps:
7292 case X86::BI__builtin_ia32_roundpd:
7293 case X86::BI__builtin_ia32_roundps256:
7294 case X86::BI__builtin_ia32_roundpd256:
7295 case X86::BI__builtin_ia32_getmantpd128_mask:
7296 case X86::BI__builtin_ia32_getmantpd256_mask:
7297 case X86::BI__builtin_ia32_getmantps128_mask:
7298 case X86::BI__builtin_ia32_getmantps256_mask:
7299 case X86::BI__builtin_ia32_getmantpd512_mask:
7300 case X86::BI__builtin_ia32_getmantps512_mask:
7301 case X86::BI__builtin_ia32_getmantph128_mask:
7302 case X86::BI__builtin_ia32_getmantph256_mask:
7303 case X86::BI__builtin_ia32_getmantph512_mask:
7304 case X86::BI__builtin_ia32_vec_ext_v16qi:
7305 case X86::BI__builtin_ia32_vec_ext_v16hi:
7306 i = 1; l = 0; u = 15;
7308 case X86::BI__builtin_ia32_pblendd128:
7309 case X86::BI__builtin_ia32_blendps:
7310 case X86::BI__builtin_ia32_blendpd256:
7311 case X86::BI__builtin_ia32_shufpd256:
7312 case X86::BI__builtin_ia32_roundss:
7313 case X86::BI__builtin_ia32_roundsd:
7314 case X86::BI__builtin_ia32_rangepd128_mask:
7315 case X86::BI__builtin_ia32_rangepd256_mask:
7316 case X86::BI__builtin_ia32_rangepd512_mask:
7317 case X86::BI__builtin_ia32_rangeps128_mask:
7318 case X86::BI__builtin_ia32_rangeps256_mask:
7319 case X86::BI__builtin_ia32_rangeps512_mask:
7320 case X86::BI__builtin_ia32_getmantsd_round_mask:
7321 case X86::BI__builtin_ia32_getmantss_round_mask:
7322 case X86::BI__builtin_ia32_getmantsh_round_mask:
7323 case X86::BI__builtin_ia32_vec_set_v16qi:
7324 case X86::BI__builtin_ia32_vec_set_v16hi:
7325 i = 2; l = 0; u = 15;
7327 case X86::BI__builtin_ia32_vec_ext_v32qi:
7328 i = 1; l = 0; u = 31;
7330 case X86::BI__builtin_ia32_cmpps:
7331 case X86::BI__builtin_ia32_cmpss:
7332 case X86::BI__builtin_ia32_cmppd:
7333 case X86::BI__builtin_ia32_cmpsd:
7334 case X86::BI__builtin_ia32_cmpps256:
7335 case X86::BI__builtin_ia32_cmppd256:
7336 case X86::BI__builtin_ia32_cmpps128_mask:
7337 case X86::BI__builtin_ia32_cmppd128_mask:
7338 case X86::BI__builtin_ia32_cmpps256_mask:
7339 case X86::BI__builtin_ia32_cmppd256_mask:
7340 case X86::BI__builtin_ia32_cmpps512_mask:
7341 case X86::BI__builtin_ia32_cmppd512_mask:
7342 case X86::BI__builtin_ia32_cmpsd_mask:
7343 case X86::BI__builtin_ia32_cmpss_mask:
7344 case X86::BI__builtin_ia32_vec_set_v32qi:
7345 i = 2; l = 0; u = 31;
7347 case X86::BI__builtin_ia32_permdf256:
7348 case X86::BI__builtin_ia32_permdi256:
7349 case X86::BI__builtin_ia32_permdf512:
7350 case X86::BI__builtin_ia32_permdi512:
7351 case X86::BI__builtin_ia32_vpermilps:
7352 case X86::BI__builtin_ia32_vpermilps256:
7353 case X86::BI__builtin_ia32_vpermilpd512:
7354 case X86::BI__builtin_ia32_vpermilps512:
7355 case X86::BI__builtin_ia32_pshufd:
7356 case X86::BI__builtin_ia32_pshufd256:
7357 case X86::BI__builtin_ia32_pshufd512:
7358 case X86::BI__builtin_ia32_pshufhw:
7359 case X86::BI__builtin_ia32_pshufhw256:
7360 case X86::BI__builtin_ia32_pshufhw512:
7361 case X86::BI__builtin_ia32_pshuflw:
7362 case X86::BI__builtin_ia32_pshuflw256:
7363 case X86::BI__builtin_ia32_pshuflw512:
7364 case X86::BI__builtin_ia32_vcvtps2ph:
7365 case X86::BI__builtin_ia32_vcvtps2ph_mask:
7366 case X86::BI__builtin_ia32_vcvtps2ph256:
7367 case X86::BI__builtin_ia32_vcvtps2ph256_mask:
7368 case X86::BI__builtin_ia32_vcvtps2ph512_mask:
7369 case X86::BI__builtin_ia32_rndscaleps_128_mask:
7370 case X86::BI__builtin_ia32_rndscalepd_128_mask:
7371 case X86::BI__builtin_ia32_rndscaleps_256_mask:
7372 case X86::BI__builtin_ia32_rndscalepd_256_mask:
7373 case X86::BI__builtin_ia32_rndscaleps_mask:
7374 case X86::BI__builtin_ia32_rndscalepd_mask:
7375 case X86::BI__builtin_ia32_rndscaleph_mask:
7376 case X86::BI__builtin_ia32_reducepd128_mask:
7377 case X86::BI__builtin_ia32_reducepd256_mask:
7378 case X86::BI__builtin_ia32_reducepd512_mask:
7379 case X86::BI__builtin_ia32_reduceps128_mask:
7380 case X86::BI__builtin_ia32_reduceps256_mask:
7381 case X86::BI__builtin_ia32_reduceps512_mask:
7382 case X86::BI__builtin_ia32_reduceph128_mask:
7383 case X86::BI__builtin_ia32_reduceph256_mask:
7384 case X86::BI__builtin_ia32_reduceph512_mask:
7385 case X86::BI__builtin_ia32_prold512:
7386 case X86::BI__builtin_ia32_prolq512:
7387 case X86::BI__builtin_ia32_prold128:
7388 case X86::BI__builtin_ia32_prold256:
7389 case X86::BI__builtin_ia32_prolq128:
7390 case X86::BI__builtin_ia32_prolq256:
7391 case X86::BI__builtin_ia32_prord512:
7392 case X86::BI__builtin_ia32_prorq512:
7393 case X86::BI__builtin_ia32_prord128:
7394 case X86::BI__builtin_ia32_prord256:
7395 case X86::BI__builtin_ia32_prorq128:
7396 case X86::BI__builtin_ia32_prorq256:
7397 case X86::BI__builtin_ia32_fpclasspd128_mask:
7398 case X86::BI__builtin_ia32_fpclasspd256_mask:
7399 case X86::BI__builtin_ia32_fpclassps128_mask:
7400 case X86::BI__builtin_ia32_fpclassps256_mask:
7401 case X86::BI__builtin_ia32_fpclassps512_mask:
7402 case X86::BI__builtin_ia32_fpclasspd512_mask:
7403 case X86::BI__builtin_ia32_fpclassph128_mask:
7404 case X86::BI__builtin_ia32_fpclassph256_mask:
7405 case X86::BI__builtin_ia32_fpclassph512_mask:
7406 case X86::BI__builtin_ia32_fpclasssd_mask:
7407 case X86::BI__builtin_ia32_fpclassss_mask:
7408 case X86::BI__builtin_ia32_fpclasssh_mask:
7409 case X86::BI__builtin_ia32_pslldqi128_byteshift:
7410 case X86::BI__builtin_ia32_pslldqi256_byteshift:
7411 case X86::BI__builtin_ia32_pslldqi512_byteshift:
7412 case X86::BI__builtin_ia32_psrldqi128_byteshift:
7413 case X86::BI__builtin_ia32_psrldqi256_byteshift:
7414 case X86::BI__builtin_ia32_psrldqi512_byteshift:
7415 case X86::BI__builtin_ia32_kshiftliqi:
7416 case X86::BI__builtin_ia32_kshiftlihi:
7417 case X86::BI__builtin_ia32_kshiftlisi:
7418 case X86::BI__builtin_ia32_kshiftlidi:
7419 case X86::BI__builtin_ia32_kshiftriqi:
7420 case X86::BI__builtin_ia32_kshiftrihi:
7421 case X86::BI__builtin_ia32_kshiftrisi:
7422 case X86::BI__builtin_ia32_kshiftridi:
7423 i = 1; l = 0; u = 255;
7425 case X86::BI__builtin_ia32_vperm2f128_pd256:
7426 case X86::BI__builtin_ia32_vperm2f128_ps256:
7427 case X86::BI__builtin_ia32_vperm2f128_si256:
7428 case X86::BI__builtin_ia32_permti256:
7429 case X86::BI__builtin_ia32_pblendw128:
7430 case X86::BI__builtin_ia32_pblendw256:
7431 case X86::BI__builtin_ia32_blendps256:
7432 case X86::BI__builtin_ia32_pblendd256:
7433 case X86::BI__builtin_ia32_palignr128:
7434 case X86::BI__builtin_ia32_palignr256:
7435 case X86::BI__builtin_ia32_palignr512:
7436 case X86::BI__builtin_ia32_alignq512:
7437 case X86::BI__builtin_ia32_alignd512:
7438 case X86::BI__builtin_ia32_alignd128:
7439 case X86::BI__builtin_ia32_alignd256:
7440 case X86::BI__builtin_ia32_alignq128:
7441 case X86::BI__builtin_ia32_alignq256:
7442 case X86::BI__builtin_ia32_vcomisd:
7443 case X86::BI__builtin_ia32_vcomiss:
7444 case X86::BI__builtin_ia32_shuf_f32x4:
7445 case X86::BI__builtin_ia32_shuf_f64x2:
7446 case X86::BI__builtin_ia32_shuf_i32x4:
7447 case X86::BI__builtin_ia32_shuf_i64x2:
7448 case X86::BI__builtin_ia32_shufpd512:
7449 case X86::BI__builtin_ia32_shufps:
7450 case X86::BI__builtin_ia32_shufps256:
7451 case X86::BI__builtin_ia32_shufps512:
7452 case X86::BI__builtin_ia32_dbpsadbw128:
7453 case X86::BI__builtin_ia32_dbpsadbw256:
7454 case X86::BI__builtin_ia32_dbpsadbw512:
7455 case X86::BI__builtin_ia32_vpshldd128:
7456 case X86::BI__builtin_ia32_vpshldd256:
7457 case X86::BI__builtin_ia32_vpshldd512:
7458 case X86::BI__builtin_ia32_vpshldq128:
7459 case X86::BI__builtin_ia32_vpshldq256:
7460 case X86::BI__builtin_ia32_vpshldq512:
7461 case X86::BI__builtin_ia32_vpshldw128:
7462 case X86::BI__builtin_ia32_vpshldw256:
7463 case X86::BI__builtin_ia32_vpshldw512:
7464 case X86::BI__builtin_ia32_vpshrdd128:
7465 case X86::BI__builtin_ia32_vpshrdd256:
7466 case X86::BI__builtin_ia32_vpshrdd512:
7467 case X86::BI__builtin_ia32_vpshrdq128:
7468 case X86::BI__builtin_ia32_vpshrdq256:
7469 case X86::BI__builtin_ia32_vpshrdq512:
7470 case X86::BI__builtin_ia32_vpshrdw128:
7471 case X86::BI__builtin_ia32_vpshrdw256:
7472 case X86::BI__builtin_ia32_vpshrdw512:
7473 i = 2; l = 0; u = 255;
7475 case X86::BI__builtin_ia32_fixupimmpd512_mask:
7476 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
7477 case X86::BI__builtin_ia32_fixupimmps512_mask:
7478 case X86::BI__builtin_ia32_fixupimmps512_maskz:
7479 case X86::BI__builtin_ia32_fixupimmsd_mask:
7480 case X86::BI__builtin_ia32_fixupimmsd_maskz:
7481 case X86::BI__builtin_ia32_fixupimmss_mask:
7482 case X86::BI__builtin_ia32_fixupimmss_maskz:
7483 case X86::BI__builtin_ia32_fixupimmpd128_mask:
7484 case X86::BI__builtin_ia32_fixupimmpd128_maskz:
7485 case X86::BI__builtin_ia32_fixupimmpd256_mask:
7486 case X86::BI__builtin_ia32_fixupimmpd256_maskz:
7487 case X86::BI__builtin_ia32_fixupimmps128_mask:
7488 case X86::BI__builtin_ia32_fixupimmps128_maskz:
7489 case X86::BI__builtin_ia32_fixupimmps256_mask:
7490 case X86::BI__builtin_ia32_fixupimmps256_maskz:
7491 case X86::BI__builtin_ia32_pternlogd512_mask:
7492 case X86::BI__builtin_ia32_pternlogd512_maskz:
7493 case X86::BI__builtin_ia32_pternlogq512_mask:
7494 case X86::BI__builtin_ia32_pternlogq512_maskz:
7495 case X86::BI__builtin_ia32_pternlogd128_mask:
7496 case X86::BI__builtin_ia32_pternlogd128_maskz:
7497 case X86::BI__builtin_ia32_pternlogd256_mask:
7498 case X86::BI__builtin_ia32_pternlogd256_maskz:
7499 case X86::BI__builtin_ia32_pternlogq128_mask:
7500 case X86::BI__builtin_ia32_pternlogq128_maskz:
7501 case X86::BI__builtin_ia32_pternlogq256_mask:
7502 case X86::BI__builtin_ia32_pternlogq256_maskz:
7503 case X86::BI__builtin_ia32_vsm3rnds2:
7504 i = 3; l = 0; u = 255;
7506 case X86::BI__builtin_ia32_gatherpfdpd:
7507 case X86::BI__builtin_ia32_gatherpfdps:
7508 case X86::BI__builtin_ia32_gatherpfqpd:
7509 case X86::BI__builtin_ia32_gatherpfqps:
7510 case X86::BI__builtin_ia32_scatterpfdpd:
7511 case X86::BI__builtin_ia32_scatterpfdps:
7512 case X86::BI__builtin_ia32_scatterpfqpd:
7513 case X86::BI__builtin_ia32_scatterpfqps:
7514 i = 4; l = 2; u = 3;
7516 case X86::BI__builtin_ia32_reducesd_mask:
7517 case X86::BI__builtin_ia32_reducess_mask:
7518 case X86::BI__builtin_ia32_rndscalesd_round_mask:
7519 case X86::BI__builtin_ia32_rndscaless_round_mask:
7520 case X86::BI__builtin_ia32_rndscalesh_round_mask:
7521 case X86::BI__builtin_ia32_reducesh_mask:
7522 i = 4; l = 0; u = 255;
7524 case X86::BI__builtin_ia32_cmpccxadd32:
7525 case X86::BI__builtin_ia32_cmpccxadd64:
7526 i = 3; l = 0; u = 15;
7534 return SemaBuiltinConstantArgRange(TheCall, i, l, u,
false);
7543 if (Format->getFirstArg() == 0)
7545 else if (IsVariadic)
7549 FSI->
FormatIdx = Format->getFormatIdx() - 1;
7580 if (
const auto *CLE = dyn_cast<CompoundLiteralExpr>(
Expr))
7581 if (
const auto *ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))
7582 Expr = ILE->getInit(0);
7592 const Expr *ArgExpr,
7596 S.
PDiag(diag::warn_null_arg)
7618 bool Format =
false;
7631 if (!Format || NumArgs <= Idx)
7633 const Expr *FormatExpr = Args[Idx];
7634 if (
const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
7635 FormatExpr = CSCE->getSubExpr();
7645 S.
Diag(FormatExpr->
getExprLoc(), diag::warn_objc_cdirective_format_string)
7654 if (
auto nullability =
type->getNullability())
7665 assert((FDecl || Proto) &&
"Need a function declaration or prototype");
7671 llvm::SmallBitVector NonNullArgs;
7677 for (
const auto *Arg : Args)
7684 unsigned IdxAST = Idx.getASTIndex();
7685 if (IdxAST >= Args.size())
7687 if (NonNullArgs.empty())
7688 NonNullArgs.resize(Args.size());
7689 NonNullArgs.set(IdxAST);
7694 if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
7698 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
7701 parms = cast<ObjCMethodDecl>(FDecl)->parameters();
7703 unsigned ParamIndex = 0;
7705 I != E; ++I, ++ParamIndex) {
7708 if (NonNullArgs.empty())
7709 NonNullArgs.resize(Args.size());
7711 NonNullArgs.set(ParamIndex);
7718 if (
const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
7723 type = blockType->getPointeeType();
7737 if (NonNullArgs.empty())
7738 NonNullArgs.resize(Args.size());
7740 NonNullArgs.set(Index);
7749 for (
unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
7750 ArgIndex != ArgIndexEnd; ++ArgIndex) {
7751 if (NonNullArgs[ArgIndex])
7764 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->
IgnoreParens());
7768 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
7772 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
7773 if (!PD || !PD->getType()->isRecordType())
7779 if (
const auto *AA = FD->
getAttr<AlignedAttr>()) {
7784 Diag(Loc, diag::note_misaligned_member_used_here) << PD;
7795 StringRef ParamName,
QualType ArgTy,
7823 if (ArgAlign < ParamAlign)
7824 Diag(Loc, diag::warn_param_mismatched_alignment)
7826 << ParamName << (FDecl !=
nullptr) << FDecl;
7841 llvm::SmallBitVector CheckedVarArgs;
7845 CheckedVarArgs.resize(Args.size());
7847 CheckFormatArguments(I, Args, IsMemberFunction, CallType, Loc, Range,
7854 auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
7858 : FDecl && isa<FunctionDecl>(FDecl)
7859 ? cast<FunctionDecl>(FDecl)->getNumParams()
7860 : FDecl && isa<ObjCMethodDecl>(FDecl)
7861 ? cast<ObjCMethodDecl>(FDecl)->param_size()
7864 for (
unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
7866 if (
const Expr *Arg = Args[ArgIdx]) {
7867 if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
7873 if (FDecl || Proto) {
7878 for (
const auto *I : FDecl->
specific_attrs<ArgumentWithTypeTagAttr>())
7879 CheckArgumentWithTypeTag(I, Args, Loc);
7885 if (!Proto && FDecl) {
7887 if (isa_and_nonnull<FunctionProtoType>(FT))
7893 const auto N = std::min<unsigned>(Proto->
getNumParams(), Args.size());
7894 for (
unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
7896 if (
const Expr *Arg = Args[ArgIdx]) {
7904 checkAIXMemberAlignment((Arg->
getExprLoc()), Arg);
7908 CheckArgAlignment(Arg->
getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
7917 if (
auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext)) {
7918 llvm::StringMap<bool> CallerFeatureMap;
7920 if (!CallerFeatureMap.contains(
"sme"))
7921 Diag(Loc, diag::err_sme_call_in_non_sme_target);
7923 Diag(Loc, diag::err_sme_call_in_non_sme_target);
7933 bool CallerHasZAState =
false;
7934 bool CallerHasZT0State =
false;
7935 if (
const auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext)) {
7936 auto *
Attr = CallerFD->getAttr<ArmNewAttr>();
7938 CallerHasZAState =
true;
7940 CallerHasZT0State =
true;
7944 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
7946 CallerHasZT0State |=
7948 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
7954 Diag(Loc, diag::err_sme_za_call_no_za_state);
7957 Diag(Loc, diag::err_sme_zt0_call_no_zt0_state);
7961 Diag(Loc, diag::err_sme_unimplemented_za_save_restore);
7962 Diag(Loc, diag::note_sme_use_preserves_za);
7967 if (FDecl && FDecl->
hasAttr<AllocAlignAttr>()) {
7968 auto *AA = FDecl->
getAttr<AllocAlignAttr>();
7969 const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
7970 if (!Arg->isValueDependent()) {
7972 if (Arg->EvaluateAsInt(Align,
Context)) {
7973 const llvm::APSInt &I = Align.
Val.
getInt();
7974 if (!I.isPowerOf2())
7975 Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
7976 << Arg->getSourceRange();
7979 Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
7998 auto *Ctor = cast<CXXConstructorDecl>(FDecl);
8003 checkCall(FDecl, Proto,
nullptr, Args,
true,
8011 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
8012 isa<CXXMethodDecl>(FDecl);
8013 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
8014 IsMemberOperatorCall;
8020 Expr *ImplicitThis =
nullptr;
8025 ImplicitThis = Args[0];
8028 }
else if (IsMemberFunction && !FDecl->
isStatic() &&
8031 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
8043 cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());
8045 CheckArgAlignment(TheCall->
getRParenLoc(), FDecl,
"'this'", ThisType,
8049 checkCall(FDecl, Proto, ImplicitThis,
llvm::ArrayRef(Args, NumArgs),
8061 CheckTCBEnforcement(TheCall->
getExprLoc(), FDecl);
8063 CheckAbsoluteValueFunction(TheCall, FDecl);
8064 CheckMaxUnsignedZero(TheCall, FDecl);
8065 CheckInfNaNFunction(TheCall, FDecl);
8076 case Builtin::BIstrlcpy:
8077 case Builtin::BIstrlcat:
8078 CheckStrlcpycatArguments(TheCall, FnInfo);
8080 case Builtin::BIstrncat:
8081 CheckStrncatArguments(TheCall, FnInfo);
8083 case Builtin::BIfree:
8084 CheckFreeArguments(TheCall);
8087 CheckMemaccessArguments(TheCall, CMId, FnInfo);
8098 checkCall(Method,
nullptr,
nullptr, Args,
8102 CheckTCBEnforcement(lbrac, Method);
8110 if (
const auto *
V = dyn_cast<VarDecl>(NDecl))
8111 Ty =
V->getType().getNonReferenceType();
8112 else if (
const auto *F = dyn_cast<FieldDecl>(NDecl))
8113 Ty = F->getType().getNonReferenceType();
8130 checkCall(NDecl, Proto,
nullptr,
8143 checkCall(
nullptr, Proto,
nullptr,
8152 if (!llvm::isValidAtomicOrderingCABI(Ordering))
8155 auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
8157 case AtomicExpr::AO__c11_atomic_init:
8158 case AtomicExpr::AO__opencl_atomic_init:
8159 llvm_unreachable(
"There is no ordering argument for an init");
8161 case AtomicExpr::AO__c11_atomic_load:
8162 case AtomicExpr::AO__opencl_atomic_load:
8163 case AtomicExpr::AO__hip_atomic_load:
8164 case AtomicExpr::AO__atomic_load_n:
8165 case AtomicExpr::AO__atomic_load:
8166 case AtomicExpr::AO__scoped_atomic_load_n:
8167 case AtomicExpr::AO__scoped_atomic_load:
8168 return OrderingCABI != llvm::AtomicOrderingCABI::release &&
8169 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8171 case AtomicExpr::AO__c11_atomic_store:
8172 case AtomicExpr::AO__opencl_atomic_store:
8173 case AtomicExpr::AO__hip_atomic_store:
8174 case AtomicExpr::AO__atomic_store:
8175 case AtomicExpr::AO__atomic_store_n:
8176 case AtomicExpr::AO__scoped_atomic_store:
8177 case AtomicExpr::AO__scoped_atomic_store_n:
8178 return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
8179 OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
8180 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8189 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
8233 const unsigned NumForm = GNUCmpXchg + 1;
8234 const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
8235 const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
8243 static_assert(
sizeof(NumArgs)/
sizeof(NumArgs[0]) == NumForm
8244 &&
sizeof(NumVals)/
sizeof(NumVals[0]) == NumForm,
8245 "need to update code for modified forms");
8246 static_assert(AtomicExpr::AO__atomic_add_fetch == 0 &&
8247 AtomicExpr::AO__atomic_xor_fetch + 1 ==
8248 AtomicExpr::AO__c11_atomic_compare_exchange_strong,
8249 "need to update code for modified C11 atomics");
8250 bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&
8251 Op <= AtomicExpr::AO__opencl_atomic_store;
8252 bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
8253 Op <= AtomicExpr::AO__hip_atomic_store;
8254 bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&
8255 Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;
8256 bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
8257 Op <= AtomicExpr::AO__c11_atomic_store) ||
8259 bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
8260 Op == AtomicExpr::AO__atomic_store_n ||
8261 Op == AtomicExpr::AO__atomic_exchange_n ||
8262 Op == AtomicExpr::AO__atomic_compare_exchange_n ||
8263 Op == AtomicExpr::AO__scoped_atomic_load_n ||
8264 Op == AtomicExpr::AO__scoped_atomic_store_n ||
8265 Op == AtomicExpr::AO__scoped_atomic_exchange_n ||
8266 Op == AtomicExpr::AO__scoped_atomic_compare_exchange_n;
8270 enum ArithOpExtraValueType {
8275 unsigned ArithAllows = AOEVT_None;
8278 case AtomicExpr::AO__c11_atomic_init:
8279 case AtomicExpr::AO__opencl_atomic_init:
8283 case AtomicExpr::AO__c11_atomic_load:
8284 case AtomicExpr::AO__opencl_atomic_load:
8285 case AtomicExpr::AO__hip_atomic_load:
8286 case AtomicExpr::AO__atomic_load_n:
8287 case AtomicExpr::AO__scoped_atomic_load_n:
8291 case AtomicExpr::AO__atomic_load:
8292 case AtomicExpr::AO__scoped_atomic_load:
8296 case AtomicExpr::AO__c11_atomic_store:
8297 case AtomicExpr::AO__opencl_atomic_store:
8298 case AtomicExpr::AO__hip_atomic_store:
8299 case AtomicExpr::AO__atomic_store:
8300 case AtomicExpr::AO__atomic_store_n:
8301 case AtomicExpr::AO__scoped_atomic_store:
8302 case AtomicExpr::AO__scoped_atomic_store_n:
8305 case AtomicExpr::AO__atomic_fetch_add:
8306 case AtomicExpr::AO__atomic_fetch_sub:
8307 case AtomicExpr::AO__atomic_add_fetch:
8308 case AtomicExpr::AO__atomic_sub_fetch:
8309 case AtomicExpr::AO__scoped_atomic_fetch_add:
8310 case AtomicExpr::AO__scoped_atomic_fetch_sub:
8311 case AtomicExpr::AO__scoped_atomic_add_fetch:
8312 case AtomicExpr::AO__scoped_atomic_sub_fetch:
8313 case AtomicExpr::AO__c11_atomic_fetch_add:
8314 case AtomicExpr::AO__c11_atomic_fetch_sub:
8315 case AtomicExpr::AO__opencl_atomic_fetch_add:
8316 case AtomicExpr::AO__opencl_atomic_fetch_sub:
8317 case AtomicExpr::AO__hip_atomic_fetch_add:
8318 case AtomicExpr::AO__hip_atomic_fetch_sub:
8319 ArithAllows = AOEVT_Pointer | AOEVT_FP;
8322 case AtomicExpr::AO__atomic_fetch_max:
8323 case AtomicExpr::AO__atomic_fetch_min:
8324 case AtomicExpr::AO__atomic_max_fetch:
8325 case AtomicExpr::AO__atomic_min_fetch:
8326 case AtomicExpr::AO__scoped_atomic_fetch_max:
8327 case AtomicExpr::AO__scoped_atomic_fetch_min:
8328 case AtomicExpr::AO__scoped_atomic_max_fetch:
8329 case AtomicExpr::AO__scoped_atomic_min_fetch:
8330 case AtomicExpr::AO__c11_atomic_fetch_max:
8331 case AtomicExpr::AO__c11_atomic_fetch_min:
8332 case AtomicExpr::AO__opencl_atomic_fetch_max:
8333 case AtomicExpr::AO__opencl_atomic_fetch_min:
8334 case AtomicExpr::AO__hip_atomic_fetch_max:
8335 case AtomicExpr::AO__hip_atomic_fetch_min:
8336 ArithAllows = AOEVT_FP;
8339 case AtomicExpr::AO__c11_atomic_fetch_and:
8340 case AtomicExpr::AO__c11_atomic_fetch_or:
8341 case AtomicExpr::AO__c11_atomic_fetch_xor:
8342 case AtomicExpr::AO__hip_atomic_fetch_and:
8343 case AtomicExpr::AO__hip_atomic_fetch_or:
8344 case AtomicExpr::AO__hip_atomic_fetch_xor:
8345 case AtomicExpr::AO__c11_atomic_fetch_nand:
8346 case AtomicExpr::AO__opencl_atomic_fetch_and:
8347 case AtomicExpr::AO__opencl_atomic_fetch_or:
8348 case AtomicExpr::AO__opencl_atomic_fetch_xor:
8349 case AtomicExpr::AO__atomic_fetch_and:
8350 case AtomicExpr::AO__atomic_fetch_or:
8351 case AtomicExpr::AO__atomic_fetch_xor:
8352 case AtomicExpr::AO__atomic_fetch_nand:
8353 case AtomicExpr::AO__atomic_and_fetch:
8354 case AtomicExpr::AO__atomic_or_fetch:
8355 case AtomicExpr::AO__atomic_xor_fetch:
8356 case AtomicExpr::AO__atomic_nand_fetch:
8357 case AtomicExpr::AO__scoped_atomic_fetch_and:
8358 case AtomicExpr::AO__scoped_atomic_fetch_or:
8359 case AtomicExpr::AO__scoped_atomic_fetch_xor:
8360 case AtomicExpr::AO__scoped_atomic_fetch_nand:
8361 case AtomicExpr::AO__scoped_atomic_and_fetch:
8362 case AtomicExpr::AO__scoped_atomic_or_fetch:
8363 case AtomicExpr::AO__scoped_atomic_xor_fetch:
8364 case AtomicExpr::AO__scoped_atomic_nand_fetch:
8368 case AtomicExpr::AO__c11_atomic_exchange:
8369 case AtomicExpr::AO__hip_atomic_exchange:
8370 case AtomicExpr::AO__opencl_atomic_exchange:
8371 case AtomicExpr::AO__atomic_exchange_n:
8372 case AtomicExpr::AO__scoped_atomic_exchange_n:
8376 case AtomicExpr::AO__atomic_exchange:
8377 case AtomicExpr::AO__scoped_atomic_exchange:
8381 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
8382 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
8383 case AtomicExpr::AO__hip_atomic_compare_exchange_strong:
8384 case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
8385 case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
8386 case AtomicExpr::AO__hip_atomic_compare_exchange_weak:
8390 case AtomicExpr::AO__atomic_compare_exchange:
8391 case AtomicExpr::AO__atomic_compare_exchange_n:
8392 case AtomicExpr::AO__scoped_atomic_compare_exchange:
8393 case AtomicExpr::AO__scoped_atomic_compare_exchange_n:
8398 unsigned AdjustedNumArgs = NumArgs[Form];
8399 if ((IsOpenCL || IsHIP || IsScoped) &&
8400 Op != AtomicExpr::AO__opencl_atomic_init)
8403 if (Args.size() < AdjustedNumArgs) {
8404 Diag(CallRange.
getEnd(), diag::err_typecheck_call_too_few_args)
8405 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8408 }
else if (Args.size() > AdjustedNumArgs) {
8409 Diag(Args[AdjustedNumArgs]->getBeginLoc(),
8410 diag::err_typecheck_call_too_many_args)
8411 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8417 Expr *Ptr = Args[0];
8422 Ptr = ConvertedPtr.
get();
8425 Diag(ExprRange.
getBegin(), diag::err_atomic_builtin_must_be_pointer)
8435 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic)
8441 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_atomic)
8447 }
else if (Form != Load && Form != LoadCopy) {
8449 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_pointer)
8456 if (Form == Arithmetic) {
8459 auto IsAllowedValueType = [&](
QualType ValType,
8460 unsigned AllowedType) ->
bool {
8464 return AllowedType & AOEVT_Pointer;
8470 &llvm::APFloat::x87DoubleExtended())
8474 if (!IsAllowedValueType(ValType, ArithAllows)) {
8475 auto DID = ArithAllows & AOEVT_FP
8476 ? (ArithAllows & AOEVT_Pointer
8477 ? diag::err_atomic_op_needs_atomic_int_ptr_or_fp
8478 : diag::err_atomic_op_needs_atomic_int_or_fp)
8479 : diag::err_atomic_op_needs_atomic_int;
8486 diag::err_incomplete_type)) {
8492 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
8503 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_trivial_copy)
8519 Diag(ExprRange.
getBegin(), diag::err_arc_atomic_ownership)
8531 if (Form ==
Copy || Form == LoadCopy || Form == GNUXchg ||
8534 else if (Form == C11CmpXchg || Form == GNUCmpXchg)
8540 bool IsPassedByAddress =
false;
8541 if (!IsC11 && !IsHIP && !IsN) {
8543 IsPassedByAddress =
true;
8548 APIOrderedArgs.push_back(Args[0]);
8552 APIOrderedArgs.push_back(Args[1]);
8558 APIOrderedArgs.push_back(Args[2]);
8559 APIOrderedArgs.push_back(Args[1]);
8562 APIOrderedArgs.push_back(Args[2]);
8563 APIOrderedArgs.push_back(Args[3]);
8564 APIOrderedArgs.push_back(Args[1]);
8567 APIOrderedArgs.push_back(Args[2]);
8568 APIOrderedArgs.push_back(Args[4]);
8569 APIOrderedArgs.push_back(Args[1]);
8570 APIOrderedArgs.push_back(Args[3]);
8573 APIOrderedArgs.push_back(Args[2]);
8574 APIOrderedArgs.push_back(Args[4]);
8575 APIOrderedArgs.push_back(Args[5]);
8576 APIOrderedArgs.push_back(Args[1]);
8577 APIOrderedArgs.push_back(Args[3]);
8581 APIOrderedArgs.append(Args.begin(), Args.end());
8588 for (
unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
8590 if (i < NumVals[Form] + 1) {
8603 assert(Form != Load);
8606 else if (Form ==
Init || Form == Arithmetic)
8608 else if (Form ==
Copy || Form == Xchg) {
8609 if (IsPassedByAddress) {
8616 Expr *ValArg = APIOrderedArgs[i];
8623 AS = PtrTy->getPointeeType().getAddressSpace();
8632 if (IsPassedByAddress)
8652 APIOrderedArgs[i] = Arg.
get();
8657 SubExprs.push_back(Ptr);
8661 SubExprs.push_back(APIOrderedArgs[1]);
8664 SubExprs.push_back(APIOrderedArgs[1]);
8670 SubExprs.push_back(APIOrderedArgs[2]);
8671 SubExprs.push_back(APIOrderedArgs[1]);
8675 SubExprs.push_back(APIOrderedArgs[3]);
8676 SubExprs.push_back(APIOrderedArgs[1]);
8677 SubExprs.push_back(APIOrderedArgs[2]);
8680 SubExprs.push_back(APIOrderedArgs[3]);
8681 SubExprs.push_back(APIOrderedArgs[1]);
8682 SubExprs.push_back(APIOrderedArgs[4]);
8683 SubExprs.push_back(APIOrderedArgs[2]);
8686 SubExprs.push_back(APIOrderedArgs[4]);
8687 SubExprs.push_back(APIOrderedArgs[1]);
8688 SubExprs.push_back(APIOrderedArgs[5]);
8689 SubExprs.push_back(APIOrderedArgs[2]);
8690 SubExprs.push_back(APIOrderedArgs[3]);
8695 if (SubExprs.size() >= 2 && Form !=
Init) {
8696 std::optional<llvm::APSInt>
Success =
8697 SubExprs[1]->getIntegerConstantExpr(
Context);
8699 Diag(SubExprs[1]->getBeginLoc(),
8700 diag::warn_atomic_op_has_invalid_memory_order)
8701 << (Form == C11CmpXchg || Form == GNUCmpXchg)
8702 << SubExprs[1]->getSourceRange();
8704 if (SubExprs.size() >= 5) {
8705 if (std::optional<llvm::APSInt> Failure =
8706 SubExprs[3]->getIntegerConstantExpr(
Context)) {
8707 if (!llvm::is_contained(
8708 {llvm::AtomicOrderingCABI::relaxed,
8709 llvm::AtomicOrderingCABI::consume,
8710 llvm::AtomicOrderingCABI::acquire,
8711 llvm::AtomicOrderingCABI::seq_cst},
8712 (llvm::AtomicOrderingCABI)Failure->getSExtValue())) {
8713 Diag(SubExprs[3]->getBeginLoc(),
8714 diag::warn_atomic_op_has_invalid_memory_order)
8715 << 2 << SubExprs[3]->getSourceRange();
8722 auto *
Scope = Args[Args.size() - 1];
8723 if (std::optional<llvm::APSInt>
Result =
8725 if (!ScopeModel->isValid(
Result->getZExtValue()))
8726 Diag(
Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
8727 <<
Scope->getSourceRange();
8729 SubExprs.push_back(
Scope);
8735 if ((Op == AtomicExpr::AO__c11_atomic_load ||
8736 Op == AtomicExpr::AO__c11_atomic_store ||
8737 Op == AtomicExpr::AO__opencl_atomic_load ||
8738 Op == AtomicExpr::AO__hip_atomic_load ||
8739 Op == AtomicExpr::AO__opencl_atomic_store ||
8740 Op == AtomicExpr::AO__hip_atomic_store) &&
8743 << ((Op == AtomicExpr::AO__c11_atomic_load ||
8744 Op == AtomicExpr::AO__opencl_atomic_load ||
8745 Op == AtomicExpr::AO__hip_atomic_load)
8750 Diag(Ptr->
getExprLoc(), diag::err_atomic_builtin_bit_int_prohibit);
8766 assert(Fn &&
"builtin call without direct callee!");
8781bool Sema::BuiltinWasmRefNullExtern(
CallExpr *TheCall) {
8790bool Sema::BuiltinWasmRefNullFunc(
CallExpr *TheCall) {
8818Sema::SemaBuiltinAtomicOverloaded(
ExprResult TheCallResult) {
8826 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
8828 <<
Callee->getSourceRange();
8841 FirstArg = FirstArgResult.
get();
8842 TheCall->
setArg(0, FirstArg);
8854 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
8889#define BUILTIN_ROW(x) \
8890 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
8891 Builtin::BI##x##_8, Builtin::BI##x##_16 }
8893 static const unsigned BuiltinIndices[][5] = {
8919 case 1: SizeIndex = 0;
break;
8920 case 2: SizeIndex = 1;
break;
8921 case 4: SizeIndex = 2;
break;
8922 case 8: SizeIndex = 3;
break;
8923 case 16: SizeIndex = 4;
break;
8935 unsigned BuiltinIndex, NumFixed = 1;
8936 bool WarnAboutSemanticsChange =
false;
8937 switch (BuiltinID) {
8938 default: llvm_unreachable(
"Unknown overloaded atomic builtin!");
8939 case Builtin::BI__sync_fetch_and_add:
8940 case Builtin::BI__sync_fetch_and_add_1:
8941 case Builtin::BI__sync_fetch_and_add_2:
8942 case Builtin::BI__sync_fetch_and_add_4:
8943 case Builtin::BI__sync_fetch_and_add_8:
8944 case Builtin::BI__sync_fetch_and_add_16:
8948 case Builtin::BI__sync_fetch_and_sub:
8949 case Builtin::BI__sync_fetch_and_sub_1:
8950 case Builtin::BI__sync_fetch_and_sub_2:
8951 case Builtin::BI__sync_fetch_and_sub_4:
8952 case Builtin::BI__sync_fetch_and_sub_8:
8953 case Builtin::BI__sync_fetch_and_sub_16:
8957 case Builtin::BI__sync_fetch_and_or:
8958 case Builtin::BI__sync_fetch_and_or_1:
8959 case Builtin::BI__sync_fetch_and_or_2:
8960 case Builtin::BI__sync_fetch_and_or_4:
8961 case Builtin::BI__sync_fetch_and_or_8:
8962 case Builtin::BI__sync_fetch_and_or_16:
8966 case Builtin::BI__sync_fetch_and_and:
8967 case Builtin::BI__sync_fetch_and_and_1:
8968 case Builtin::BI__sync_fetch_and_and_2:
8969 case Builtin::BI__sync_fetch_and_and_4:
8970 case Builtin::BI__sync_fetch_and_and_8:
8971 case Builtin::BI__sync_fetch_and_and_16:
8975 case Builtin::BI__sync_fetch_and_xor:
8976 case Builtin::BI__sync_fetch_and_xor_1:
8977 case Builtin::BI__sync_fetch_and_xor_2:
8978 case Builtin::BI__sync_fetch_and_xor_4:
8979 case Builtin::BI__sync_fetch_and_xor_8:
8980 case Builtin::BI__sync_fetch_and_xor_16:
8984 case Builtin::BI__sync_fetch_and_nand:
8985 case Builtin::BI__sync_fetch_and_nand_1:
8986 case Builtin::BI__sync_fetch_and_nand_2:
8987 case Builtin::BI__sync_fetch_and_nand_4:
8988 case Builtin::BI__sync_fetch_and_nand_8:
8989 case Builtin::BI__sync_fetch_and_nand_16:
8991 WarnAboutSemanticsChange =
true;
8994 case Builtin::BI__sync_add_and_fetch:
8995 case Builtin::BI__sync_add_and_fetch_1:
8996 case Builtin::BI__sync_add_and_fetch_2:
8997 case Builtin::BI__sync_add_and_fetch_4:
8998 case Builtin::BI__sync_add_and_fetch_8:
8999 case Builtin::BI__sync_add_and_fetch_16:
9003 case Builtin::BI__sync_sub_and_fetch:
9004 case Builtin::BI__sync_sub_and_fetch_1:
9005 case Builtin::BI__sync_sub_and_fetch_2:
9006 case Builtin::BI__sync_sub_and_fetch_4:
9007 case Builtin::BI__sync_sub_and_fetch_8:
9008 case Builtin::BI__sync_sub_and_fetch_16:
9012 case Builtin::BI__sync_and_and_fetch:
9013 case Builtin::BI__sync_and_and_fetch_1:
9014 case Builtin::BI__sync_and_and_fetch_2:
9015 case Builtin::BI__sync_and_and_fetch_4:
9016 case Builtin::BI__sync_and_and_fetch_8:
9017 case Builtin::BI__sync_and_and_fetch_16:
9021 case Builtin::BI__sync_or_and_fetch:
9022 case Builtin::BI__sync_or_and_fetch_1:
9023 case Builtin::BI__sync_or_and_fetch_2:
9024 case Builtin::BI__sync_or_and_fetch_4:
9025 case Builtin::BI__sync_or_and_fetch_8:
9026 case Builtin::BI__sync_or_and_fetch_16:
9030 case Builtin::BI__sync_xor_and_fetch:
9031 case Builtin::BI__sync_xor_and_fetch_1:
9032 case Builtin::BI__sync_xor_and_fetch_2:
9033 case Builtin::BI__sync_xor_and_fetch_4:
9034 case Builtin::BI__sync_xor_and_fetch_8:
9035 case Builtin::BI__sync_xor_and_fetch_16:
9039 case Builtin::BI__sync_nand_and_fetch:
9040 case Builtin::BI__sync_nand_and_fetch_1:
9041 case Builtin::BI__sync_nand_and_fetch_2:
9042 case Builtin::BI__sync_nand_and_fetch_4:
9043 case Builtin::BI__sync_nand_and_fetch_8:
9044 case Builtin::BI__sync_nand_and_fetch_16:
9046 WarnAboutSemanticsChange =
true;
9049 case Builtin::BI__sync_val_compare_and_swap:
9050 case Builtin::BI__sync_val_compare_and_swap_1:
9051 case Builtin::BI__sync_val_compare_and_swap_2:
9052 case Builtin::BI__sync_val_compare_and_swap_4:
9053 case Builtin::BI__sync_val_compare_and_swap_8:
9054 case Builtin::BI__sync_val_compare_and_swap_16:
9059 case Builtin::BI__sync_bool_compare_and_swap:
9060 case Builtin::BI__sync_bool_compare_and_swap_1:
9061 case Builtin::BI__sync_bool_compare_and_swap_2:
9062 case Builtin::BI__sync_bool_compare_and_swap_4:
9063 case Builtin::BI__sync_bool_compare_and_swap_8:
9064 case Builtin::BI__sync_bool_compare_and_swap_16:
9070 case Builtin::BI__sync_lock_test_and_set:
9071 case Builtin::BI__sync_lock_test_and_set_1:
9072 case Builtin::BI__sync_lock_test_and_set_2:
9073 case Builtin::BI__sync_lock_test_and_set_4:
9074 case Builtin::BI__sync_lock_test_and_set_8:
9075 case Builtin::BI__sync_lock_test_and_set_16:
9079 case Builtin::BI__sync_lock_release:
9080 case Builtin::BI__sync_lock_release_1:
9081 case Builtin::BI__sync_lock_release_2:
9082 case Builtin::BI__sync_lock_release_4:
9083 case Builtin::BI__sync_lock_release_8:
9084 case Builtin::BI__sync_lock_release_16:
9090 case Builtin::BI__sync_swap:
9091 case Builtin::BI__sync_swap_1:
9092 case Builtin::BI__sync_swap_2:
9093 case Builtin::BI__sync_swap_4:
9094 case Builtin::BI__sync_swap_8:
9095 case Builtin::BI__sync_swap_16:
9103 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
9104 << 0 << 1 + NumFixed << TheCall->
getNumArgs() << 0
9105 <<
Callee->getSourceRange();
9109 Diag(TheCall->
getEndLoc(), diag::warn_atomic_implicit_seq_cst)
9110 <<
Callee->getSourceRange();
9112 if (WarnAboutSemanticsChange) {
9113 Diag(TheCall->
getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
9114 <<
Callee->getSourceRange();
9119 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
9122 if (NewBuiltinID == BuiltinID)
9123 NewBuiltinDecl = FDecl;
9129 assert(Res.getFoundDecl());
9130 NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
9131 if (!NewBuiltinDecl)
9138 for (
unsigned i = 0; i != NumFixed; ++i) {
9169 CK_BuiltinFnToFnPtr);
9181 if (BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {
9182 Diag(FirstArg->
getExprLoc(), diag::err_atomic_builtin_ext_int_size);
9186 return TheCallResult;
9201 assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||
9202 BuiltinID == Builtin::BI__builtin_nontemporal_load) &&
9203 "Unexpected nontemporal load/store builtin!");
9204 bool isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;
9205 unsigned numArgs = isStore ? 2 : 1;
9215 Expr *PointerArg = TheCall->
getArg(numArgs - 1);
9221 PointerArg = PointerArgResult.
get();
9222 TheCall->
setArg(numArgs - 1, PointerArg);
9226 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
9239 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
9246 return TheCallResult;
9258 return TheCallResult;
9265bool Sema::CheckObjCString(
Expr *Arg) {
9269 if (!Literal || !
Literal->isOrdinary()) {
9270 Diag(Arg->
getBeginLoc(), diag::err_cfstring_literal_not_string_constant)
9275 if (
Literal->containsNonAsciiOrNull()) {
9276 StringRef String =
Literal->getString();
9277 unsigned NumBytes = String.size();
9279 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
9280 llvm::UTF16 *ToPtr = &ToBuf[0];
9282 llvm::ConversionResult
Result =
9283 llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
9284 ToPtr + NumBytes, llvm::strictConversion);
9286 if (
Result != llvm::conversionOK)
9297 auto *
Literal = dyn_cast<StringLiteral>(Arg);
9299 if (
auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
9300 Literal = ObjcLiteral->getString();
9304 if (!Literal || (!
Literal->isOrdinary() && !
Literal->isUTF8())) {
9322 bool IsX64 = TT.getArch() == llvm::Triple::x86_64;
9323 bool IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||
9324 TT.getArch() == llvm::Triple::aarch64_32);
9325 bool IsWindows = TT.isOSWindows();
9326 bool IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;
9327 if (IsX64 || IsAArch64) {
9335 diag::err_ms_va_start_used_in_sysv_function);
9344 diag::err_va_start_used_in_wrong_abi_function)
9359 bool IsVariadic =
false;
9362 if (
auto *
Block = dyn_cast<BlockDecl>(Caller)) {
9363 IsVariadic =
Block->isVariadic();
9364 Params =
Block->parameters();
9365 }
else if (
auto *FD = dyn_cast<FunctionDecl>(Caller)) {
9368 }
else if (
auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {
9369 IsVariadic = MD->isVariadic();
9371 Params = MD->parameters();
9372 }
else if (isa<CapturedDecl>(Caller)) {
9388 *LastParam = Params.empty() ? nullptr : Params.back();
9396bool Sema::SemaBuiltinVAStart(
unsigned BuiltinID,
CallExpr *TheCall) {
9421 bool SecondArgIsLastNamedArgument =
false;
9423 if (std::optional<llvm::APSInt> Val =
9432 bool IsCRegister =
false;
9434 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
9435 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
9436 SecondArgIsLastNamedArgument = PV == LastParam;
9438 Type = PV->getType();
9439 ParamLoc = PV->getLocation();
9445 if (!SecondArgIsLastNamedArgument)
9447 diag::warn_second_arg_of_va_start_not_last_named_param);
9452 if (!Context.isPromotableIntegerType(Type))
9454 if (!Type->isEnumeralType())
9456 const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
9458 Context.typesAreCompatible(ED->getPromotionType(), Type));
9460 unsigned Reason = 0;
9462 else if (IsCRegister) Reason = 2;
9463 Diag(Arg->
getBeginLoc(), diag::warn_va_start_type_is_undefined) << Reason;
9464 Diag(ParamLoc, diag::note_parameter_type) <<
Type;
9470bool Sema::SemaBuiltinVAStartARMMicrosoft(
CallExpr *
Call) {
9471 auto IsSuitablyTypedFormatArgument = [
this](
const Expr *Arg) ->
bool {
9491 if (
Call->getNumArgs() < 3)
9493 diag::err_typecheck_call_too_few_args_at_least)
9494 << 0 << 3 <<
Call->getNumArgs()
9507 const Expr *Arg1 =
Call->getArg(1)->IgnoreParens();
9510 const Expr *Arg2 =
Call->getArg(2)->IgnoreParens();
9515 if (!Arg1Ty->
isPointerType() || !IsSuitablyTypedFormatArgument(Arg1))
9517 << Arg1->
getType() << ConstCharPtrTy << 1
9520 << 2 << Arg1->
getType() << ConstCharPtrTy;
9525 << Arg2->
getType() << SizeTy << 1
9528 << 3 << Arg2->
getType() << SizeTy;
9535bool Sema::SemaBuiltinUnorderedCompare(
CallExpr *TheCall,
unsigned BuiltinID) {
9539 if (BuiltinID == Builtin::BI__builtin_isunordered &&
9567 diag::err_typecheck_call_invalid_ordered_compare)
9578bool Sema::SemaBuiltinFPClassification(
CallExpr *TheCall,
unsigned NumArgs,
9579 unsigned BuiltinID) {
9584 if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
9585 BuiltinID == Builtin::BI__builtin_isinf ||
9586 BuiltinID == Builtin::BI__builtin_isinf_sign))
9590 if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
9591 BuiltinID == Builtin::BI__builtin_isunordered))
9595 bool IsFPClass = NumArgs == 2;
9598 unsigned FPArgNo = IsFPClass ? 0 : NumArgs - 1;
9602 for (
unsigned i = 0; i < FPArgNo; ++i) {
9627 TheCall->
setArg(FPArgNo, OrigArg);
9641 diag::err_typecheck_call_invalid_unary_fp)
9647 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
9653 if (!VectorResultTy.
isNull())
9654 ResultTy = VectorResultTy;
9664bool Sema::SemaBuiltinComplex(
CallExpr *TheCall) {
9668 bool Dependent =
false;
9669 for (
unsigned I = 0; I != 2; ++I) {
9680 return Diag(Arg->
getBeginLoc(), diag::err_typecheck_call_requires_real_fp)
9699 diag::err_typecheck_call_different_arg_types)
9725bool Sema::SemaBuiltinVSX(
CallExpr *TheCall) {
9726 unsigned ExpectedNumArgs = 3;
9733 diag::err_vsx_builtin_nonconstant_argument)
9745 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
9753 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
9772 diag::err_typecheck_call_too_few_args_at_least)
9780 unsigned numElements = 0;
9795 unsigned numResElements = TheCall->
getNumArgs() - 2;
9804 diag::err_vec_builtin_incompatible_vector)
9811 diag::err_vec_builtin_incompatible_vector)
9816 }
else if (numElements != numResElements) {
9823 for (
unsigned i = 2; i < TheCall->
getNumArgs(); i++) {
9828 std::optional<llvm::APSInt>
Result;
9831 diag::err_shufflevector_nonconstant_argument)
9838 if (
Result->getActiveBits() > 64 ||
9839 Result->getZExtValue() >= numElements * 2)
9841 diag::err_shufflevector_argument_too_large)
9847 for (
unsigned i = 0, e = TheCall->
getNumArgs(); i != e; i++) {
9848 exprs.push_back(TheCall->
getArg(i));
9849 TheCall->
setArg(i,
nullptr);
9868 diag::err_convertvector_non_vector)
9871 return ExprError(
Diag(BuiltinLoc, diag::err_builtin_non_vector_type)
9873 <<
"__builtin_convertvector");
9878 if (SrcElts != DstElts)
9880 diag::err_convertvector_incompatible_vector)
9891bool Sema::SemaBuiltinPrefetch(
CallExpr *TheCall) {
9896 diag::err_typecheck_call_too_many_args_at_most)
9897 << 0 << 3 << NumArgs << 0
9902 for (
unsigned i = 1; i != NumArgs; ++i)
9903 if (SemaBuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
9910bool Sema::SemaBuiltinArithmeticFence(
CallExpr *TheCall) {
9912 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
9922 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
9935bool Sema::SemaBuiltinAssume(
CallExpr *TheCall) {
9942 << cast<FunctionDecl>(TheCall->
getCalleeDecl())->getIdentifier();
9950bool Sema::SemaBuiltinAllocaWithAlign(
CallExpr *TheCall) {
9956 if (
const auto *UE =
9958 if (UE->getKind() == UETT_AlignOf ||
9959 UE->getKind() == UETT_PreferredAlignOf)
9965 if (!
Result.isPowerOf2())
9966 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
9973 if (
Result > std::numeric_limits<int32_t>::max())
9983bool Sema::SemaBuiltinAssumeAligned(
CallExpr *TheCall) {
9996 TheCall->
setArg(0, FirstArgResult.
get());
10005 if (SemaBuiltinConstantArg(TheCall, 1,
Result))
10008 if (!
Result.isPowerOf2())
10009 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10021 TheCall->
setArg(2, ThirdArg);
10027bool Sema::SemaBuiltinOSLogFormat(
CallExpr *TheCall) {
10028 unsigned BuiltinID =
10029 cast<FunctionDecl>(TheCall->
getCalleeDecl())->getBuiltinID();
10030 bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
10033 unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
10034 if (NumArgs < NumRequiredArgs) {
10035 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args)
10036 << 0 << NumRequiredArgs << NumArgs
10039 if (NumArgs >= NumRequiredArgs + 0x100) {
10041 diag::err_typecheck_call_too_many_args_at_most)
10042 << 0 << (NumRequiredArgs + 0xff) << NumArgs
10053 if (Arg.isInvalid())
10055 TheCall->
setArg(i, Arg.get());
10060 unsigned FormatIdx = i;
10070 unsigned FirstDataArg = i;
10071 while (i < NumArgs) {
10089 llvm::SmallBitVector CheckedVarArgs(NumArgs,
false);
10091 bool Success = CheckFormatArguments(
10109bool Sema::SemaBuiltinConstantArg(
CallExpr *TheCall,
int ArgNum,
10117 std::optional<llvm::APSInt> R;
10119 return Diag(TheCall->
getBeginLoc(), diag::err_constant_integer_arg_type)
10127bool Sema::SemaBuiltinConstantArgRange(
CallExpr *TheCall,
int ArgNum,
10128 int Low,
int High,
bool RangeIsError) {
10139 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
10142 if (
Result.getSExtValue() < Low ||
Result.getSExtValue() > High) {
10144 return Diag(TheCall->
getBeginLoc(), diag::err_argument_invalid_range)
10150 PDiag(diag::warn_argument_invalid_range)
10160bool Sema::SemaBuiltinConstantArgMultiple(
CallExpr *TheCall,
int ArgNum,
10170 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
10173 if (
Result.getSExtValue() % Num != 0)
10182bool Sema::SemaBuiltinConstantArgPower2(
CallExpr *TheCall,
int ArgNum) {
10191 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
10199 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_power_of_2)
10204 if (
Value.isNegative())
10215 if ((
Value & 0xFF) != 0)
10228bool Sema::SemaBuiltinConstantArgShiftedByte(
CallExpr *TheCall,
int ArgNum,
10229 unsigned ArgBits) {
10238 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
10243 Result.setIsUnsigned(
true);
10248 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_shifted_byte)
10257bool Sema::SemaBuiltinConstantArgShiftedByteOrXXFF(
CallExpr *TheCall,
10259 unsigned ArgBits) {
10268 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
10273 Result.setIsUnsigned(
true);
10281 diag::err_argument_not_shifted_byte_or_xxff)
10286bool Sema::SemaBuiltinARMMemoryTaggingCall(
unsigned BuiltinID,
CallExpr *TheCall) {
10287 if (BuiltinID == AArch64::BI__builtin_arm_irg) {
10298 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10307 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10311 TheCall->
setType(FirstArgType);
10315 if (BuiltinID == AArch64::BI__builtin_arm_addg) {
10325 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10330 TheCall->
setType(FirstArgType);
10333 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
10336 if (BuiltinID == AArch64::BI__builtin_arm_gmi) {
10347 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10352 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10358 if (BuiltinID == AArch64::BI__builtin_arm_ldg ||
10359 BuiltinID == AArch64::BI__builtin_arm_stg) {
10369 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10374 if (BuiltinID == AArch64::BI__builtin_arm_ldg)
10375 TheCall->
setType(FirstArgType);
10379 if (BuiltinID == AArch64::BI__builtin_arm_subp) {
10392 auto isNull = [&] (
Expr *E) ->
bool {
10398 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10402 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10413 return Diag(TheCall->
getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
10421 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_any2arg_pointer)
10435 assert(
false &&
"Unhandled ARM MTE intrinsic");
10441bool Sema::SemaBuiltinARMSpecialReg(
unsigned BuiltinID,
CallExpr *TheCall,
10442 int ArgNum,
unsigned ExpectedFieldNum,
10444 bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
10445 BuiltinID == ARM::BI__builtin_arm_wsr64 ||
10446 BuiltinID == ARM::BI__builtin_arm_rsr ||
10447 BuiltinID == ARM::BI__builtin_arm_rsrp ||
10448 BuiltinID == ARM::BI__builtin_arm_wsr ||
10449 BuiltinID == ARM::BI__builtin_arm_wsrp;
10450 bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
10451 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
10452 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10453 BuiltinID == AArch64::BI__builtin_arm_wsr128 ||
10454 BuiltinID == AArch64::BI__builtin_arm_rsr ||
10455 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
10456 BuiltinID == AArch64::BI__builtin_arm_wsr ||
10457 BuiltinID == AArch64::BI__builtin_arm_wsrp;
10458 assert((IsARMBuiltin || IsAArch64Builtin) &&
"Unexpected ARM builtin.");
10467 return Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
10473 Reg.split(Fields,
":");
10475 if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))
10476 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10483 if (Fields.size() > 1) {
10484 bool FiveFields = Fields.size() == 5;
10486 bool ValidString =
true;
10487 if (IsARMBuiltin) {
10488 ValidString &= Fields[0].starts_with_insensitive(
"cp") ||
10489 Fields[0].starts_with_insensitive(
"p");
10491 Fields[0] = Fields[0].drop_front(
10492 Fields[0].starts_with_insensitive(
"cp") ? 2 : 1);
10494 ValidString &= Fields[2].starts_with_insensitive(
"c");
10496 Fields[2] = Fields[2].drop_front(1);
10499 ValidString &= Fields[3].starts_with_insensitive(
"c");
10501 Fields[3] = Fields[3].drop_front(1);
10507 Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});
10509 Ranges.append({15, 7, 15});
10511 for (
unsigned i=0; i<Fields.size(); ++i) {
10513 ValidString &= !Fields[i].getAsInteger(10, IntField);
10514 ValidString &= (IntField >= 0 && IntField <= Ranges[i]);
10518 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10520 }
else if (IsAArch64Builtin && Fields.size() == 1) {
10528 if (BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10529 BuiltinID == AArch64::BI__builtin_arm_wsr128)
10534 auto MaxLimit = llvm::StringSwitch<std::optional<unsigned>>(Reg)
10535 .CaseLower(
"spsel", 15)
10536 .CaseLower(
"daifclr", 15)
10537 .CaseLower(
"daifset", 15)
10538 .CaseLower(
"pan", 15)
10539 .CaseLower(
"uao", 15)
10540 .CaseLower(
"dit", 15)
10541 .CaseLower(
"ssbs", 15)
10542 .CaseLower(
"tco", 15)
10543 .CaseLower(
"allint", 1)
10544 .CaseLower(
"pm", 1)
10545 .Default(std::nullopt);
10565 return SemaBuiltinConstantArgRange(TheCall, 1, 0, *MaxLimit);
10575bool Sema::SemaBuiltinPPCMMACall(
CallExpr *TheCall,
unsigned BuiltinID,
10576 const char *TypeStr) {
10578 assert((TypeStr[0] !=
'\0') &&
10579 "Invalid types in PPC MMA builtin declaration");
10582 unsigned ArgNum = 0;
10589 while (*TypeStr !=
'\0') {
10613 diag::err_typecheck_convert_incompatible)
10620 SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, Mask,
true))
10630 while (*TypeStr !=
'\0') {
10643bool Sema::SemaBuiltinLongjmp(
CallExpr *TheCall) {
10645 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_unsupported)
10652 if (SemaBuiltinConstantArg(TheCall, 1,
Result))
10656 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
10664bool Sema::SemaBuiltinSetjmp(
CallExpr *TheCall) {
10666 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_setjmp_unsupported)
10673class UncoveredArgHandler {
10674 enum {
Unknown = -1, AllCovered = -2 };
10676 signed FirstUncoveredArg =
Unknown;
10680 UncoveredArgHandler() =
default;
10682 bool hasUncoveredArg()
const {
10683 return (FirstUncoveredArg >= 0);
10686 unsigned getUncoveredArg()
const {
10687 assert(hasUncoveredArg() &&
"no uncovered argument");
10688 return FirstUncoveredArg;
10691 void setAllCovered() {
10694 DiagnosticExprs.clear();
10695 FirstUncoveredArg = AllCovered;
10698 void Update(
signed NewFirstUncoveredArg,
const Expr *StrExpr) {
10699 assert(NewFirstUncoveredArg >= 0 &&
"Outside range");
10702 if (FirstUncoveredArg == AllCovered)
10707 if (NewFirstUncoveredArg == FirstUncoveredArg)
10708 DiagnosticExprs.push_back(StrExpr);
10709 else if (NewFirstUncoveredArg > FirstUncoveredArg) {
10710 DiagnosticExprs.clear();
10711 DiagnosticExprs.push_back(StrExpr);
10712 FirstUncoveredArg = NewFirstUncoveredArg;
10716 void Diagnose(
Sema &S,
bool IsFunctionCall,
const Expr *ArgExpr);
10719enum StringLiteralCheckType {
10721 SLCT_UncheckedLiteral,
10722 SLCT_CheckedLiteral
10729 bool AddendIsRight) {
10730 unsigned BitWidth = Offset.getBitWidth();
10731 unsigned AddendBitWidth = Addend.getBitWidth();
10733 if (Addend.isUnsigned()) {
10734 Addend = Addend.zext(++AddendBitWidth);
10735 Addend.setIsSigned(
true);
10738 if (AddendBitWidth > BitWidth) {
10739 Offset = Offset.sext(AddendBitWidth);
10740 BitWidth = AddendBitWidth;
10741 }
else if (BitWidth > AddendBitWidth) {
10742 Addend = Addend.sext(BitWidth);
10746 llvm::APSInt ResOffset = Offset;
10747 if (BinOpKind == BO_Add)
10748 ResOffset = Offset.sadd_ov(Addend, Ov);
10750 assert(AddendIsRight && BinOpKind == BO_Sub &&
10751 "operator must be add or sub with addend on the right");
10752 ResOffset = Offset.ssub_ov(Addend, Ov);
10758 assert(BitWidth <= std::numeric_limits<unsigned>::max() / 2 &&
10759 "index (intermediate) result too big");
10760 Offset = Offset.sext(2 * BitWidth);
10761 sumOffsets(Offset, Addend, BinOpKind, AddendIsRight);
10765 Offset = ResOffset;
10773class FormatStringLiteral {
10778 FormatStringLiteral(
const StringLiteral *fexpr, int64_t Offset = 0)
10779 : FExpr(fexpr), Offset(Offset) {}
10781 StringRef getString()
const {
10782 return FExpr->
getString().drop_front(Offset);
10785 unsigned getByteLength()
const {
10786 return FExpr->
getByteLength() - getCharByteWidth() * Offset;
10789 unsigned getLength()
const {
return FExpr->
getLength() - Offset; }
10796 bool isAscii()
const {
return FExpr->
isOrdinary(); }
10797 bool isWide()
const {
return FExpr->
isWide(); }
10798 bool isUTF8()
const {
return FExpr->
isUTF8(); }
10799 bool isUTF16()
const {
return FExpr->
isUTF16(); }
10800 bool isUTF32()
const {
return FExpr->
isUTF32(); }
10801 bool isPascal()
const {
return FExpr->
isPascal(); }
10806 unsigned *StartTokenByteOffset =
nullptr)
const {
10808 StartToken, StartTokenByteOffset);
10821 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
10825 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
10826 bool IgnoreStringsWithoutSpecifiers);
10835static StringLiteralCheckType
10840 llvm::SmallBitVector &CheckedVarArgs,
10841 UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset,
10842 bool IgnoreStringsWithoutSpecifiers =
false) {
10844 return SLCT_NotALiteral;
10846 assert(Offset.isSigned() &&
"invalid offset");
10849 return SLCT_NotALiteral;
10858 return SLCT_UncheckedLiteral;
10861 case Stmt::InitListExprClass:
10865 Type, CallType,
false,
10866 CheckedVarArgs, UncoveredArg, Offset,
10867 IgnoreStringsWithoutSpecifiers);
10869 return SLCT_NotALiteral;
10870 case Stmt::BinaryConditionalOperatorClass:
10871 case Stmt::ConditionalOperatorClass: {
10875 cast<AbstractConditionalOperator>(E);
10880 bool CheckLeft =
true, CheckRight =
true;
10883 if (
C->getCond()->EvaluateAsBooleanCondition(
10886 CheckRight =
false;
10895 StringLiteralCheckType Left;
10897 Left = SLCT_UncheckedLiteral;
10900 firstDataArg,
Type, CallType, InFunctionCall,
10901 CheckedVarArgs, UncoveredArg, Offset,
10902 IgnoreStringsWithoutSpecifiers);
10903 if (Left == SLCT_NotALiteral || !CheckRight) {
10909 S,
C->getFalseExpr(), Args, APK, format_idx, firstDataArg,
Type,
10910 CallType, InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
10911 IgnoreStringsWithoutSpecifiers);
10913 return (CheckLeft && Left < Right) ? Left : Right;
10916 case Stmt::ImplicitCastExprClass:
10917 E = cast<ImplicitCastExpr>(E)->getSubExpr();
10920 case Stmt::OpaqueValueExprClass:
10921 if (
const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
10925 return SLCT_NotALiteral;
10927 case Stmt::PredefinedExprClass:
10931 return SLCT_UncheckedLiteral;
10933 case Stmt::DeclRefExprClass: {
10939 bool isConstant =
false;
10943 isConstant = AT->getElementType().isConstant(S.
Context);
10946 PT->getPointeeType().isConstant(S.
Context);
10954 if (
const Expr *
Init = VD->getAnyInitializer()) {
10957 if (InitList->isStringLiteralInit())
10958 Init = InitList->getInit(0)->IgnoreParenImpCasts();
10961 S,
Init, Args, APK, format_idx, firstDataArg,
Type, CallType,
10962 false, CheckedVarArgs, UncoveredArg, Offset);
11003 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
11004 if (
const auto *D = dyn_cast<Decl>(PV->getDeclContext())) {
11006 bool IsCXXMember =
false;
11007 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D))
11008 IsCXXMember = MD->isInstance();
11010 bool IsVariadic =
false;
11012 IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();
11013 else if (
const auto *BD = dyn_cast<BlockDecl>(D))
11014 IsVariadic = BD->isVariadic();
11015 else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D))
11016 IsVariadic = OMD->isVariadic();
11023 if (PV->getFunctionScopeIndex() == CallerFSI.
FormatIdx &&
11036 return SLCT_UncheckedLiteral;
11045 return SLCT_NotALiteral;
11048 case Stmt::CallExprClass:
11049 case Stmt::CXXMemberCallExprClass: {
11050 const CallExpr *CE = cast<CallExpr>(E);
11052 bool IsFirst =
true;
11053 StringLiteralCheckType CommonResult;
11054 for (
const auto *FA : ND->specific_attrs<FormatArgAttr>()) {
11055 const Expr *Arg = CE->
getArg(FA->getFormatIdx().getASTIndex());
11057 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11058 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11059 IgnoreStringsWithoutSpecifiers);
11066 return CommonResult;
11068 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
11070 if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
11071 BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString) {
11074 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11075 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11076 IgnoreStringsWithoutSpecifiers);
11082 Type, CallType,
false,
11083 CheckedVarArgs, UncoveredArg, Offset,
11084 IgnoreStringsWithoutSpecifiers);
11085 return SLCT_NotALiteral;
11087 case Stmt::ObjCMessageExprClass: {
11088 const auto *ME = cast<ObjCMessageExpr>(E);
11089 if (
const auto *MD = ME->getMethodDecl()) {
11090 if (
const auto *FA = MD->getAttr<FormatArgAttr>()) {
11099 if (MD->isInstanceMethod() && (IFace = MD->getClassInterface()) &&
11101 MD->getSelector().isKeywordSelector(
11102 {
"localizedStringForKey",
"value",
"table"})) {
11103 IgnoreStringsWithoutSpecifiers =
true;
11106 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
11108 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11109 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11110 IgnoreStringsWithoutSpecifiers);
11114 return SLCT_NotALiteral;
11116 case Stmt::ObjCStringLiteralClass:
11117 case Stmt::StringLiteralClass: {
11123 StrE = cast<StringLiteral>(E);
11126 if (Offset.isNegative() || Offset > StrE->
getLength()) {
11129 return SLCT_NotALiteral;
11131 FormatStringLiteral FStr(StrE, Offset.sextOrTrunc(64).getSExtValue());
11133 InFunctionCall, CallType, CheckedVarArgs, UncoveredArg,
11134 IgnoreStringsWithoutSpecifiers);
11135 return SLCT_CheckedLiteral;
11138 return SLCT_NotALiteral;
11140 case Stmt::BinaryOperatorClass: {
11154 if (LIsInt != RIsInt) {
11158 if (BinOpKind == BO_Add) {
11171 return SLCT_NotALiteral;
11173 case Stmt::UnaryOperatorClass: {
11175 auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->
getSubExpr());
11176 if (UnaOp->
getOpcode() == UO_AddrOf && ASE) {
11178 if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.
Context,
11183 E = ASE->getBase();
11188 return SLCT_NotALiteral;
11192 return SLCT_NotALiteral;
11203 const auto *LVE =
Result.Val.getLValueBase().dyn_cast<
const Expr *>();
11204 if (isa_and_nonnull<StringLiteral>(LVE))
11211 return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
11217 .Cases(
"kprintf",
"cmn_err",
"vcmn_err",
"zcmn_err",
FST_Kprintf)
11227bool Sema::CheckFormatArguments(
const FormatAttr *Format,
11231 llvm::SmallBitVector &CheckedVarArgs) {
11232 FormatStringInfo FSI;
11235 return CheckFormatArguments(Args, FSI.ArgPassingKind, FSI.FormatIdx,
11237 CallType, Loc, Range, CheckedVarArgs);
11243 unsigned format_idx,
unsigned firstDataArg,
11244 FormatStringType
Type,
11247 llvm::SmallBitVector &CheckedVarArgs) {
11249 if (format_idx >= Args.size()) {
11250 Diag(Loc, diag::warn_missing_format_string) << Range;
11254 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
11268 UncoveredArgHandler UncoveredArg;
11270 *
this, OrigFormatExpr, Args, APK, format_idx, firstDataArg,
Type,
11272 true, CheckedVarArgs, UncoveredArg,
11273 llvm::APSInt(64,
false) = 0);
11276 if (UncoveredArg.hasUncoveredArg()) {
11277 unsigned ArgIdx = UncoveredArg.getUncoveredArg() + firstDataArg;
11278 assert(ArgIdx < Args.size() &&
"ArgIdx outside bounds");
11279 UncoveredArg.Diagnose(*
this,
true, Args[ArgIdx]);
11282 if (CT != SLCT_NotALiteral)
11284 return CT == SLCT_CheckedLiteral;
11301 if (Args.size() == firstDataArg) {
11302 Diag(FormatLoc, diag::warn_format_nonliteral_noargs)
11310 Diag(FormatLoc, diag::note_format_security_fixit)
11314 Diag(FormatLoc, diag::note_format_security_fixit)
11319 Diag(FormatLoc, diag::warn_format_nonliteral)
11330 const FormatStringLiteral *FExpr;
11331 const Expr *OrigFormatExpr;
11333 const unsigned FirstDataArg;
11334 const unsigned NumDataArgs;
11338 unsigned FormatIdx;
11339 llvm::SmallBitVector CoveredArgs;
11340 bool usesPositionalArgs =
false;
11341 bool atFirstArg =
true;
11342 bool inFunctionCall;
11344 llvm::SmallBitVector &CheckedVarArgs;
11345 UncoveredArgHandler &UncoveredArg;
11348 CheckFormatHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11349 const Expr *origFormatExpr,
11351 unsigned numDataArgs,
const char *beg,
11355 llvm::SmallBitVector &CheckedVarArgs,
11356 UncoveredArgHandler &UncoveredArg)
11357 : S(
s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(
type),
11358 FirstDataArg(firstDataArg), NumDataArgs(numDataArgs), Beg(beg),
11359 ArgPassingKind(APK), Args(Args), FormatIdx(formatIdx),
11360 inFunctionCall(inFunctionCall), CallType(callType),
11361 CheckedVarArgs(CheckedVarArgs), UncoveredArg(UncoveredArg) {
11362 CoveredArgs.resize(numDataArgs);
11363 CoveredArgs.reset();
11366 void DoneProcessing();
11368 void HandleIncompleteSpecifier(
const char *startSpecifier,
11369 unsigned specifierLen)
override;
11371 void HandleInvalidLengthModifier(
11374 const char *startSpecifier,
unsigned specifierLen,
11377 void HandleNonStandardLengthModifier(
11379 const char *startSpecifier,
unsigned specifierLen);
11381 void HandleNonStandardConversionSpecifier(
11383 const char *startSpecifier,
unsigned specifierLen);
11385 void HandlePosition(
const char *startPos,
unsigned posLen)
override;
11387 void HandleInvalidPosition(
const char *startSpecifier,
11388 unsigned specifierLen,
11391 void HandleZeroPosition(
const char *startPos,
unsigned posLen)
override;
11393 void HandleNullChar(
const char *nullCharacter)
override;
11395 template <
typename Range>
11397 EmitFormatDiagnostic(
Sema &S,
bool inFunctionCall,
const Expr *ArgumentExpr,
11399 bool IsStringLocation, Range StringRange,
11403 bool HandleInvalidConversionSpecifier(
unsigned argIndex,
SourceLocation Loc,
11404 const char *startSpec,
11405 unsigned specifierLen,
11406 const char *csStart,
unsigned csLen);
11409 const char *startSpec,
11410 unsigned specifierLen);
11414 unsigned specifierLen);
11417 const Expr *getDataArg(
unsigned i)
const;
11421 const char *startSpecifier,
unsigned specifierLen,
11422 unsigned argIndex);
11424 template <
typename Range>
11426 bool IsStringLocation, Range StringRange,
11432SourceRange CheckFormatHandler::getFormatStringRange() {
11437getSpecifierRange(
const char *startSpecifier,
unsigned specifierLen) {
11439 SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
11442 End = End.getLocWithOffset(1);
11447SourceLocation CheckFormatHandler::getLocationOfByte(
const char *x) {
11452void CheckFormatHandler::HandleIncompleteSpecifier(
const char *startSpecifier,
11453 unsigned specifierLen){
11454 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_incomplete_specifier),
11455 getLocationOfByte(startSpecifier),
11457 getSpecifierRange(startSpecifier, specifierLen));
11460void CheckFormatHandler::HandleInvalidLengthModifier(
11463 const char *startSpecifier,
unsigned specifierLen,
unsigned DiagID) {
11464 using namespace analyze_format_string;
11466 const LengthModifier &LM = FS.getLengthModifier();
11467 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11470 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11472 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11473 getLocationOfByte(LM.getStart()),
11475 getSpecifierRange(startSpecifier, specifierLen));
11477 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11478 << FixedLM->toString()
11483 if (DiagID == diag::warn_format_nonsensical_length)
11486 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11487 getLocationOfByte(LM.getStart()),
11489 getSpecifierRange(startSpecifier, specifierLen),
11494void CheckFormatHandler::HandleNonStandardLengthModifier(
11496 const char *startSpecifier,
unsigned specifierLen) {
11497 using namespace analyze_format_string;
11499 const LengthModifier &LM = FS.getLengthModifier();
11500 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11503 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11505 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11506 << LM.toString() << 0,
11507 getLocationOfByte(LM.getStart()),
11509 getSpecifierRange(startSpecifier, specifierLen));
11511 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11512 << FixedLM->toString()
11516 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11517 << LM.toString() << 0,
11518 getLocationOfByte(LM.getStart()),
11520 getSpecifierRange(startSpecifier, specifierLen));
11524void CheckFormatHandler::HandleNonStandardConversionSpecifier(
11526 const char *startSpecifier,
unsigned specifierLen) {
11527 using namespace analyze_format_string;
11532 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11536 getSpecifierRange(startSpecifier, specifierLen));
11539 S.
Diag(getLocationOfByte(CS.
getStart()), diag::note_format_fix_specifier)
11540 << FixedCS->toString()
11543 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11547 getSpecifierRange(startSpecifier, specifierLen));
11551void CheckFormatHandler::HandlePosition(
const char *startPos,
11553 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard_positional_arg),
11554 getLocationOfByte(startPos),
11556 getSpecifierRange(startPos, posLen));
11559void CheckFormatHandler::HandleInvalidPosition(
11560 const char *startSpecifier,
unsigned specifierLen,
11562 EmitFormatDiagnostic(
11563 S.
PDiag(diag::warn_format_invalid_positional_specifier) << (
unsigned)p,
11564 getLocationOfByte(startSpecifier),
true,
11565 getSpecifierRange(startSpecifier, specifierLen));
11568void CheckFormatHandler::HandleZeroPosition(
const char *startPos,
11570 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_zero_positional_specifier),
11571 getLocationOfByte(startPos),
11573 getSpecifierRange(startPos, posLen));
11576void CheckFormatHandler::HandleNullChar(
const char *nullCharacter) {
11577 if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
11579 EmitFormatDiagnostic(
11580 S.
PDiag(diag::warn_printf_format_string_contains_null_char),
11581 getLocationOfByte(nullCharacter),
true,
11582 getFormatStringRange());
11588const Expr *CheckFormatHandler::getDataArg(
unsigned i)
const {
11589 return Args[FirstDataArg + i];
11592void CheckFormatHandler::DoneProcessing() {
11597 CoveredArgs.flip();
11598 signed notCoveredArg = CoveredArgs.find_first();
11599 if (notCoveredArg >= 0) {
11600 assert((
unsigned)notCoveredArg < NumDataArgs);
11601 UncoveredArg.Update(notCoveredArg, OrigFormatExpr);
11603 UncoveredArg.setAllCovered();
11608void UncoveredArgHandler::Diagnose(
Sema &S,
bool IsFunctionCall,
11609 const Expr *ArgExpr) {
11610 assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
11622 for (
auto E : DiagnosticExprs)
11625 CheckFormatHandler::EmitFormatDiagnostic(
11626 S, IsFunctionCall, DiagnosticExprs[0],
11632CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex,
11634 const char *startSpec,
11635 unsigned specifierLen,
11636 const char *csStart,
11638 bool keepGoing =
true;
11639 if (argIndex < NumDataArgs) {
11642 CoveredArgs.set(argIndex);
11658 std::string CodePointStr;
11659 if (!llvm::sys::locale::isPrint(*csStart)) {
11660 llvm::UTF32 CodePoint;
11661 const llvm::UTF8 **B =
reinterpret_cast<const llvm::UTF8 **
>(&csStart);
11662 const llvm::UTF8 *E =
11663 reinterpret_cast<const llvm::UTF8 *
>(csStart + csLen);
11664 llvm::ConversionResult
Result =
11665 llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
11667 if (
Result != llvm::conversionOK) {
11668 unsigned char FirstChar = *csStart;
11669 CodePoint = (llvm::UTF32)FirstChar;
11672 llvm::raw_string_ostream OS(CodePointStr);
11673 if (CodePoint < 256)
11674 OS <<
"\\x" << llvm::format(
"%02x", CodePoint);
11675 else if (CodePoint <= 0xFFFF)
11676 OS <<
"\\u" << llvm::format(
"%04x", CodePoint);
11678 OS <<
"\\U" << llvm::format(
"%08x", CodePoint);
11683 EmitFormatDiagnostic(
11684 S.
PDiag(diag::warn_format_invalid_conversion) << Specifier, Loc,
11685 true, getSpecifierRange(startSpec, specifierLen));
11691CheckFormatHandler::HandlePositionalNonpositionalArgs(
SourceLocation Loc,
11692 const char *startSpec,
11693 unsigned specifierLen) {
11694 EmitFormatDiagnostic(
11695 S.
PDiag(diag::warn_format_mix_positional_nonpositional_args),
11696 Loc,
true, getSpecifierRange(startSpec, specifierLen));
11700CheckFormatHandler::CheckNumArgs(
11703 const char *startSpecifier,
unsigned specifierLen,
unsigned argIndex) {
11705 if (argIndex >= NumDataArgs) {
11707 ? (S.
PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
11708 << (argIndex+1) << NumDataArgs)
11709 : S.
PDiag(diag::warn_printf_insufficient_data_args);
11710 EmitFormatDiagnostic(
11711 PDiag, getLocationOfByte(CS.
getStart()),
true,
11712 getSpecifierRange(startSpecifier, specifierLen));
11716 UncoveredArg.setAllCovered();
11722template<
typename Range>
11725 bool IsStringLocation,
11728 EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
11729 Loc, IsStringLocation, StringRange, FixIt);
11759template <
typename Range>
11760void CheckFormatHandler::EmitFormatDiagnostic(
11761 Sema &S,
bool InFunctionCall,
const Expr *ArgumentExpr,
11764 if (InFunctionCall) {
11769 S.
Diag(IsStringLocation ? ArgumentExpr->
getExprLoc() : Loc, PDiag)
11773 S.
Diag(IsStringLocation ? Loc : StringRange.getBegin(),
11774 diag::note_format_string_defined);
11776 Note << StringRange;
11785class CheckPrintfHandler :
public CheckFormatHandler {
11787 CheckPrintfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11788 const Expr *origFormatExpr,
11790 unsigned numDataArgs,
bool isObjC,
const char *beg,
11794 llvm::SmallBitVector &CheckedVarArgs,
11795 UncoveredArgHandler &UncoveredArg)
11796 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
11797 numDataArgs, beg, APK, Args, formatIdx,
11798 inFunctionCall, CallType, CheckedVarArgs,
11804 bool allowsObjCArg()
const {
11809 bool HandleInvalidPrintfConversionSpecifier(
11811 const char *startSpecifier,
11812 unsigned specifierLen)
override;
11814 void handleInvalidMaskType(StringRef MaskType)
override;
11817 const char *startSpecifier,
unsigned specifierLen,
11820 const char *StartSpecifier,
11821 unsigned SpecifierLen,
11825 const char *startSpecifier,
unsigned specifierLen);
11829 const char *startSpecifier,
unsigned specifierLen);
11832 const char *startSpecifier,
unsigned specifierLen);
11836 const char *startSpecifier,
unsigned specifierLen);
11840 void HandleEmptyObjCModifierFlag(
const char *startFlag,
11841 unsigned flagLen)
override;
11843 void HandleInvalidObjCModifierFlag(
const char *startFlag,
11844 unsigned flagLen)
override;
11846 void HandleObjCFlagsWithNonObjCConversion(
const char *flagsStart,
11847 const char *flagsEnd,
11848 const char *conversionPosition)
11854bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
11856 const char *startSpecifier,
11857 unsigned specifierLen) {
11859 FS.getConversionSpecifier();
11861 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
11863 startSpecifier, specifierLen,
11867void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
11868 S.
Diag(getLocationOfByte(MaskType.data()), diag::err_invalid_mask_type_size);
11871bool CheckPrintfHandler::HandleAmount(
11873 const char *startSpecifier,
unsigned specifierLen) {
11877 if (argIndex >= NumDataArgs) {
11878 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_missing_arg)
11880 getLocationOfByte(Amt.
getStart()),
11882 getSpecifierRange(startSpecifier, specifierLen));
11892 CoveredArgs.set(argIndex);
11893 const Expr *Arg = getDataArg(argIndex);
11903 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_wrong_type)
11906 getLocationOfByte(Amt.
getStart()),
11908 getSpecifierRange(startSpecifier, specifierLen));
11918void CheckPrintfHandler::HandleInvalidAmount(
11922 const char *startSpecifier,
11923 unsigned specifierLen) {
11925 FS.getConversionSpecifier();
11933 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_optional_amount)
11935 getLocationOfByte(Amt.
getStart()),
11937 getSpecifierRange(startSpecifier, specifierLen),
11943 const char *startSpecifier,
11944 unsigned specifierLen) {
11947 FS.getConversionSpecifier();
11948 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_flag)
11952 getSpecifierRange(startSpecifier, specifierLen),
11957void CheckPrintfHandler::HandleIgnoredFlag(
11961 const char *startSpecifier,
11962 unsigned specifierLen) {
11964 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_ignored_flag)
11968 getSpecifierRange(startSpecifier, specifierLen),
11970 getSpecifierRange(ignoredFlag.
getPosition(), 1)));
11973void CheckPrintfHandler::HandleEmptyObjCModifierFlag(
const char *startFlag,
11974 unsigned flagLen) {
11976 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_empty_objc_flag),
11977 getLocationOfByte(startFlag),
11979 getSpecifierRange(startFlag, flagLen));
11982void CheckPrintfHandler::HandleInvalidObjCModifierFlag(
const char *startFlag,
11983 unsigned flagLen) {
11985 auto Range = getSpecifierRange(startFlag, flagLen);
11986 StringRef flag(startFlag, flagLen);
11987 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_invalid_objc_flag) << flag,
11988 getLocationOfByte(startFlag),
11993void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
11994 const char *flagsStart,
const char *flagsEnd,
const char *conversionPosition) {
11996 auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
11997 auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
11998 EmitFormatDiagnostic(S.
PDiag(diag) << StringRef(conversionPosition, 1),
11999 getLocationOfByte(conversionPosition),
12007template<
typename MemberKind>
12028 if (MemberKind *FK = dyn_cast<MemberKind>(
decl))
12029 Results.insert(FK);
12041 MethodSet Results =
12042 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", *
this, E->
getType());
12043 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12045 if ((*MI)->getMinRequiredArguments() == 0)
12053bool CheckPrintfHandler::checkForCStrMembers(
12057 MethodSet Results =
12058 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", S, E->
getType());
12060 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12076bool CheckPrintfHandler::HandlePrintfSpecifier(
12079 using namespace analyze_format_string;
12080 using namespace analyze_printf;
12082 const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
12084 if (FS.consumesDataArgument()) {
12086 atFirstArg =
false;
12087 usesPositionalArgs = FS.usesPositionalArg();
12089 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12090 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12091 startSpecifier, specifierLen);
12098 if (!HandleAmount(FS.getFieldWidth(), 0,
12099 startSpecifier, specifierLen)) {
12103 if (!HandleAmount(FS.getPrecision(), 1,
12104 startSpecifier, specifierLen)) {
12108 if (!CS.consumesDataArgument()) {
12115 unsigned argIndex = FS.getArgIndex();
12116 if (argIndex < NumDataArgs) {
12120 CoveredArgs.set(argIndex);
12124 if (CS.getKind() == ConversionSpecifier::FreeBSDbArg ||
12125 CS.getKind() == ConversionSpecifier::FreeBSDDArg) {
12127 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex + 1))
12131 CoveredArgs.set(argIndex + 1);
12134 const Expr *Ex = getDataArg(argIndex);
12136 (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
12139 EmitFormatDiagnostic(
12140 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12144 getSpecifierRange(startSpecifier, specifierLen));
12147 Ex = getDataArg(argIndex + 1);
12150 EmitFormatDiagnostic(
12151 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12155 getSpecifierRange(startSpecifier, specifierLen));
12162 if (!allowsObjCArg() && CS.isObjCArg()) {
12163 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12168 if (FSType !=
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::PArg) {
12169 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12174 if (FSType ==
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {
12175 EmitFormatDiagnostic(S.
PDiag(diag::warn_os_log_format_narg),
12176 getLocationOfByte(CS.getStart()),
12178 getSpecifierRange(startSpecifier, specifierLen));
12185 (CS.getKind() == ConversionSpecifier::PArg ||
12186 CS.getKind() == ConversionSpecifier::sArg ||
12187 CS.getKind() == ConversionSpecifier::ObjCObjArg)) {
12188 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12194 if (FS.isPublic().isSet()) {
12195 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12197 getLocationOfByte(FS.isPublic().getPosition()),
12199 getSpecifierRange(startSpecifier, specifierLen));
12201 if (FS.isPrivate().isSet()) {
12202 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12204 getLocationOfByte(FS.isPrivate().getPosition()),
12206 getSpecifierRange(startSpecifier, specifierLen));
12210 const llvm::Triple &Triple =
Target.getTriple();
12211 if (CS.getKind() == ConversionSpecifier::nArg &&
12212 (Triple.isAndroid() || Triple.isOSFuchsia())) {
12213 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_narg_not_supported),
12214 getLocationOfByte(CS.getStart()),
12216 getSpecifierRange(startSpecifier, specifierLen));
12220 if (!FS.hasValidFieldWidth()) {
12221 HandleInvalidAmount(FS, FS.getFieldWidth(), 0,
12222 startSpecifier, specifierLen);
12226 if (!FS.hasValidPrecision()) {
12227 HandleInvalidAmount(FS, FS.getPrecision(), 1,
12228 startSpecifier, specifierLen);
12232 if (CS.getKind() == ConversionSpecifier::PArg &&
12233 FS.getPrecision().getHowSpecified() == OptionalAmount::NotSpecified) {
12234 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_no_precision),
12235 getLocationOfByte(startSpecifier),
12237 getSpecifierRange(startSpecifier, specifierLen));
12241 if (!FS.hasValidThousandsGroupingPrefix())
12242 HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen);
12243 if (!FS.hasValidLeadingZeros())
12244 HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
12245 if (!FS.hasValidPlusPrefix())
12246 HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
12247 if (!FS.hasValidSpacePrefix())
12248 HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
12249 if (!FS.hasValidAlternativeForm())
12250 HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
12251 if (!FS.hasValidLeftJustified())
12252 HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
12255 if (FS.hasSpacePrefix() && FS.hasPlusPrefix())
12256 HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
12257 startSpecifier, specifierLen);
12258 if (FS.hasLeadingZeros() && FS.isLeftJustified())
12259 HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
12260 startSpecifier, specifierLen);
12265 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12266 diag::warn_format_nonsensical_length);
12267 else if (!FS.hasStandardLengthModifier())
12268 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12269 else if (!FS.hasStandardLengthConversionCombination())
12270 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12271 diag::warn_format_non_standard_conversion_spec);
12273 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12274 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12280 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12283 const Expr *Arg = getDataArg(argIndex);
12287 return checkFormatExpr(FS, startSpecifier, specifierLen, Arg);
12299 case Stmt::ArraySubscriptExprClass:
12300 case Stmt::CallExprClass:
12301 case Stmt::CharacterLiteralClass:
12302 case Stmt::CXXBoolLiteralExprClass:
12303 case Stmt::DeclRefExprClass:
12304 case Stmt::FloatingLiteralClass:
12305 case Stmt::IntegerLiteralClass:
12306 case Stmt::MemberExprClass:
12307 case Stmt::ObjCArrayLiteralClass:
12308 case Stmt::ObjCBoolLiteralExprClass:
12309 case Stmt::ObjCBoxedExprClass:
12310 case Stmt::ObjCDictionaryLiteralClass:
12311 case Stmt::ObjCEncodeExprClass:
12312 case Stmt::ObjCIvarRefExprClass:
12313 case Stmt::ObjCMessageExprClass:
12314 case Stmt::ObjCPropertyRefExprClass:
12315 case Stmt::ObjCStringLiteralClass:
12316 case Stmt::ObjCSubscriptRefExprClass:
12317 case Stmt::ParenExprClass:
12318 case Stmt::StringLiteralClass:
12319 case Stmt::UnaryOperatorClass:
12326static std::pair<QualType, StringRef>
12333 StringRef Name = UserTy->getDecl()->getName();
12334 QualType CastTy = llvm::StringSwitch<QualType>(Name)
12338 .Case(
"SInt32", Context.
IntTy)
12343 return std::make_pair(CastTy, Name);
12345 TyTy = UserTy->desugar();
12349 if (
const ParenExpr *PE = dyn_cast<ParenExpr>(E))
12351 PE->getSubExpr()->getType(),
12360 StringRef TrueName, FalseName;
12362 std::tie(TrueTy, TrueName) =
12364 CO->getTrueExpr()->getType(),
12365 CO->getTrueExpr());
12366 std::tie(FalseTy, FalseName) =
12368 CO->getFalseExpr()->getType(),
12369 CO->getFalseExpr());
12371 if (TrueTy == FalseTy)
12372 return std::make_pair(TrueTy, TrueName);
12373 else if (TrueTy.
isNull())
12374 return std::make_pair(FalseTy, FalseName);
12375 else if (FalseTy.
isNull())
12376 return std::make_pair(TrueTy, TrueName);
12379 return std::make_pair(
QualType(), StringRef());
12398 From = VecTy->getElementType();
12400 To = VecTy->getElementType();
12408 const char *StartSpecifier,
12409 unsigned SpecifierLen,
12411 using namespace analyze_format_string;
12412 using namespace analyze_printf;
12421 while (
const TypeOfExprType *TET = dyn_cast<TypeOfExprType>(ExprTy)) {
12422 ExprTy = TET->getUnderlyingExpr()->getType();
12434 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::cArg &&
12437 getSpecifierRange(StartSpecifier, SpecifierLen);
12439 llvm::raw_svector_ostream os(FSString);
12441 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_bool_as_character)
12447 ArgType::MatchKind ImplicitMatch = ArgType::NoMatch;
12449 if (Match == ArgType::Match)
12453 assert(Match != ArgType::NoMatchPromotionTypeConfusion);
12462 E = ICE->getSubExpr();
12472 if (ImplicitMatch == ArgType::Match)
12483 FS.getLengthModifier().getKind() != LengthModifier::AsChar)
12490 if (Match == ArgType::MatchPromotion)
12491 Match = ArgType::NoMatch;
12494 if (Match == ArgType::MatchPromotion) {
12498 ImplicitMatch != ArgType::NoMatchPromotionTypeConfusion &&
12499 ImplicitMatch != ArgType::NoMatchTypeConfusion)
12501 Match = ArgType::NoMatch;
12503 if (ImplicitMatch == ArgType::NoMatchPedantic ||
12504 ImplicitMatch == ArgType::NoMatchTypeConfusion)
12505 Match = ImplicitMatch;
12506 assert(Match != ArgType::MatchPromotion);
12509 bool IsEnum =
false;
12510 bool IsScopedEnum =
false;
12513 IntendedTy = EnumTy->getDecl()->getIntegerType();
12514 if (EnumTy->isUnscopedEnumerationType()) {
12515 ExprTy = IntendedTy;
12520 IsScopedEnum =
true;
12527 if (isObjCContext() &&
12528 FS.getConversionSpecifier().getKind() == ConversionSpecifier::CArg) {
12538 const llvm::APInt &
V = IL->getValue();
12548 if (TD->getUnderlyingType() == IntendedTy)
12556 bool ShouldNotPrintDirectly =
false; StringRef CastTyName;
12564 if (!IsScopedEnum &&
12565 (CastTyName ==
"NSInteger" || CastTyName ==
"NSUInteger") &&
12568 Match = ArgType::NoMatchPedantic;
12569 IntendedTy = CastTy;
12570 ShouldNotPrintDirectly =
true;
12575 PrintfSpecifier fixedFS = FS;
12582 llvm::raw_svector_ostream os(buf);
12583 fixedFS.toString(os);
12585 CharSourceRange SpecRange = getSpecifierRange(StartSpecifier, SpecifierLen);
12587 if (IntendedTy == ExprTy && !ShouldNotPrintDirectly && !IsScopedEnum) {
12590 case ArgType::Match:
12591 case ArgType::MatchPromotion:
12592 case ArgType::NoMatchPromotionTypeConfusion:
12593 llvm_unreachable(
"expected non-matching");
12594 case ArgType::NoMatchPedantic:
12595 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12597 case ArgType::NoMatchTypeConfusion:
12598 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12600 case ArgType::NoMatch:
12601 Diag = diag::warn_format_conversion_argument_type_mismatch;
12622 llvm::raw_svector_ostream CastFix(CastBuf);
12623 CastFix << (S.
LangOpts.CPlusPlus ?
"static_cast<" :
"(");
12625 CastFix << (S.
LangOpts.CPlusPlus ?
">" :
")");
12629 ShouldNotPrintDirectly)
12632 if (
const CStyleCastExpr *CCast = dyn_cast<CStyleCastExpr>(E)) {
12634 SourceRange CastRange(CCast->getLParenLoc(), CCast->getRParenLoc());
12656 if (ShouldNotPrintDirectly && !IsScopedEnum) {
12662 Name = TypedefTy->getDecl()->getName();
12665 unsigned Diag = Match == ArgType::NoMatchPedantic
12666 ? diag::warn_format_argument_needs_cast_pedantic
12667 : diag::warn_format_argument_needs_cast;
12668 EmitFormatDiagnostic(S.
PDiag(
Diag) << Name << IntendedTy << IsEnum
12676 EmitFormatDiagnostic(
12677 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12689 bool EmitTypeMismatch =
false;
12695 case ArgType::Match:
12696 case ArgType::MatchPromotion:
12697 case ArgType::NoMatchPromotionTypeConfusion:
12698 llvm_unreachable(
"expected non-matching");
12699 case ArgType::NoMatchPedantic:
12700 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12702 case ArgType::NoMatchTypeConfusion:
12703 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12705 case ArgType::NoMatch:
12706 Diag = diag::warn_format_conversion_argument_type_mismatch;
12710 EmitFormatDiagnostic(
12719 EmitTypeMismatch =
true;
12721 EmitFormatDiagnostic(
12722 S.
PDiag(diag::warn_non_pod_vararg_with_format_string)
12723 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12727 checkForCStrMembers(AT, E);
12733 EmitTypeMismatch =
true;
12735 EmitFormatDiagnostic(
12736 S.
PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
12737 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12745 << isa<InitListExpr>(E) << ExprTy << CallType
12750 if (EmitTypeMismatch) {
12756 EmitFormatDiagnostic(
12757 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12763 assert(FirstDataArg + FS.getArgIndex() < CheckedVarArgs.size() &&
12764 "format string specifier index out of range");
12765 CheckedVarArgs[FirstDataArg + FS.getArgIndex()] =
true;
12775class CheckScanfHandler :
public CheckFormatHandler {
12777 CheckScanfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
12779 unsigned firstDataArg,
unsigned numDataArgs,
12783 llvm::SmallBitVector &CheckedVarArgs,
12784 UncoveredArgHandler &UncoveredArg)
12785 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
12786 numDataArgs, beg, APK, Args, formatIdx,
12787 inFunctionCall, CallType, CheckedVarArgs,
12791 const char *startSpecifier,
12792 unsigned specifierLen)
override;
12794 bool HandleInvalidScanfConversionSpecifier(
12796 const char *startSpecifier,
12797 unsigned specifierLen)
override;
12799 void HandleIncompleteScanList(
const char *start,
const char *end)
override;
12804void CheckScanfHandler::HandleIncompleteScanList(
const char *start,
12806 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_scanlist_incomplete),
12807 getLocationOfByte(end),
true,
12808 getSpecifierRange(start, end - start));
12811bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
12813 const char *startSpecifier,
12814 unsigned specifierLen) {
12816 FS.getConversionSpecifier();
12818 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
12820 startSpecifier, specifierLen,
12824bool CheckScanfHandler::HandleScanfSpecifier(
12826 const char *startSpecifier,
12827 unsigned specifierLen) {
12828 using namespace analyze_scanf;
12829 using namespace analyze_format_string;
12831 const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
12835 if (FS.consumesDataArgument()) {
12837 atFirstArg =
false;
12838 usesPositionalArgs = FS.usesPositionalArg();
12840 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12841 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12842 startSpecifier, specifierLen);
12848 const OptionalAmount &Amt = FS.getFieldWidth();
12849 if (Amt.getHowSpecified() == OptionalAmount::Constant) {
12850 if (Amt.getConstantAmount() == 0) {
12852 Amt.getConstantLength());
12853 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_nonzero_width),
12854 getLocationOfByte(Amt.getStart()),
12860 if (!FS.consumesDataArgument()) {
12867 unsigned argIndex = FS.getArgIndex();
12868 if (argIndex < NumDataArgs) {
12872 CoveredArgs.set(argIndex);
12878 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12879 diag::warn_format_nonsensical_length);
12880 else if (!FS.hasStandardLengthModifier())
12881 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12882 else if (!FS.hasStandardLengthConversionCombination())
12883 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12884 diag::warn_format_non_standard_conversion_spec);
12886 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12887 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12893 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12897 const Expr *Ex = getDataArg(argIndex);
12913 ScanfSpecifier fixedFS = FS;
12918 Pedantic ? diag::warn_format_conversion_argument_type_mismatch_pedantic
12919 : diag::warn_format_conversion_argument_type_mismatch;
12924 llvm::raw_svector_ostream os(buf);
12925 fixedFS.toString(os);
12927 EmitFormatDiagnostic(
12932 getSpecifierRange(startSpecifier, specifierLen),
12934 getSpecifierRange(startSpecifier, specifierLen), os.str()));
12941 getSpecifierRange(startSpecifier, specifierLen));
12948 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
12952 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
12953 bool IgnoreStringsWithoutSpecifiers) {
12955 if (!FExpr->isAscii() && !FExpr->isUTF8()) {
12956 CheckFormatHandler::EmitFormatDiagnostic(
12957 S, inFunctionCall, Args[format_idx],
12958 S.
PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
12964 StringRef StrRef = FExpr->getString();
12965 const char *Str = StrRef.data();
12969 assert(T &&
"String literal not of constant array type!");
12970 size_t TypeSize = T->
getSize().getZExtValue();
12971 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
12972 const unsigned numDataArgs = Args.size() - firstDataArg;
12974 if (IgnoreStringsWithoutSpecifiers &&
12981 if (TypeSize <= StrRef.size() && !StrRef.substr(0, TypeSize).contains(
'\0')) {
12982 CheckFormatHandler::EmitFormatDiagnostic(
12983 S, inFunctionCall, Args[format_idx],
12984 S.
PDiag(diag::warn_printf_format_string_not_null_terminated),
12985 FExpr->getBeginLoc(),
12991 if (StrLen == 0 && numDataArgs > 0) {
12992 CheckFormatHandler::EmitFormatDiagnostic(
12993 S, inFunctionCall, Args[format_idx],
12994 S.
PDiag(diag::warn_empty_format_string), FExpr->getBeginLoc(),
13002 CheckPrintfHandler H(
13003 S, FExpr, OrigFormatExpr,
Type, firstDataArg, numDataArgs,
13005 Args, format_idx, inFunctionCall, CallType, CheckedVarArgs,
13011 H.DoneProcessing();
13013 CheckScanfHandler H(S, FExpr, OrigFormatExpr,
Type, firstDataArg,
13014 numDataArgs, Str, APK, Args, format_idx, inFunctionCall,
13015 CallType, CheckedVarArgs, UncoveredArg);
13019 H.DoneProcessing();
13026 const char *Str = StrRef.data();
13029 assert(T &&
"String literal not of constant array type!");
13030 size_t TypeSize = T->
getSize().getZExtValue();
13031 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13042 switch (AbsFunction) {
13046 case Builtin::BI__builtin_abs:
13047 return Builtin::BI__builtin_labs;
13048 case Builtin::BI__builtin_labs:
13049 return Builtin::BI__builtin_llabs;
13050 case Builtin::BI__builtin_llabs:
13053 case Builtin::BI__builtin_fabsf:
13054 return Builtin::BI__builtin_fabs;
13055 case Builtin::BI__builtin_fabs:
13056 return Builtin::BI__builtin_fabsl;
13057 case Builtin::BI__builtin_fabsl:
13060 case Builtin::BI__builtin_cabsf:
13061 return Builtin::BI__builtin_cabs;
13062 case Builtin::BI__builtin_cabs:
13063 return Builtin::BI__builtin_cabsl;
13064 case Builtin::BI__builtin_cabsl:
13067 case Builtin::BIabs:
13068 return Builtin::BIlabs;
13069 case Builtin::BIlabs:
13070 return Builtin::BIllabs;
13071 case Builtin::BIllabs:
13074 case Builtin::BIfabsf:
13075 return Builtin::BIfabs;
13076 case Builtin::BIfabs:
13077 return Builtin::BIfabsl;
13078 case Builtin::BIfabsl:
13081 case Builtin::BIcabsf:
13082 return Builtin::BIcabs;
13083 case Builtin::BIcabs:
13084 return Builtin::BIcabsl;
13085 case Builtin::BIcabsl:
13092 unsigned AbsType) {
13114 unsigned AbsFunctionKind) {
13115 unsigned BestKind = 0;
13117 for (
unsigned Kind = AbsFunctionKind; Kind != 0;
13123 else if (Context.
hasSameType(ParamType, ArgType)) {
13146 llvm_unreachable(
"Type not integer, floating, or complex");
13153 switch (ValueKind) {
13158 case Builtin::BI__builtin_fabsf:
13159 case Builtin::BI__builtin_fabs:
13160 case Builtin::BI__builtin_fabsl:
13161 case Builtin::BI__builtin_cabsf:
13162 case Builtin::BI__builtin_cabs:
13163 case Builtin::BI__builtin_cabsl:
13164 return Builtin::BI__builtin_abs;
13165 case Builtin::BIfabsf:
13166 case Builtin::BIfabs:
13167 case Builtin::BIfabsl:
13168 case Builtin::BIcabsf:
13169 case Builtin::BIcabs:
13170 case Builtin::BIcabsl:
13171 return Builtin::BIabs;
13177 case Builtin::BI__builtin_abs:
13178 case Builtin::BI__builtin_labs:
13179 case Builtin::BI__builtin_llabs:
13180 case Builtin::BI__builtin_cabsf:
13181 case Builtin::BI__builtin_cabs:
13182 case Builtin::BI__builtin_cabsl:
13183 return Builtin::BI__builtin_fabsf;
13184 case Builtin::BIabs:
13185 case Builtin::BIlabs:
13186 case Builtin::BIllabs:
13187 case Builtin::BIcabsf:
13188 case Builtin::BIcabs:
13189 case Builtin::BIcabsl:
13190 return Builtin::BIfabsf;
13196 case Builtin::BI__builtin_abs:
13197 case Builtin::BI__builtin_labs:
13198 case Builtin::BI__builtin_llabs:
13199 case Builtin::BI__builtin_fabsf:
13200 case Builtin::BI__builtin_fabs:
13201 case Builtin::BI__builtin_fabsl:
13202 return Builtin::BI__builtin_cabsf;
13203 case Builtin::BIabs:
13204 case Builtin::BIlabs:
13205 case Builtin::BIllabs:
13206 case Builtin::BIfabsf:
13207 case Builtin::BIfabs:
13208 case Builtin::BIfabsl:
13209 return Builtin::BIcabsf;
13212 llvm_unreachable(
"Unable to convert function");
13223 case Builtin::BI__builtin_abs:
13224 case Builtin::BI__builtin_fabs:
13225 case Builtin::BI__builtin_fabsf:
13226 case Builtin::BI__builtin_fabsl:
13227 case Builtin::BI__builtin_labs:
13228 case Builtin::BI__builtin_llabs:
13229 case Builtin::BI__builtin_cabs:
13230 case Builtin::BI__builtin_cabsf:
13231 case Builtin::BI__builtin_cabsl:
13232 case Builtin::BIabs:
13233 case Builtin::BIlabs:
13234 case Builtin::BIllabs:
13235 case Builtin::BIfabs:
13236 case Builtin::BIfabsf:
13237 case Builtin::BIfabsl:
13238 case Builtin::BIcabs:
13239 case Builtin::BIcabsf:
13240 case Builtin::BIcabsl:
13243 llvm_unreachable(
"Unknown Builtin type");
13249 unsigned AbsKind,
QualType ArgType) {
13250 bool EmitHeaderHint =
true;
13251 const char *HeaderName =
nullptr;
13252 StringRef FunctionName;
13254 FunctionName =
"std::abs";
13256 HeaderName =
"cstdlib";
13258 HeaderName =
"cmath";
13260 llvm_unreachable(
"Invalid Type");
13269 for (
const auto *I : R) {
13272 FDecl = dyn_cast<FunctionDecl>(UsingD->getTargetDecl());
13274 FDecl = dyn_cast<FunctionDecl>(I);
13289 EmitHeaderHint =
false;
13307 EmitHeaderHint =
false;
13311 }
else if (!R.
empty()) {
13317 S.
Diag(Loc, diag::note_replace_abs_function)
13323 if (!EmitHeaderHint)
13326 S.
Diag(Loc, diag::note_include_header_or_declare) << HeaderName
13330template <std::
size_t StrLen>
13332 const char (&Str)[StrLen]) {
13347 (
Call->getBuiltinCallee() == Builtin::BI__builtin_nanf)) &&
13348 FPO.getNoHonorNaNs())
13349 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13350 << 1 << 0 <<
Call->getSourceRange();
13354 FPO.getNoHonorInfs())
13355 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13356 << 0 << 0 <<
Call->getSourceRange();
13360void Sema::CheckAbsoluteValueFunction(
const CallExpr *
Call,
13362 if (
Call->getNumArgs() != 1)
13367 if (AbsKind == 0 && !IsStdAbs)
13370 QualType ArgType =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13376 StringRef FunctionName =
13378 Diag(
Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
13379 Diag(
Call->getExprLoc(), diag::note_remove_abs)
13388 unsigned DiagType = 0;
13394 Diag(
Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;
13408 if (ArgValueKind == ParamValueKind) {
13413 Diag(
Call->getExprLoc(), diag::warn_abs_too_small)
13414 << FDecl << ArgType << ParamType;
13416 if (NewAbsKind == 0)
13420 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13429 if (NewAbsKind == 0)
13432 Diag(
Call->getExprLoc(), diag::warn_wrong_absolute_value_type)
13433 << FDecl << ParamValueKind << ArgValueKind;
13436 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13442 if (!
Call || !FDecl)
return;
13446 if (
Call->getExprLoc().isMacroID())
return;
13449 if (
Call->getNumArgs() != 2)
return;
13452 if (!ArgList)
return;
13453 if (ArgList->size() != 1)
return;
13456 const auto& TA = ArgList->
get(0);
13458 QualType ArgType = TA.getAsType();
13462 auto IsLiteralZeroArg = [](
const Expr* E) ->
bool {
13463 const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
13464 if (!MTE)
return false;
13465 const auto *Num = dyn_cast<IntegerLiteral>(MTE->getSubExpr());
13466 if (!Num)
return false;
13467 if (Num->getValue() != 0)
return false;
13471 const Expr *FirstArg =
Call->getArg(0);
13472 const Expr *SecondArg =
Call->getArg(1);
13473 const bool IsFirstArgZero = IsLiteralZeroArg(FirstArg);
13474 const bool IsSecondArgZero = IsLiteralZeroArg(SecondArg);
13477 if (IsFirstArgZero == IsSecondArgZero)
return;
13482 SourceRange ZeroRange = IsFirstArgZero ? FirstRange : SecondRange;
13484 Diag(
Call->getExprLoc(), diag::warn_max_unsigned_zero)
13485 << IsFirstArgZero <<
Call->getCallee()->getSourceRange() << ZeroRange;
13489 if (IsFirstArgZero) {
13497 Diag(
Call->getExprLoc(), diag::note_remove_max_call)
13517 if (!Size->isComparisonOp() && !Size->isLogicalOp())
13521 S.
Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison)
13522 << SizeRange << FnName;
13523 S.
Diag(FnLoc, diag::note_memsize_comparison_paren)
13528 S.
Diag(SizeRange.
getBegin(), diag::note_memsize_comparison_cast_silence)
13539 bool &IsContained) {
13542 IsContained =
false;
13555 for (
auto *FD : RD->
fields()) {
13559 IsContained =
true;
13560 return ContainedRD;
13568 if (
const auto *Unary = dyn_cast<UnaryExprOrTypeTraitExpr>(E))
13569 if (Unary->getKind() == UETT_SizeOf)
13578 if (!
SizeOf->isArgumentType())
13579 return SizeOf->getArgumentExpr()->IgnoreParenImpCasts();
13586 return SizeOf->getTypeOfArgument();
13592struct SearchNonTrivialToInitializeField
13597 SearchNonTrivialToInitializeField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13601 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13602 asDerived().visitArray(PDIK, AT, SL);
13606 Super::visitWithKind(PDIK, FT, SL);
13621 visit(getContext().getBaseElementType(AT), SL);
13626 SearchNonTrivialToInitializeField(E, S).visitStruct(RT,
SourceLocation());
13635struct SearchNonTrivialToCopyField
13639 SearchNonTrivialToCopyField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13643 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13644 asDerived().visitArray(PCK, AT, SL);
13648 Super::visitWithKind(PCK, FT, SL);
13663 visit(getContext().getBaseElementType(AT), SL);
13671 SearchNonTrivialToCopyField(E, S).visitStruct(RT,
SourceLocation());
13686 if (
const auto *BO = dyn_cast<BinaryOperator>(SizeofExpr)) {
13687 if (BO->getOpcode() != BO_Mul && BO->getOpcode() != BO_Add)
13711 return SM.getFileID(CallLoc) !=
SM.getFileID(ArgLoc);
13713 return SM.getFileID(
SM.getImmediateMacroCallerLoc(CallLoc)) !=
13714 SM.getFileID(
SM.getImmediateMacroCallerLoc(ArgLoc));
13720 if (BId != Builtin::BImemset && BId != Builtin::BIbzero)
13723 const Expr *SizeArg =
13724 Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
13726 auto isLiteralZero = [](
const Expr *E) {
13727 return (isa<IntegerLiteral>(E) &&
13728 cast<IntegerLiteral>(E)->getValue() == 0) ||
13729 (isa<CharacterLiteral>(E) &&
13730 cast<CharacterLiteral>(E)->getValue() == 0);
13736 if (isLiteralZero(SizeArg) &&
13743 if (BId == Builtin::BIbzero ||
13746 S.
Diag(DiagLoc, diag::warn_suspicious_bzero_size);
13747 S.
Diag(DiagLoc, diag::note_suspicious_bzero_size_silence);
13748 }
else if (!isLiteralZero(
Call->getArg(1)->IgnoreImpCasts())) {
13749 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 0;
13750 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 0;
13758 if (BId == Builtin::BImemset &&
13762 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 1;
13763 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 1;
13775void Sema::CheckMemaccessArguments(
const CallExpr *
Call,
13782 unsigned ExpectedNumArgs =
13783 (BId == Builtin::BIstrndup || BId == Builtin::BIbzero ? 2 : 3);
13784 if (
Call->getNumArgs() < ExpectedNumArgs)
13787 unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
13788 BId == Builtin::BIstrndup ? 1 : 2);
13790 (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
13791 const Expr *LenExpr =
Call->getArg(LenArg)->IgnoreParenImpCasts();
13794 Call->getBeginLoc(),
Call->getRParenLoc()))
13803 llvm::FoldingSetNodeID SizeOfArgID;
13808 QualType FirstArgTy =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13812 for (
unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {
13813 const Expr *Dest =
Call->getArg(ArgIdx)->IgnoreParenImpCasts();
13835 if (SizeOfArgID == llvm::FoldingSetNodeID())
13837 llvm::FoldingSetNodeID DestID;
13839 if (DestID == SizeOfArgID) {
13842 unsigned ActionIdx = 0;
13843 StringRef ReadableName = FnName->
getName();
13845 if (
const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
13846 if (UnaryOp->getOpcode() == UO_AddrOf)
13860 if (
SM.isMacroArgExpansion(SL)) {
13862 SL =
SM.getSpellingLoc(SL);
13870 PDiag(diag::warn_sizeof_pointer_expr_memaccess)
13877 PDiag(diag::warn_sizeof_pointer_expr_memaccess_note)
13892 PDiag(diag::warn_sizeof_pointer_type_memaccess)
13893 << FnName << SizeOfArgTy << ArgIdx
13900 PointeeTy = DestTy;
13911 unsigned OperationType = 0;
13912 const bool IsCmp = BId == Builtin::BImemcmp || BId == Builtin::BIbcmp;
13915 if (ArgIdx != 0 || IsCmp) {
13916 if (BId == Builtin::BImemcpy)
13918 else if(BId == Builtin::BImemmove)
13925 PDiag(diag::warn_dyn_class_memaccess)
13926 << (IsCmp ? ArgIdx + 2 : ArgIdx) << FnName
13927 << IsContained << ContainedRD << OperationType
13928 <<
Call->getCallee()->getSourceRange());
13930 BId != Builtin::BImemset)
13933 PDiag(diag::warn_arc_object_memaccess)
13934 << ArgIdx << FnName << PointeeTy
13935 <<
Call->getCallee()->getSourceRange());
13937 if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
13938 RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
13940 PDiag(diag::warn_cstruct_memaccess)
13941 << ArgIdx << FnName << PointeeTy << 0);
13942 SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *
this);
13943 }
else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
13944 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
13946 PDiag(diag::warn_cstruct_memaccess)
13947 << ArgIdx << FnName << PointeeTy << 1);
13948 SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *
this);
13957 PDiag(diag::note_bad_memaccess_silence)
13977 if (isa<IntegerLiteral>(RHS))
13979 else if (isa<IntegerLiteral>(LHS))
13993 if (CAT->getSize().getSExtValue() <= 1)
14003void Sema::CheckStrlcpycatArguments(
const CallExpr *
Call,
14007 unsigned NumArgs =
Call->getNumArgs();
14008 if ((NumArgs != 3) && (NumArgs != 4))
14013 const Expr *CompareWithSrc =
nullptr;
14016 Call->getBeginLoc(),
Call->getRParenLoc()))
14021 CompareWithSrc = Ex;
14024 if (
const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
14025 if (SizeCall->getBuiltinCallee() == Builtin::BIstrlen &&
14026 SizeCall->getNumArgs() == 1)
14031 if (!CompareWithSrc)
14038 const DeclRefExpr *SrcArgDRE = dyn_cast<DeclRefExpr>(SrcArg);
14042 const DeclRefExpr *CompareWithSrcDRE = dyn_cast<DeclRefExpr>(CompareWithSrc);
14043 if (!CompareWithSrcDRE ||
14047 const Expr *OriginalSizeArg =
Call->getArg(2);
14048 Diag(CompareWithSrcDRE->
getBeginLoc(), diag::warn_strlcpycat_wrong_size)
14055 const Expr *DstArg =
Call->getArg(0)->IgnoreParenImpCasts();
14060 llvm::raw_svector_ostream
OS(sizeString);
14065 Diag(OriginalSizeArg->
getBeginLoc(), diag::note_strlcpycat_wrong_size)
14072 if (
const DeclRefExpr *D1 = dyn_cast_or_null<DeclRefExpr>(E1))
14073 if (
const DeclRefExpr *D2 = dyn_cast_or_null<DeclRefExpr>(E2))
14074 return D1->getDecl() == D2->getDecl();
14079 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
14083 return CE->getArg(0)->IgnoreParenCasts();
14091void Sema::CheckStrncatArguments(
const CallExpr *CE,
14106 unsigned PatternType = 0;
14114 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(LenArg)) {
14115 if (BE->getOpcode() == BO_Sub) {
14128 if (PatternType == 0)
14137 if (
SM.isMacroArgExpansion(SL)) {
14138 SL =
SM.getSpellingLoc(SL);
14147 if (!isKnownSizeArray) {
14148 if (PatternType == 1)
14149 Diag(SL, diag::warn_strncat_wrong_size) << SR;
14151 Diag(SL, diag::warn_strncat_src_size) << SR;
14155 if (PatternType == 1)
14156 Diag(SL, diag::warn_strncat_large_size) << SR;
14158 Diag(SL, diag::warn_strncat_src_size) << SR;
14161 llvm::raw_svector_ostream
OS(sizeString);
14169 Diag(SL, diag::note_strncat_wrong_size)
14174void CheckFreeArgumentsOnLvalue(
Sema &S,
const std::string &CalleeName,
14176 if (isa<FieldDecl, FunctionDecl, VarDecl>(D)) {
14178 << CalleeName << 0 << cast<NamedDecl>(D);
14183void CheckFreeArgumentsAddressof(
Sema &S,
const std::string &CalleeName,
14185 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->
getSubExpr())) {
14186 const Decl *D = Lvalue->getDecl();
14187 if (isa<DeclaratorDecl>(D))
14188 if (!dyn_cast<DeclaratorDecl>(D)->getType()->isReferenceType())
14189 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
14192 if (
const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->
getSubExpr()))
14193 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
14194 Lvalue->getMemberDecl());
14197void CheckFreeArgumentsPlus(
Sema &S,
const std::string &CalleeName,
14199 const auto *Lambda = dyn_cast<LambdaExpr>(
14204 S.
Diag(Lambda->getBeginLoc(), diag::warn_free_nonheap_object)
14205 << CalleeName << 2 ;
14208void CheckFreeArgumentsStackArray(
Sema &S,
const std::string &CalleeName,
14210 const auto *Var = dyn_cast<VarDecl>(Lvalue->
getDecl());
14211 if (Var ==
nullptr)
14215 << CalleeName << 0 << Var;
14218void CheckFreeArgumentsCast(
Sema &S,
const std::string &CalleeName,
14221 llvm::raw_svector_ostream OS(SizeString);
14224 if (Kind == clang::CK_BitCast &&
14225 !
Cast->getSubExpr()->getType()->isFunctionPointerType())
14227 if (Kind == clang::CK_IntegralToPointer &&
14228 !isa<IntegerLiteral>(
14229 Cast->getSubExpr()->IgnoreParenImpCasts()->IgnoreParens()))
14232 switch (
Cast->getCastKind()) {
14233 case clang::CK_BitCast:
14234 case clang::CK_IntegralToPointer:
14235 case clang::CK_FunctionToPointerDecay:
14244 S.
Diag(
Cast->getBeginLoc(), diag::warn_free_nonheap_object)
14245 << CalleeName << 0 << OS.str();
14250void Sema::CheckFreeArguments(
const CallExpr *E) {
14251 const std::string CalleeName =
14252 cast<FunctionDecl>(E->
getCalleeDecl())->getQualifiedNameAsString();
14256 if (
const auto *UnaryExpr = dyn_cast<UnaryOperator>(Arg))
14258 case UnaryOperator::Opcode::UO_AddrOf:
14259 return CheckFreeArgumentsAddressof(*
this, CalleeName, UnaryExpr);
14260 case UnaryOperator::Opcode::UO_Plus:
14261 return CheckFreeArgumentsPlus(*
this, CalleeName, UnaryExpr);
14266 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
14268 return CheckFreeArgumentsStackArray(*
this, CalleeName, Lvalue);
14270 if (
const auto *
Label = dyn_cast<AddrLabelExpr>(Arg)) {
14271 Diag(
Label->getBeginLoc(), diag::warn_free_nonheap_object)
14272 << CalleeName << 0 <<
Label->getLabel()->getIdentifier();
14276 if (isa<BlockExpr>(Arg)) {
14278 << CalleeName << 1 ;
14283 if (
const auto *Cast = dyn_cast<CastExpr>(E->
getArg(0)))
14284 return CheckFreeArgumentsCast(*
this, CalleeName, Cast);
14288Sema::CheckReturnValExpr(
Expr *RetValExp,
QualType lhsType,
14294 if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) ||
14297 Diag(ReturnLoc, diag::warn_null_ret)
14307 if (Op == OO_New || Op == OO_Array_New) {
14312 Diag(ReturnLoc, diag::warn_operator_new_returns_null)
14318 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
14324 CheckPPCMMAType(RetValExp->
getType(), ReturnLoc);
14337 auto getCastAndLiteral = [&FPLiteral, &FPCast](
Expr *L,
Expr *R) {
14338 FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
14340 return FPLiteral && FPCast;
14343 if (getCastAndLiteral(LHS, RHS) || getCastAndLiteral(RHS, LHS)) {
14349 llvm::APFloat TargetC = FPLiteral->
getValue();
14351 llvm::APFloat::rmNearestTiesToEven, &Lossy);
14355 Diag(Loc, diag::warn_float_compare_literal)
14356 << (Opcode == BO_EQ) <<
QualType(SourceTy, 0)
14369 if (
auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
14370 if (
auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
14371 if (DRL->getDecl() == DRR->getDecl())
14379 if (
FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
14380 if (FLL->isExact())
14383 if (
FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
14384 if (FLR->isExact())
14388 if (
CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
14389 if (CL->getBuiltinCallee())
14392 if (
CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
14393 if (CR->getBuiltinCallee())
14397 Diag(Loc, diag::warn_floatingpoint_eq)
14418 IntRange(
unsigned Width,
bool NonNegative)
14419 : Width(Width), NonNegative(NonNegative) {}
14422 unsigned valueBits()
const {
14423 return NonNegative ? Width : Width - 1;
14427 static IntRange forBoolType() {
14428 return IntRange(1,
true);
14433 return forValueOfCanonicalType(
C,
14438 static IntRange forValueOfCanonicalType(
ASTContext &
C,
const Type *T) {
14441 if (
const VectorType *VT = dyn_cast<VectorType>(T))
14442 T = VT->getElementType().getTypePtr();
14443 if (
const ComplexType *CT = dyn_cast<ComplexType>(T))
14444 T = CT->getElementType().getTypePtr();
14445 if (
const AtomicType *AT = dyn_cast<AtomicType>(T))
14446 T = AT->getValueType().getTypePtr();
14448 if (!
C.getLangOpts().CPlusPlus) {
14450 if (
const EnumType *ET = dyn_cast<EnumType>(T))
14451 T = ET->getDecl()->getIntegerType().getDesugaredType(
C).getTypePtr();
14452 }
else if (
const EnumType *ET = dyn_cast<EnumType>(T)) {
14457 if (
Enum->isFixed()) {
14458 return IntRange(
C.getIntWidth(
QualType(T, 0)),
14459 !ET->isSignedIntegerOrEnumerationType());
14462 unsigned NumPositive =
Enum->getNumPositiveBits();
14463 unsigned NumNegative =
Enum->getNumNegativeBits();
14465 if (NumNegative == 0)
14466 return IntRange(NumPositive,
true);
14468 return IntRange(std::max(NumPositive + 1, NumNegative),
14472 if (
const auto *EIT = dyn_cast<BitIntType>(T))
14473 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14486 static IntRange forTargetOfCanonicalType(
ASTContext &
C,
const Type *T) {
14489 if (
const VectorType *VT = dyn_cast<VectorType>(T))
14490 T = VT->getElementType().getTypePtr();
14491 if (
const ComplexType *CT = dyn_cast<ComplexType>(T))
14492 T = CT->getElementType().getTypePtr();
14493 if (
const AtomicType *AT = dyn_cast<AtomicType>(T))
14494 T = AT->getValueType().getTypePtr();
14495 if (
const EnumType *ET = dyn_cast<EnumType>(T))
14496 T =
C.getCanonicalType(ET->getDecl()->getIntegerType()).getTypePtr();
14498 if (
const auto *EIT = dyn_cast<BitIntType>(T))
14499 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14508 static IntRange join(IntRange L, IntRange R) {
14509 bool Unsigned = L.NonNegative && R.NonNegative;
14510 return IntRange(std::max(L.valueBits(), R.valueBits()) + !
Unsigned,
14511 L.NonNegative && R.NonNegative);
14515 static IntRange bit_and(IntRange L, IntRange R) {
14516 unsigned Bits = std::max(L.Width, R.Width);
14517 bool NonNegative =
false;
14518 if (L.NonNegative) {
14519 Bits = std::min(Bits, L.Width);
14520 NonNegative =
true;
14522 if (R.NonNegative) {
14523 Bits = std::min(Bits, R.Width);
14524 NonNegative =
true;
14526 return IntRange(Bits, NonNegative);
14530 static IntRange sum(IntRange L, IntRange R) {
14531 bool Unsigned = L.NonNegative && R.NonNegative;
14532 return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !
Unsigned,
14537 static IntRange difference(IntRange L, IntRange R) {
14541 bool CanWiden = !L.NonNegative || !R.NonNegative;
14542 bool Unsigned = L.NonNegative && R.Width == 0;
14543 return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
14549 static IntRange product(IntRange L, IntRange R) {
14553 bool CanWiden = !L.NonNegative && !R.NonNegative;
14554 bool Unsigned = L.NonNegative && R.NonNegative;
14555 return IntRange(L.valueBits() + R.valueBits() + CanWiden + !
Unsigned,
14560 static IntRange rem(IntRange L, IntRange R) {
14564 return IntRange(std::min(L.valueBits(), R.valueBits()) + !
Unsigned,
14572 unsigned MaxWidth) {
14573 if (value.isSigned() && value.isNegative())
14574 return IntRange(value.getSignificantBits(),
false);
14576 if (value.getBitWidth() > MaxWidth)
14577 value = value.trunc(MaxWidth);
14581 return IntRange(value.getActiveBits(),
true);
14585 unsigned MaxWidth) {
14586 if (result.
isInt())
14593 R = IntRange::join(R, El);
14601 return IntRange::join(R, I);
14616 Ty = AtomicRHS->getValueType();
14629 bool InConstantContext,
bool Approximate) {
14640 if (
const auto *CE = dyn_cast<ImplicitCastExpr>(E)) {
14641 if (CE->getCastKind() == CK_NoOp || CE->getCastKind() == CK_LValueToRValue)
14642 return GetExprRange(
C, CE->getSubExpr(), MaxWidth, InConstantContext,
14645 IntRange OutputTypeRange = IntRange::forValueOfType(
C,
GetExprType(CE));
14647 bool isIntegerCast = CE->getCastKind() == CK_IntegralCast ||
14648 CE->getCastKind() == CK_BooleanToSignedIntegral;
14651 if (!isIntegerCast)
14652 return OutputTypeRange;
14655 std::min(MaxWidth, OutputTypeRange.Width),
14656 InConstantContext, Approximate);
14659 if (SubRange.Width >= OutputTypeRange.Width)
14660 return OutputTypeRange;
14664 return IntRange(SubRange.Width,
14665 SubRange.NonNegative || OutputTypeRange.NonNegative);
14668 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
14671 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult,
C))
14673 CondResult ? CO->getTrueExpr() : CO->getFalseExpr(),
14674 MaxWidth, InConstantContext, Approximate);
14679 Expr *E = CO->getTrueExpr();
14681 ? IntRange{0,
true}
14682 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14683 E = CO->getFalseExpr();
14685 ? IntRange{0,
true}
14686 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14687 return IntRange::join(L, R);
14690 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
14691 IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
14693 switch (BO->getOpcode()) {
14695 llvm_unreachable(
"builtin <=> should have class type");
14706 return IntRange::forBoolType();
14724 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14735 Combine = IntRange::bit_and;
14743 = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
14744 if (I->getValue() == 1) {
14745 IntRange R = IntRange::forValueOfType(
C,
GetExprType(E));
14746 return IntRange(R.Width,
true);
14756 case BO_ShrAssign: {
14757 IntRange L =
GetExprRange(
C, BO->getLHS(), MaxWidth, InConstantContext,
14762 if (std::optional<llvm::APSInt> shift =
14763 BO->getRHS()->getIntegerConstantExpr(
C)) {
14764 if (shift->isNonNegative()) {
14765 if (shift->uge(L.Width))
14766 L.Width = (L.NonNegative ? 0 : 1);
14768 L.Width -= shift->getZExtValue();
14777 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14782 Combine = IntRange::sum;
14786 if (BO->getLHS()->getType()->isPointerType())
14789 Combine = IntRange::difference;
14794 Combine = IntRange::product;
14802 IntRange L =
GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext,
14806 if (std::optional<llvm::APSInt> divisor =
14807 BO->getRHS()->getIntegerConstantExpr(
C)) {
14808 unsigned log2 = divisor->logBase2();
14809 if (
log2 >= L.Width)
14810 L.Width = (L.NonNegative ? 0 : 1);
14812 L.Width = std::min(L.Width -
log2, MaxWidth);
14819 IntRange R =
GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext,
14821 return IntRange(L.Width, L.NonNegative && R.NonNegative);
14825 Combine = IntRange::rem;
14837 unsigned opWidth =
C.getIntWidth(T);
14839 GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext, Approximate);
14841 GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext, Approximate);
14842 IntRange
C = Combine(L, R);
14844 C.Width = std::min(
C.Width, MaxWidth);
14848 if (
const auto *UO = dyn_cast<UnaryOperator>(E)) {
14849 switch (UO->getOpcode()) {
14852 return IntRange::forBoolType();
14860 return GetExprRange(
C, UO->getSubExpr(), MaxWidth, InConstantContext,
14865 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
14866 return GetExprRange(
C, OVE->getSourceExpr(), MaxWidth, InConstantContext,
14870 return IntRange(BitField->getBitWidthValue(
C),
14871 BitField->getType()->isUnsignedIntegerOrEnumerationType());
14877 bool InConstantContext,
bool Approximate) {
14886 const llvm::fltSemantics &Src,
14887 const llvm::fltSemantics &Tgt) {
14888 llvm::APFloat truncated = value;
14891 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
14892 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
14894 return truncated.bitwiseIsEqual(value);
14903 const llvm::fltSemantics &Src,
14904 const llvm::fltSemantics &Tgt) {
14921 bool IsListInit =
false);
14927 if (isa<EnumConstantDecl>(DR->getDecl()))
14937 return MacroName !=
"YES" && MacroName !=
"NO" &&
14938 MacroName !=
"true" && MacroName !=
"false";
14961struct PromotedRange {
14963 llvm::APSInt PromotedMin;
14965 llvm::APSInt PromotedMax;
14967 PromotedRange(IntRange R,
unsigned BitWidth,
bool Unsigned) {
14969 PromotedMin = PromotedMax = llvm::APSInt(BitWidth,
Unsigned);
14970 else if (R.Width >= BitWidth && !
Unsigned) {
14974 PromotedMin = llvm::APSInt::getMinValue(BitWidth,
Unsigned);
14975 PromotedMax = llvm::APSInt::getMaxValue(BitWidth,
Unsigned);
14977 PromotedMin = llvm::APSInt::getMinValue(R.Width, R.NonNegative)
14978 .extOrTrunc(BitWidth);
14979 PromotedMin.setIsUnsigned(
Unsigned);
14981 PromotedMax = llvm::APSInt::getMaxValue(R.Width, R.NonNegative)
14982 .extOrTrunc(BitWidth);
14983 PromotedMax.setIsUnsigned(
Unsigned);
14988 bool isContiguous()
const {
return PromotedMin <= PromotedMax; }
14998 InRangeFlag = 0x40,
15001 Min =
LE | InRangeFlag,
15003 Max =
GE | InRangeFlag,
15006 OnlyValue =
LE |
GE |
EQ | InRangeFlag,
15011 assert(
Value.getBitWidth() == PromotedMin.getBitWidth() &&
15012 Value.isUnsigned() == PromotedMin.isUnsigned());
15013 if (!isContiguous()) {
15014 assert(
Value.isUnsigned() &&
"discontiguous range for signed compare");
15015 if (
Value.isMinValue())
return Min;
15016 if (
Value.isMaxValue())
return Max;
15022 switch (llvm::APSInt::compareValues(
Value, PromotedMin)) {
15023 case -1:
return Less;
15024 case 0:
return PromotedMin == PromotedMax ? OnlyValue :
Min;
15026 switch (llvm::APSInt::compareValues(
Value, PromotedMax)) {
15028 case 0:
return Max;
15033 llvm_unreachable(
"impossible compare result");
15036 static std::optional<StringRef>
15038 if (Op == BO_Cmp) {
15040 if (ConstantOnRHS) std::swap(LTFlag, GTFlag);
15042 if (R & EQ)
return StringRef(
"'std::strong_ordering::equal'");
15043 if (R & LTFlag)
return StringRef(
"'std::strong_ordering::less'");
15044 if (R & GTFlag)
return StringRef(
"'std::strong_ordering::greater'");
15045 return std::nullopt;
15052 }
else if (Op == BO_NE) {
15056 if ((Op == BO_LT || Op == BO_GE) ^ ConstantOnRHS) {
15063 if (Op == BO_GE || Op == BO_LE)
15064 std::swap(TrueFlag, FalseFlag);
15067 return StringRef(
"true");
15069 return StringRef(
"false");
15070 return std::nullopt;
15078 if (ICE->getCastKind() != CK_IntegralCast &&
15079 ICE->getCastKind() != CK_NoOp)
15081 E = ICE->getSubExpr();
15090 enum ConstantValueKind {
15095 if (
auto *BL = dyn_cast<CXXBoolLiteralExpr>(Constant))
15096 return BL->getValue() ? ConstantValueKind::LiteralTrue
15097 : ConstantValueKind::LiteralFalse;
15098 return ConstantValueKind::Miscellaneous;
15103 const llvm::APSInt &
Value,
15104 bool RhsConstant) {
15129 OtherT = AT->getValueType();
15130 IntRange OtherTypeRange = IntRange::forValueOfType(S.
Context, OtherT);
15134 bool IsObjCSignedCharBool = S.
getLangOpts().ObjC &&
15135 S.
NSAPIObj->isObjCBOOLType(OtherT) &&
15140 bool OtherIsBooleanDespiteType =
15142 if (OtherIsBooleanDespiteType || IsObjCSignedCharBool)
15143 OtherTypeRange = OtherValueRange = IntRange::forBoolType();
15147 PromotedRange OtherPromotedValueRange(OtherValueRange,
Value.getBitWidth(),
15148 Value.isUnsigned());
15149 auto Cmp = OtherPromotedValueRange.compare(
Value);
15150 auto Result = PromotedRange::constantValue(E->
getOpcode(), Cmp, RhsConstant);
15156 bool TautologicalTypeCompare =
false;
15158 PromotedRange OtherPromotedTypeRange(OtherTypeRange,
Value.getBitWidth(),
15159 Value.isUnsigned());
15160 auto TypeCmp = OtherPromotedTypeRange.compare(
Value);
15163 TautologicalTypeCompare =
true;
15171 if (!TautologicalTypeCompare && OtherValueRange.Width == 0)
15180 bool InRange = Cmp & PromotedRange::InRangeFlag;
15186 if (
Other->refersToBitField() && InRange &&
Value == 0 &&
15187 Other->getType()->isUnsignedIntegerOrEnumerationType())
15188 TautologicalTypeCompare =
true;
15193 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
15194 ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
15198 llvm::raw_svector_ostream OS(PrettySourceValue);
15200 OS <<
'\'' << *ED <<
"' (" <<
Value <<
")";
15201 }
else if (
auto *BL = dyn_cast<ObjCBoolLiteralExpr>(
15203 OS << (BL->getValue() ?
"YES" :
"NO");
15208 if (!TautologicalTypeCompare) {
15210 << RhsConstant << OtherValueRange.Width << OtherValueRange.NonNegative
15216 if (IsObjCSignedCharBool) {
15218 S.
PDiag(diag::warn_tautological_compare_objc_bool)
15219 << OS.str() << *
Result);
15226 if (!InRange ||
Other->isKnownToHaveBooleanValue()) {
15230 S.
PDiag(!InRange ? diag::warn_out_of_range_compare
15231 : diag::warn_tautological_bool_compare)
15233 << OtherIsBooleanDespiteType << *
Result
15240 ? diag::warn_unsigned_enum_always_true_comparison
15241 : IsCharTy ? diag::warn_unsigned_char_always_true_comparison
15242 : diag::warn_unsigned_always_true_comparison)
15243 : diag::warn_tautological_constant_compare;
15280 std::optional<llvm::APSInt> RHSValue =
15282 std::optional<llvm::APSInt> LHSValue =
15286 if (RHSValue && LHSValue)
15290 if ((
bool)RHSValue ^ (
bool)LHSValue) {
15292 const bool RhsConstant = (
bool)RHSValue;
15293 Expr *Const = RhsConstant ? RHS : LHS;
15295 const llvm::APSInt &
Value = RhsConstant ? *RHSValue : *LHSValue;
15318 if (
const auto *TET = dyn_cast<TypeOfExprType>(LHS->
getType()))
15320 if (
const auto *TET = dyn_cast<TypeOfExprType>(RHS->
getType()))
15326 Expr *signedOperand, *unsignedOperand;
15329 "unsigned comparison between two signed integer expressions?");
15330 signedOperand = LHS;
15331 unsignedOperand = RHS;
15333 signedOperand = RHS;
15334 unsignedOperand = LHS;
15340 IntRange signedRange =
15350 if (signedRange.NonNegative)
15359 IntRange unsignedRange =
15365 assert(unsignedRange.NonNegative &&
"unsigned range includes negative?");
15367 if (unsignedRange.Width < comparisonWidth)
15372 S.
PDiag(diag::warn_mixed_sign_comparison)
15400 S.
Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield)
15401 << BitfieldEnumDecl;
15408 Init->isValueDependent() ||
15409 Init->isTypeDependent())
15412 Expr *OriginalInit =
Init->IgnoreParenImpCasts();
15435 unsigned DiagID = 0;
15436 if (SignedEnum && !SignedBitfield) {
15437 DiagID = diag::warn_unsigned_bitfield_assigned_signed_enum;
15438 }
else if (SignedBitfield && !SignedEnum &&
15440 DiagID = diag::warn_signed_bitfield_enum_conversion;
15444 S.
Diag(InitLoc, DiagID) << Bitfield << ED;
15449 << SignedEnum << TypeRange;
15460 if (BitsNeeded > FieldWidth) {
15462 S.
Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
15474 unsigned OriginalWidth =
Value.getBitWidth();
15480 bool OneAssignedToOneBitBitfield = FieldWidth == 1 &&
Value == 1;
15481 if (OneAssignedToOneBitBitfield && !S.
LangOpts.CPlusPlus) {
15488 if (!
Value.isSigned() ||
Value.isNegative())
15489 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(OriginalInit))
15490 if (UO->getOpcode() == UO_Minus || UO->getOpcode() == UO_Not)
15491 OriginalWidth =
Value.getSignificantBits();
15493 if (OriginalWidth <= FieldWidth)
15497 llvm::APSInt TruncatedValue =
Value.trunc(FieldWidth);
15501 TruncatedValue = TruncatedValue.extend(OriginalWidth);
15502 if (llvm::APSInt::isSameValue(
Value, TruncatedValue))
15506 std::string PrettyTrunc =
toString(TruncatedValue, 10);
15508 S.
Diag(InitLoc, OneAssignedToOneBitBitfield
15509 ? diag::warn_impcast_single_bit_bitield_precision_constant
15510 : diag::warn_impcast_bitfield_precision_constant)
15511 << PrettyValue << PrettyTrunc << OriginalInit->
getType()
15512 <<
Init->getSourceRange();
15544 bool pruneControlFlow =
false) {
15545 if (pruneControlFlow) {
15559 unsigned diag,
bool pruneControlFlow =
false) {
15571 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
15572 Ignored = OVE->getSourceExpr();
15573 bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
15574 isa<BinaryOperator>(Ignored) ||
15575 isa<CXXOperatorCallExpr>(Ignored);
15592 if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
15595 const bool IsLiteral =
15596 isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
15598 llvm::APFloat
Value(0.0);
15605 S.
Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
15610 diag::warn_impcast_float_integer, PruneWarnings);
15613 bool isExact =
false;
15617 llvm::APFloat::opStatus
Result =
Value.convertToInteger(
15618 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
15626 unsigned precision = llvm::APFloat::semanticsPrecision(
Value.getSemantics());
15627 precision = (precision * 59 + 195) / 196;
15628 Value.toString(PrettySourceValue, precision);
15633 S.
Diag(CContext, diag::warn_impcast_constant_value_to_objc_bool)
15634 << PrettySourceValue);
15637 if (
Result == llvm::APFloat::opOK && isExact) {
15638 if (IsLiteral)
return;
15639 return DiagnoseImpCast(S, E, T, CContext, diag::warn_impcast_float_integer,
15645 if (!IsBool &&
Result == llvm::APFloat::opInvalidOp)
15648 IsLiteral ? diag::warn_impcast_literal_float_to_integer_out_of_range
15649 : diag::warn_impcast_float_to_integer_out_of_range,
15652 unsigned DiagID = 0;
15655 DiagID = diag::warn_impcast_literal_float_to_integer;
15656 }
else if (IntegerValue == 0) {
15657 if (
Value.isZero()) {
15659 diag::warn_impcast_float_integer, PruneWarnings);
15662 DiagID = diag::warn_impcast_float_to_integer_zero;
15664 if (IntegerValue.isUnsigned()) {
15665 if (!IntegerValue.isMaxValue()) {
15667 diag::warn_impcast_float_integer, PruneWarnings);
15670 if (!IntegerValue.isMaxSignedValue() &&
15671 !IntegerValue.isMinSignedValue()) {
15673 diag::warn_impcast_float_integer, PruneWarnings);
15677 DiagID = diag::warn_impcast_float_to_integer;
15682 PrettyTargetValue =
Value.isZero() ?
"false" :
"true";
15684 IntegerValue.toString(PrettyTargetValue);
15686 if (PruneWarnings) {
15690 << PrettySourceValue << PrettyTargetValue
15702 assert(isa<CompoundAssignOperator>(E) &&
15703 "Must be compound assignment operation");
15713 const auto *RBT = cast<CompoundAssignOperator>(E)
15714 ->getComputationResultType()
15721 if (ResultBT->isInteger())
15723 E->
getExprLoc(), diag::warn_impcast_float_integer);
15725 if (!ResultBT->isFloatingPoint())
15734 diag::warn_impcast_float_result_precision);
15739 if (!Range.Width)
return "0";
15741 llvm::APSInt ValueInRange =
Value;
15742 ValueInRange.setIsSigned(!Range.NonNegative);
15743 ValueInRange = ValueInRange.trunc(Range.Width);
15744 return toString(ValueInRange, 10);
15748 if (!isa<ImplicitCastExpr>(Ex))
15753 const Type *Source =
15755 if (
Target->isDependentType())
15759 dyn_cast<BuiltinType>(ToBool ? Source :
Target);
15760 const Type *BoolCandidateType = ToBool ?
Target : Source;
15769 for (
unsigned i = 0; i < NumArgs; ++i) {
15774 bool IsSwapped = ((i > 0) &&
15776 IsSwapped |= ((i < (NumArgs - 1)) &&
15782 diag::warn_impcast_floating_point_to_bool);
15789 if (S.
Diags.
isIgnored(diag::warn_impcast_null_pointer_to_integer,
15794 if (isa<CallExpr>(E))
15799 bool IsGNUNullExpr = isa<GNUNullExpr>(NewE);
15801 if (!IsGNUNullExpr && !HasNullPtrType)
15818 if (IsGNUNullExpr && Loc.
isMacroID()) {
15821 if (MacroName ==
"NULL")
15829 S.
Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
15847 unsigned ElementKind) {
15849 if (
auto ICE = dyn_cast<ImplicitCastExpr>(Element)) {
15850 if (ICE->getCastKind() == CK_BitCast &&
15852 Element = ICE->getSubExpr();
15855 QualType ElementType = Element->getType();
15862 S.
Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element)
15863 << ElementType << ElementKind << TargetElementType
15864 << Element->getSourceRange();
15867 if (
auto ArrayLiteral = dyn_cast<ObjCArrayLiteral>(Element))
15869 else if (
auto DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(Element))
15881 if (!TargetObjCPtr)
15884 if (TargetObjCPtr->isUnspecialized() ||
15885 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
15890 if (TypeArgs.size() != 1)
15893 QualType TargetElementType = TypeArgs[0];
15894 for (
unsigned I = 0, N = ArrayLiteral->
getNumElements(); I != N; ++I) {
15910 if (!TargetObjCPtr)
15913 if (TargetObjCPtr->isUnspecialized() ||
15914 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
15919 if (TypeArgs.size() != 2)
15922 QualType TargetKeyType = TypeArgs[0];
15923 QualType TargetObjectType = TypeArgs[1];
15924 for (
unsigned I = 0, N = DictionaryLiteral->
getNumElements(); I != N; ++I) {
15939 const char FirstLiteralCharacter =
15941 if (FirstLiteralCharacter ==
'0')
15948 const char FirstContextCharacter =
15950 if (FirstContextCharacter ==
'{')
15958 const auto *IL = dyn_cast<IntegerLiteral>(E);
15960 if (
auto *UO = dyn_cast<UnaryOperator>(E)) {
15961 if (UO->getOpcode() == UO_Minus)
15962 return dyn_cast<IntegerLiteral>(UO->getSubExpr());
15973 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
15977 if (Opc == BO_Shl) {
15980 if (LHS && LHS->getValue() == 0)
15981 S.
Diag(ExprLoc, diag::warn_left_shift_always) << 0;
15983 RHS->getValue().isNonNegative() &&
15985 S.
Diag(ExprLoc, diag::warn_left_shift_always)
15986 << (
Result.Val.getInt() != 0);
15988 S.
Diag(ExprLoc, diag::warn_left_shift_in_bool_context) << E;
15992 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
15997 if ((LHS->getValue() == 0 || LHS->getValue() == 1) &&
15998 (RHS->getValue() == 0 || RHS->getValue() == 1))
16001 if (LHS->getValue() != 0 && RHS->getValue() != 0)
16002 S.
Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
16008 bool *ICContext =
nullptr,
16009 bool IsListInit =
false) {
16014 if (Source ==
Target)
return;
16015 if (
Target->isDependentType())
return;
16029 if (
Target->isSpecificBuiltinType(BuiltinType::Bool)) {
16030 if (isa<StringLiteral>(E))
16035 diag::warn_impcast_string_literal_to_bool);
16036 if (isa<ObjCStringLiteral>(E) || isa<ObjCArrayLiteral>(E) ||
16037 isa<ObjCDictionaryLiteral>(E) || isa<ObjCBoxedExpr>(E)) {
16041 diag::warn_impcast_objective_c_literal_to_bool);
16057 if (
Result.Val.getInt() != 1 &&
Result.Val.getInt() != 0) {
16060 S.
Diag(CC, diag::warn_impcast_constant_value_to_objc_bool)
16069 if (
auto *ArrayLiteral = dyn_cast<ObjCArrayLiteral>(E))
16071 else if (
auto *DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(E))
16075 if (isa<VectorType>(Source)) {
16076 if (
Target->isSveVLSBuiltinType() &&
16083 if (
Target->isRVVVLSBuiltinType() &&
16090 if (!isa<VectorType>(
Target)) {
16093 return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_vector_scalar);
16099 DiagnoseImpCast(S, E, T, CC, diag::warn_hlsl_impcast_vector_truncation);
16108 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
16109 Target = cast<VectorType>(
Target)->getElementType().getTypePtr();
16111 if (
auto VecTy = dyn_cast<VectorType>(
Target))
16112 Target = VecTy->getElementType().getTypePtr();
16115 if (isa<ComplexType>(Source)) {
16116 if (!isa<ComplexType>(
Target)) {
16122 ? diag::err_impcast_complex_scalar
16123 : diag::warn_impcast_complex_scalar);
16126 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
16127 Target = cast<ComplexType>(
Target)->getElementType().getTypePtr();
16130 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
16182 else if (Order < 0) {
16192 if (TargetBT && TargetBT->
isInteger()) {
16207 if (
Target->isBooleanType() && isa<CallExpr>(E)) {
16211 CallExpr *CEx = cast<CallExpr>(E);
16215 if (isa<ImplicitCastExpr>(LastA) &&
16219 diag::warn_impcast_floating_point_to_bool);
16228 if (
Target->isUnsaturatedFixedPointType()) {
16232 llvm::APFixedPoint
Value =
Result.Val.getFixedPoint();
16237 S.
PDiag(diag::warn_impcast_fixed_point_range)
16238 <<
Value.toString() << T
16244 }
else if (
Target->isIntegerType()) {
16249 llvm::APFixedPoint FXResult =
Result.Val.getFixedPoint();
16252 llvm::APSInt IntResult = FXResult.convertToInt(
16254 Target->isSignedIntegerOrEnumerationType(), &Overflowed);
16258 S.
PDiag(diag::warn_impcast_fixed_point_range)
16259 << FXResult.toString() << T
16266 }
else if (
Target->isUnsaturatedFixedPointType()) {
16274 llvm::APFixedPoint IntResult = llvm::APFixedPoint::getFromIntValue(
16279 S.
PDiag(diag::warn_impcast_fixed_point_range)
16298 unsigned int SourcePrecision =
SourceRange.Width;
16302 unsigned int TargetPrecision = llvm::APFloatBase::semanticsPrecision(
16305 if (SourcePrecision > 0 && TargetPrecision > 0 &&
16306 SourcePrecision > TargetPrecision) {
16308 if (std::optional<llvm::APSInt> SourceInt =
16313 llvm::APFloat TargetFloatValue(
16315 llvm::APFloat::opStatus ConversionStatus =
16316 TargetFloatValue.convertFromAPInt(
16318 llvm::APFloat::rmNearestTiesToEven);
16320 if (ConversionStatus != llvm::APFloat::opOK) {
16322 SourceInt->toString(PrettySourceValue, 10);
16324 TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
16328 S.
PDiag(diag::warn_impcast_integer_float_precision_constant)
16329 << PrettySourceValue << PrettyTargetValue << E->
getType() << T
16335 diag::warn_impcast_integer_float_precision);
16344 if (
Target->isBooleanType())
16352 if (
Target->isSpecificBuiltinType(BuiltinType::Bool))
16359 S.
Diag(CC, diag::warn_impcast_int_to_objc_signed_char_bool)
16363 IntRange SourceTypeRange =
16364 IntRange::forTargetOfCanonicalType(S.
Context, Source);
16367 IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.
Context,
Target);
16369 if (LikelySourceRange.Width > TargetRange.Width) {
16375 llvm::APSInt
Value(32);
16386 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16387 << PrettySourceValue << PrettyTargetValue << E->
getType() << T
16397 return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_integer_64_32,
16399 return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_integer_precision);
16402 if (TargetRange.Width > SourceTypeRange.Width) {
16403 if (
auto *UO = dyn_cast<UnaryOperator>(E))
16404 if (UO->getOpcode() == UO_Minus)
16406 if (
Target->isUnsignedIntegerType())
16408 diag::warn_impcast_high_order_zero_bits);
16409 if (
Target->isSignedIntegerType())
16411 diag::warn_impcast_nonnegative_result);
16415 if (TargetRange.Width == LikelySourceRange.Width &&
16416 !TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16432 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16433 << PrettySourceValue << PrettyTargetValue << E->
getType() << T
16442 if ((!isa<EnumType>(
Target) || !isa<EnumType>(Source)) &&
16443 ((TargetRange.NonNegative && !LikelySourceRange.NonNegative) ||
16444 (!TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16445 LikelySourceRange.Width == TargetRange.Width))) {
16449 if (SourceBT && SourceBT->
isInteger() && TargetBT &&
16455 unsigned DiagID = diag::warn_impcast_integer_sign;
16463 DiagID = diag::warn_impcast_integer_sign_conditional;
16478 if (SourceEnum->getDecl()->hasNameForLinkage() &&
16479 TargetEnum->getDecl()->hasNameForLinkage() &&
16480 SourceEnum != TargetEnum) {
16485 diag::warn_impcast_different_enum_types);
16499 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(E))
16512 if (
auto *BCO = dyn_cast<BinaryConditionalOperator>(E))
16513 TrueExpr = BCO->getCommon();
16515 bool Suspicious =
false;
16524 if (!Suspicious)
return;
16527 if (!S.
Diags.
isIgnored(diag::warn_impcast_integer_sign_conditional, CC))
16532 if (E->
getType() == T)
return;
16534 Suspicious =
false;
16536 E->
getType(), CC, &Suspicious);
16539 E->
getType(), CC, &Suspicious);
16556struct AnalyzeImplicitConversionsWorkItem {
16566 Sema &S, AnalyzeImplicitConversionsWorkItem Item,
16568 Expr *OrigE = Item.E;
16577 bool IsListInit = Item.IsListInit ||
16578 (isa<InitListExpr>(OrigE) && S.
getLangOpts().CPlusPlus);
16583 Expr *SourceExpr = E;
16588 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(E))
16589 if (
auto *Src = OVE->getSourceExpr())
16592 if (
const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
16593 if (UO->getOpcode() == UO_Not &&
16594 UO->getSubExpr()->isKnownToHaveBooleanValue())
16595 S.
Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
16599 if (
const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
16600 if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
16601 BO->getLHS()->isKnownToHaveBooleanValue() &&
16602 BO->getRHS()->isKnownToHaveBooleanValue() &&
16603 BO->getLHS()->HasSideEffects(S.
Context) &&
16604 BO->getRHS()->HasSideEffects(S.
Context)) {
16605 S.
Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical)
16606 << (BO->getOpcode() == BO_And ?
"&" :
"|") << OrigE->
getSourceRange()
16608 BO->getOperatorLoc(),
16609 (BO->getOpcode() == BO_And ?
"&&" :
"||"));
16610 S.
Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
16615 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(SourceExpr)) {
16627 if (SourceExpr->
getType() != T)
16636 for (
auto *SE : POE->semantics())
16637 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(SE))
16638 WorkList.push_back({OVE->getSourceExpr(), CC, IsListInit});
16642 if (
auto *CE = dyn_cast<ExplicitCastExpr>(E)) {
16646 WorkList.push_back({E, CC, IsListInit});
16652 if (BO->isComparisonOp())
16656 if (BO->getOpcode() == BO_Assign)
16659 if (BO->isAssignmentOp())
16667 if (isa<StmtExpr>(E))
return;
16670 if (isa<UnaryExprOrTypeTraitExpr>(E))
return;
16675 bool IsLogicalAndOperator = BO && BO->
getOpcode() == BO_LAnd;
16677 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
16681 if (
auto *CSE = dyn_cast<CoroutineSuspendExpr>(E))
16682 if (ChildExpr == CSE->getOperand())
16688 if (IsLogicalAndOperator &&
16693 WorkList.push_back({ChildExpr, CC, IsListInit});
16698 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16702 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16707 if (
U->getOpcode() == UO_LNot) {
16709 }
else if (
U->getOpcode() != UO_AddrOf) {
16710 if (
U->getSubExpr()->getType()->isAtomicType())
16711 S.
Diag(
U->getSubExpr()->getBeginLoc(),
16712 diag::warn_atomic_implicit_seq_cst);
16723 WorkList.push_back({OrigE, CC, IsListInit});
16724 while (!WorkList.empty())
16734 diag::err_opencl_enqueue_kernel_invalid_local_size_type);
16751 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
16754 }
else if (
const MemberExpr *M = dyn_cast<MemberExpr>(E)) {
16755 if (!M->getMemberDecl()->getType()->isReferenceType())
16757 }
else if (
const CallExpr *
Call = dyn_cast<CallExpr>(E)) {
16758 if (!
Call->getCallReturnType(SemaRef.
Context)->isReferenceType())
16760 FD =
Call->getDirectCallee();
16769 SemaRef.
Diag(FD->
getLocation(), diag::note_reference_is_return_value) << FD;
16783 if (
SM.isMacroBodyExpansion(Loc))
16785 Loc =
SM.getImmediateMacroCallerLoc(Loc);
16814 if (isa<CXXThisExpr>(E)) {
16815 unsigned DiagID = IsCompare ? diag::warn_this_null_compare
16816 : diag::warn_this_bool_conversion;
16821 bool IsAddressOf =
false;
16823 if (
auto *UO = dyn_cast<UnaryOperator>(E->
IgnoreParens())) {
16824 if (UO->getOpcode() != UO_AddrOf)
16826 IsAddressOf =
true;
16827 E = UO->getSubExpr();
16831 unsigned DiagID = IsCompare
16832 ? diag::warn_address_of_reference_null_compare
16833 : diag::warn_address_of_reference_bool_conversion;
16841 auto ComplainAboutNonnullParamOrCall = [&](
const Attr *NonnullAttr) {
16842 bool IsParam = isa<NonNullAttr>(NonnullAttr);
16844 llvm::raw_string_ostream S(Str);
16846 unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare
16847 : diag::warn_cast_nonnull_to_bool;
16850 Diag(NonnullAttr->getLocation(), diag::note_declared_nonnull) << IsParam;
16855 if (
auto *Callee =
Call->getDirectCallee()) {
16856 if (
const Attr *A = Callee->getAttr<ReturnsNonNullAttr>()) {
16857 ComplainAboutNonnullParamOrCall(A);
16866 if (
const auto *MCallExpr = dyn_cast<CXXMemberCallExpr>(E)) {
16867 if (
const auto *MRecordDecl = MCallExpr->getRecordDecl();
16868 MRecordDecl && MRecordDecl->isLambda()) {
16871 << MRecordDecl->getSourceRange() << Range << IsEqual;
16881 }
else if (
MemberExpr *M = dyn_cast<MemberExpr>(E)) {
16882 D = M->getMemberDecl();
16890 if (
const auto* PV = dyn_cast<ParmVarDecl>(D)) {
16893 if (
const Attr *A = PV->getAttr<NonNullAttr>()) {
16894 ComplainAboutNonnullParamOrCall(A);
16898 if (
const auto *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
16902 auto ParamIter = llvm::find(FD->
parameters(), PV);
16904 unsigned ParamNo = std::distance(FD->
param_begin(), ParamIter);
16908 ComplainAboutNonnullParamOrCall(
NonNull);
16913 if (ArgNo.getASTIndex() == ParamNo) {
16914 ComplainAboutNonnullParamOrCall(
NonNull);
16928 if (IsAddressOf && IsFunction) {
16933 if (!IsAddressOf && !IsFunction && !IsArray)
16938 llvm::raw_string_ostream S(Str);
16941 unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare
16942 : diag::warn_impcast_pointer_to_bool;
16949 DiagType = AddressOf;
16950 else if (IsFunction)
16951 DiagType = FunctionPointer;
16953 DiagType = ArrayPointer;
16955 llvm_unreachable(
"Could not determine diagnostic.");
16957 << Range << IsEqual;
16970 if (ReturnType.
isNull())
17015 CheckArrayAccess(E);
17024 ::CheckBoolLikeConversion(*
this, E, CC);
17029void Sema::CheckForIntOverflow (
const Expr *E) {
17034 const Expr *OriginalE = Exprs.pop_back_val();
17037 if (isa<BinaryOperator, UnaryOperator>(E)) {
17042 if (
const auto *InitList = dyn_cast<InitListExpr>(OriginalE))
17043 Exprs.append(InitList->inits().begin(), InitList->inits().end());
17044 else if (isa<ObjCBoxedExpr>(OriginalE))
17046 else if (
const auto *
Call = dyn_cast<CallExpr>(E))
17047 Exprs.append(
Call->arg_begin(),
Call->arg_end());
17048 else if (
const auto *Message = dyn_cast<ObjCMessageExpr>(E))
17049 Exprs.append(Message->arg_begin(), Message->arg_end());
17050 else if (
const auto *Construct = dyn_cast<CXXConstructExpr>(E))
17051 Exprs.append(Construct->arg_begin(), Construct->arg_end());
17052 else if (
const auto *Temporary = dyn_cast<CXXBindTemporaryExpr>(E))
17053 Exprs.push_back(Temporary->getSubExpr());
17054 else if (
const auto *Array = dyn_cast<ArraySubscriptExpr>(E))
17055 Exprs.push_back(Array->getIdx());
17056 else if (
const auto *Compound = dyn_cast<CompoundLiteralExpr>(E))
17057 Exprs.push_back(Compound->getInitializer());
17058 else if (
const auto *New = dyn_cast<CXXNewExpr>(E);
17059 New && New->isArray()) {
17060 if (
auto ArraySize = New->getArraySize())
17061 Exprs.push_back(*ArraySize);
17063 }
while (!Exprs.empty());
17078 class SequenceTree {
17082 LLVM_PREFERRED_TYPE(
bool)
17083 unsigned Merged : 1;
17091 friend class SequenceTree;
17095 explicit Seq(
unsigned N) : Index(N) {}
17098 Seq() : Index(0) {}
17101 SequenceTree() { Values.push_back(
Value(0)); }
17102 Seq root()
const {
return Seq(0); }
17109 return Seq(Values.size() - 1);
17113 void merge(
Seq S) {
17114 Values[S.Index].Merged =
true;
17120 bool isUnsequenced(
Seq Cur,
Seq Old) {
17121 unsigned C = representative(Cur.Index);
17122 unsigned Target = representative(Old.Index);
17126 C = Values[
C].Parent;
17133 unsigned representative(
unsigned K) {
17134 if (Values[K].Merged)
17136 return Values[K].Parent = representative(Values[K].
Parent);
17156 UK_ModAsSideEffect,
17158 UK_Count = UK_ModAsSideEffect + 1
17164 const Expr *UsageExpr =
nullptr;
17165 SequenceTree::Seq
Seq;
17171 Usage Uses[UK_Count];
17174 bool Diagnosed =
false;
17178 using UsageInfoMap = llvm::SmallDenseMap<Object, UsageInfo, 16>;
17186 UsageInfoMap UsageMap;
17189 SequenceTree::Seq Region;
17204 struct SequencedSubexpression {
17205 SequencedSubexpression(SequenceChecker &
Self)
17206 :
Self(
Self), OldModAsSideEffect(
Self.ModAsSideEffect) {
17207 Self.ModAsSideEffect = &ModAsSideEffect;
17210 ~SequencedSubexpression() {
17211 for (
const std::pair<Object, Usage> &M : llvm::reverse(ModAsSideEffect)) {
17215 UsageInfo &UI =
Self.UsageMap[M.first];
17216 auto &SideEffectUsage = UI.Uses[UK_ModAsSideEffect];
17217 Self.addUsage(M.first, UI, SideEffectUsage.UsageExpr, UK_ModAsValue);
17218 SideEffectUsage = M.second;
17220 Self.ModAsSideEffect = OldModAsSideEffect;
17223 SequenceChecker &
Self;
17232 class EvaluationTracker {
17234 EvaluationTracker(SequenceChecker &
Self)
17236 Self.EvalTracker =
this;
17239 ~EvaluationTracker() {
17240 Self.EvalTracker = Prev;
17242 Prev->EvalOK &= EvalOK;
17245 bool evaluate(
const Expr *E,
bool &Result) {
17249 Result,
Self.SemaRef.Context,
17250 Self.SemaRef.isConstantEvaluatedContext());
17255 SequenceChecker &
Self;
17256 EvaluationTracker *Prev;
17257 bool EvalOK =
true;
17258 } *EvalTracker =
nullptr;
17262 Object getObject(
const Expr *E,
bool Mod)
const {
17264 if (
const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
17265 if (Mod && (UO->getOpcode() == UO_PreInc || UO->getOpcode() == UO_PreDec))
17266 return getObject(UO->getSubExpr(), Mod);
17267 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
17268 if (BO->getOpcode() == BO_Comma)
17269 return getObject(BO->getRHS(), Mod);
17270 if (Mod && BO->isAssignmentOp())
17271 return getObject(BO->getLHS(), Mod);
17272 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
17274 if (isa<CXXThisExpr>(ME->getBase()->IgnoreParenCasts()))
17275 return ME->getMemberDecl();
17276 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
17285 void addUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr, UsageKind UK) {
17287 Usage &
U = UI.Uses[UK];
17288 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq)) {
17292 if (UK == UK_ModAsSideEffect && ModAsSideEffect)
17293 ModAsSideEffect->push_back(std::make_pair(O,
U));
17295 U.UsageExpr = UsageExpr;
17305 void checkUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr,
17306 UsageKind OtherKind,
bool IsModMod) {
17310 const Usage &
U = UI.Uses[OtherKind];
17311 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq))
17314 const Expr *Mod =
U.UsageExpr;
17315 const Expr *ModOrUse = UsageExpr;
17316 if (OtherKind == UK_Use)
17317 std::swap(Mod, ModOrUse);
17321 SemaRef.
PDiag(IsModMod ? diag::warn_unsequenced_mod_mod
17322 : diag::warn_unsequenced_mod_use)
17324 UI.Diagnosed =
true;
17353 void notePreUse(Object O,
const Expr *UseExpr) {
17354 UsageInfo &UI = UsageMap[O];
17356 checkUsage(O, UI, UseExpr, UK_ModAsValue,
false);
17359 void notePostUse(Object O,
const Expr *UseExpr) {
17360 UsageInfo &UI = UsageMap[O];
17361 checkUsage(O, UI, UseExpr, UK_ModAsSideEffect,
17363 addUsage(O, UI, UseExpr, UK_Use);
17366 void notePreMod(Object O,
const Expr *ModExpr) {
17367 UsageInfo &UI = UsageMap[O];
17369 checkUsage(O, UI, ModExpr, UK_ModAsValue,
true);
17370 checkUsage(O, UI, ModExpr, UK_Use,
false);
17373 void notePostMod(Object O,
const Expr *ModExpr, UsageKind UK) {
17374 UsageInfo &UI = UsageMap[O];
17375 checkUsage(O, UI, ModExpr, UK_ModAsSideEffect,
17377 addUsage(O, UI, ModExpr, UK);
17381 SequenceChecker(
Sema &S,
const Expr *E,
17383 :
Base(S.Context), SemaRef(S), Region(
Tree.root()), WorkList(WorkList) {
17387 (void)this->WorkList;
17390 void VisitStmt(
const Stmt *S) {
17394 void VisitExpr(
const Expr *E) {
17396 Base::VisitStmt(E);
17400 for (
auto *Sub : CSE->
children()) {
17401 const Expr *ChildExpr = dyn_cast_or_null<Expr>(Sub);
17416 void VisitCastExpr(
const CastExpr *E) {
17428 void VisitSequencedExpressions(
const Expr *SequencedBefore,
17429 const Expr *SequencedAfter) {
17430 SequenceTree::Seq BeforeRegion =
Tree.allocate(Region);
17431 SequenceTree::Seq AfterRegion =
Tree.allocate(Region);
17432 SequenceTree::Seq OldRegion = Region;
17435 SequencedSubexpression SeqBefore(*
this);
17436 Region = BeforeRegion;
17437 Visit(SequencedBefore);
17440 Region = AfterRegion;
17441 Visit(SequencedAfter);
17443 Region = OldRegion;
17445 Tree.merge(BeforeRegion);
17446 Tree.merge(AfterRegion);
17454 VisitSequencedExpressions(ASE->
getLHS(), ASE->
getRHS());
17461 void VisitBinPtrMemD(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17462 void VisitBinPtrMemI(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17468 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17475 void VisitBinShl(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17476 void VisitBinShr(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17481 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17493 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17497 SequenceTree::Seq RHSRegion;
17498 SequenceTree::Seq LHSRegion;
17500 RHSRegion =
Tree.allocate(Region);
17501 LHSRegion =
Tree.allocate(Region);
17503 RHSRegion = Region;
17504 LHSRegion = Region;
17506 SequenceTree::Seq OldRegion = Region;
17522 SequencedSubexpression SeqBefore(*
this);
17523 Region = RHSRegion;
17527 Region = LHSRegion;
17530 if (O && isa<CompoundAssignOperator>(BO))
17531 notePostUse(O, BO);
17535 Region = LHSRegion;
17538 if (O && isa<CompoundAssignOperator>(BO))
17539 notePostUse(O, BO);
17541 Region = RHSRegion;
17549 Region = OldRegion;
17553 : UK_ModAsSideEffect);
17555 Tree.merge(RHSRegion);
17556 Tree.merge(LHSRegion);
17561 VisitBinAssign(CAO);
17564 void VisitUnaryPreInc(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17565 void VisitUnaryPreDec(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17569 return VisitExpr(UO);
17577 : UK_ModAsSideEffect);
17580 void VisitUnaryPostInc(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17581 void VisitUnaryPostDec(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17585 return VisitExpr(UO);
17589 notePostMod(O, UO, UK_ModAsSideEffect);
17598 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17599 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17600 SequenceTree::Seq OldRegion = Region;
17602 EvaluationTracker Eval(*
this);
17604 SequencedSubexpression Sequenced(*
this);
17605 Region = LHSRegion;
17612 bool EvalResult =
false;
17613 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17614 bool ShouldVisitRHS = !EvalOK || !EvalResult;
17615 if (ShouldVisitRHS) {
17616 Region = RHSRegion;
17620 Region = OldRegion;
17621 Tree.merge(LHSRegion);
17622 Tree.merge(RHSRegion);
17631 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17632 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17633 SequenceTree::Seq OldRegion = Region;
17635 EvaluationTracker Eval(*
this);
17637 SequencedSubexpression Sequenced(*
this);
17638 Region = LHSRegion;
17644 bool EvalResult =
false;
17645 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17646 bool ShouldVisitRHS = !EvalOK || EvalResult;
17647 if (ShouldVisitRHS) {
17648 Region = RHSRegion;
17652 Region = OldRegion;
17653 Tree.merge(LHSRegion);
17654 Tree.merge(RHSRegion);
17662 SequenceTree::Seq ConditionRegion =
Tree.allocate(Region);
17678 SequenceTree::Seq TrueRegion =
Tree.allocate(Region);
17679 SequenceTree::Seq FalseRegion =
Tree.allocate(Region);
17680 SequenceTree::Seq OldRegion = Region;
17682 EvaluationTracker Eval(*
this);
17684 SequencedSubexpression Sequenced(*
this);
17685 Region = ConditionRegion;
17695 bool EvalResult =
false;
17696 bool EvalOK = Eval.evaluate(CO->
getCond(), EvalResult);
17697 bool ShouldVisitTrueExpr = !EvalOK || EvalResult;
17698 bool ShouldVisitFalseExpr = !EvalOK || !EvalResult;
17699 if (ShouldVisitTrueExpr) {
17700 Region = TrueRegion;
17703 if (ShouldVisitFalseExpr) {
17704 Region = FalseRegion;
17708 Region = OldRegion;
17709 Tree.merge(ConditionRegion);
17710 Tree.merge(TrueRegion);
17711 Tree.merge(FalseRegion);
17714 void VisitCallExpr(
const CallExpr *CE) {
17726 SequencedSubexpression Sequenced(*
this);
17731 SequenceTree::Seq CalleeRegion;
17732 SequenceTree::Seq OtherRegion;
17733 if (SemaRef.getLangOpts().CPlusPlus17) {
17734 CalleeRegion = Tree.allocate(Region);
17735 OtherRegion = Tree.allocate(Region);
17737 CalleeRegion = Region;
17738 OtherRegion = Region;
17740 SequenceTree::Seq OldRegion = Region;
17743 Region = CalleeRegion;
17745 SequencedSubexpression Sequenced(*this);
17746 Visit(CE->getCallee());
17748 Visit(CE->getCallee());
17752 Region = OtherRegion;
17756 Region = OldRegion;
17758 Tree.merge(CalleeRegion);
17759 Tree.merge(OtherRegion);
17777 return VisitCallExpr(CXXOCE);
17788 case OO_MinusEqual:
17790 case OO_SlashEqual:
17791 case OO_PercentEqual:
17792 case OO_CaretEqual:
17795 case OO_LessLessEqual:
17796 case OO_GreaterGreaterEqual:
17797 SequencingKind = RHSBeforeLHS;
17801 case OO_GreaterGreater:
17807 SequencingKind = LHSBeforeRHS;
17811 SequencingKind = LHSBeforeRest;
17815 SequencingKind = NoSequencing;
17819 if (SequencingKind == NoSequencing)
17820 return VisitCallExpr(CXXOCE);
17823 SequencedSubexpression Sequenced(*
this);
17826 assert(SemaRef.getLangOpts().CPlusPlus17 &&
17827 "Should only get there with C++17 and above!");
17828 assert((CXXOCE->getNumArgs() == 2 || CXXOCE->getOperator() == OO_Call) &&
17829 "Should only get there with an overloaded binary operator"
17830 " or an overloaded call operator!");
17832 if (SequencingKind == LHSBeforeRest) {
17833 assert(CXXOCE->getOperator() == OO_Call &&
17834 "We should only have an overloaded call operator here!");
17843 SequenceTree::Seq PostfixExprRegion = Tree.allocate(Region);
17844 SequenceTree::Seq ArgsRegion = Tree.allocate(Region);
17845 SequenceTree::Seq OldRegion = Region;
17847 assert(CXXOCE->getNumArgs() >= 1 &&
17848 "An overloaded call operator must have at least one argument"
17849 " for the postfix-expression!");
17850 const Expr *PostfixExpr = CXXOCE->getArgs()[0];
17851 llvm::ArrayRef<const Expr *> Args(CXXOCE->getArgs() + 1,
17852 CXXOCE->getNumArgs() - 1);
17856 Region = PostfixExprRegion;
17857 SequencedSubexpression Sequenced(*this);
17858 Visit(PostfixExpr);
17862 Region = ArgsRegion;
17863 for (const Expr *Arg : Args)
17866 Region = OldRegion;
17867 Tree.merge(PostfixExprRegion);
17868 Tree.merge(ArgsRegion);
17870 assert(CXXOCE->getNumArgs() == 2 &&
17871 "Should only have two arguments here!");
17872 assert((SequencingKind == LHSBeforeRHS ||
17873 SequencingKind == RHSBeforeLHS) &&
17874 "Unexpected sequencing kind!");
17878 const Expr *E1 = CXXOCE->getArg(0);
17879 const Expr *E2 = CXXOCE->getArg(1);
17880 if (SequencingKind == RHSBeforeLHS)
17883 return VisitSequencedExpressions(E1, E2);
17890 SequencedSubexpression Sequenced(*
this);
17893 return VisitExpr(CCE);
17896 SequenceExpressionsInOrder(
17902 return VisitExpr(ILE);
17905 SequenceExpressionsInOrder(ILE->
inits());
17917 SequenceTree::Seq
Parent = Region;
17918 for (
const Expr *E : ExpressionList) {
17922 Elts.push_back(Region);
17928 for (
unsigned I = 0; I < Elts.size(); ++I)
17929 Tree.merge(Elts[I]);
17933SequenceChecker::UsageInfo::UsageInfo() =
default;
17937void Sema::CheckUnsequencedOperations(
const Expr *E) {
17939 WorkList.push_back(E);
17940 while (!WorkList.empty()) {
17941 const Expr *Item = WorkList.pop_back_val();
17942 SequenceChecker(*
this, Item, WorkList);
17947 bool IsConstexpr) {
17949 IsConstexpr || isa<ConstantExpr>(E));
17950 CheckImplicitConversions(E, CheckLoc);
17952 CheckUnsequencedOperations(E);
17954 CheckForIntOverflow(E);
17968 if (
const auto *PointerTy = dyn_cast<PointerType>(PType)) {
17972 if (
const auto *ReferenceTy = dyn_cast<ReferenceType>(PType)) {
17976 if (
const auto *ParenTy = dyn_cast<ParenType>(PType)) {
17990 S.
Diag(Loc, diag::err_array_star_in_function_definition);
17999 bool CheckParameterNames) {
18000 bool HasInvalidParm =
false;
18002 assert(Param &&
"null in a parameter list");
18011 if (!Param->isInvalidDecl() &&
18013 diag::err_typecheck_decl_incomplete_type) ||
18015 diag::err_abstract_type_in_decl,
18017 Param->setInvalidDecl();
18018 HasInvalidParm =
true;
18023 if (CheckParameterNames && Param->getIdentifier() ==
nullptr &&
18027 Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c23);
18035 QualType PType = Param->getOriginalType();
18043 if (!Param->isInvalidDecl()) {
18045 if (!ClassDecl->isInvalidDecl() &&
18046 !ClassDecl->hasIrrelevantDestructor() &&
18047 !ClassDecl->isDependentContext() &&
18048 ClassDecl->isParamDestroyedInCallee()) {
18060 if (
const auto *
Attr = Param->getAttr<PassObjectSizeAttr>())
18061 if (!Param->getType().isConstQualified())
18062 Diag(Param->getLocation(), diag::err_attribute_pointers_only)
18066 if (
LangOpts.CPlusPlus && !Param->isInvalidDecl()) {
18071 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC->
getParent()))
18072 CheckShadowInheritedFields(Param->getLocation(), Param->getDeclName(),
18077 if (!Param->isInvalidDecl() &&
18079 Param->setInvalidDecl();
18080 HasInvalidParm =
true;
18081 Diag(Param->getLocation(), diag::err_wasm_table_as_function_parameter);
18085 return HasInvalidParm;
18088std::optional<std::pair<
18097static std::pair<CharUnits, CharUnits>
18105 if (
Base->isVirtual()) {
18112 BaseAlignment = std::min(BaseAlignment, NonVirtualAlignment);
18119 DerivedType =
Base->getType();
18122 return std::make_pair(BaseAlignment, Offset);
18126static std::optional<std::pair<CharUnits, CharUnits>>
18132 return std::nullopt;
18137 return std::nullopt;
18141 CharUnits Offset = EltSize * IdxRes->getExtValue();
18144 return std::make_pair(
P->first,
P->second + Offset);
18150 return std::make_pair(
18151 P->first.alignmentAtOffset(
P->second).alignmentAtOffset(EltSize),
18157std::optional<std::pair<
18165 case Stmt::CStyleCastExprClass:
18166 case Stmt::CXXStaticCastExprClass:
18167 case Stmt::ImplicitCastExprClass: {
18168 auto *CE = cast<CastExpr>(E);
18169 const Expr *From = CE->getSubExpr();
18170 switch (CE->getCastKind()) {
18175 case CK_UncheckedDerivedToBase:
18176 case CK_DerivedToBase: {
18186 case Stmt::ArraySubscriptExprClass: {
18187 auto *ASE = cast<ArraySubscriptExpr>(E);
18191 case Stmt::DeclRefExprClass: {
18192 if (
auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
18195 if (!VD->getType()->isReferenceType()) {
18197 if (VD->hasDependentAlignment())
18206 case Stmt::MemberExprClass: {
18207 auto *ME = cast<MemberExpr>(E);
18208 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
18212 std::optional<std::pair<CharUnits, CharUnits>>
P;
18221 return std::make_pair(
P->first,
18224 case Stmt::UnaryOperatorClass: {
18225 auto *UO = cast<UnaryOperator>(E);
18234 case Stmt::BinaryOperatorClass: {
18235 auto *BO = cast<BinaryOperator>(E);
18246 return std::nullopt;
18251std::optional<std::pair<
18260 case Stmt::CStyleCastExprClass:
18261 case Stmt::CXXStaticCastExprClass:
18262 case Stmt::ImplicitCastExprClass: {
18263 auto *CE = cast<CastExpr>(E);
18264 const Expr *From = CE->getSubExpr();
18265 switch (CE->getCastKind()) {
18270 case CK_ArrayToPointerDecay:
18272 case CK_UncheckedDerivedToBase:
18273 case CK_DerivedToBase: {
18283 case Stmt::CXXThisExprClass: {
18288 case Stmt::UnaryOperatorClass: {
18289 auto *UO = cast<UnaryOperator>(E);
18294 case Stmt::BinaryOperatorClass: {
18295 auto *BO = cast<BinaryOperator>(E);
18303 if (Opcode == BO_Add && !RHS->getType()->isIntegralOrEnumerationType())
18304 std::swap(LHS, RHS);
18314 return std::nullopt;
18319 std::optional<std::pair<CharUnits, CharUnits>>
P =
18323 return P->first.alignmentAtOffset(
P->second);
18343 if (!DestPtr)
return;
18349 if (DestAlign.
isOne())
return;
18353 if (!SrcPtr)
return;
18364 if (SrcAlign >= DestAlign)
return;
18369 <<
static_cast<unsigned>(DestAlign.
getQuantity())
18373void Sema::CheckArrayAccess(
const Expr *BaseExpr,
const Expr *IndexExpr,
18375 bool AllowOnePastEnd,
bool IndexNegated) {
18384 const Type *EffectiveType =
18391 StrictFlexArraysLevel =
getLangOpts().getStrictFlexArraysLevel();
18393 const Type *BaseType =
18395 bool IsUnboundedArray =
18397 Context, StrictFlexArraysLevel,
18407 llvm::APSInt index =
Result.Val.getInt();
18408 if (IndexNegated) {
18409 index.setIsUnsigned(
false);
18413 if (IsUnboundedArray) {
18416 if (index.isUnsigned() || !index.isNegative()) {
18418 unsigned AddrBits = ASTC.getTargetInfo().getPointerWidth(
18420 if (index.getBitWidth() < AddrBits)
18421 index = index.zext(AddrBits);
18422 std::optional<CharUnits> ElemCharUnits =
18423 ASTC.getTypeSizeInCharsIfKnown(EffectiveType);
18426 if (!ElemCharUnits || ElemCharUnits->isZero())
18428 llvm::APInt ElemBytes(index.getBitWidth(), ElemCharUnits->getQuantity());
18433 if (index.getActiveBits() <= AddrBits) {
18435 llvm::APInt Product(index);
18437 Product = Product.umul_ov(ElemBytes, Overflow);
18438 if (!Overflow && Product.getActiveBits() <= AddrBits)
18444 llvm::APInt MaxElems = llvm::APInt::getMaxValue(AddrBits);
18445 MaxElems = MaxElems.zext(std::max(AddrBits + 1, ElemBytes.getBitWidth()));
18447 ElemBytes = ElemBytes.zextOrTrunc(MaxElems.getBitWidth());
18448 MaxElems = MaxElems.udiv(ElemBytes);
18451 ASE ? diag::warn_array_index_exceeds_max_addressable_bounds
18452 : diag::warn_ptr_arith_exceeds_max_addressable_bounds;
18458 <<
toString(index, 10,
true) << AddrBits
18459 << (
unsigned)ASTC.toBits(*ElemCharUnits)
18462 << (
unsigned)MaxElems.getLimitedValue(~0
U)
18467 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18469 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18471 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18472 ND = ME->getMemberDecl();
18476 PDiag(diag::note_array_declared_here) << ND);
18481 if (index.isUnsigned() || !index.isNegative()) {
18491 llvm::APInt size = ArrayTy->
getSize();
18493 if (BaseType != EffectiveType) {
18501 if (!ptrarith_typesize)
18504 if (ptrarith_typesize != array_typesize) {
18506 uint64_t ratio = array_typesize / ptrarith_typesize;
18510 if (ptrarith_typesize * ratio == array_typesize)
18511 size *= llvm::APInt(size.getBitWidth(), ratio);
18515 if (size.getBitWidth() > index.getBitWidth())
18516 index = index.zext(size.getBitWidth());
18517 else if (size.getBitWidth() < index.getBitWidth())
18518 size = size.zext(index.getBitWidth());
18524 if (AllowOnePastEnd ? index.ule(size) : index.ult(size))
18541 unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds
18542 : diag::warn_ptr_arith_exceeds_bounds;
18543 unsigned CastMsg = (!ASE || BaseType == EffectiveType) ? 0 : 1;
18551 unsigned DiagID = diag::warn_array_index_precedes_bounds;
18553 DiagID = diag::warn_ptr_arith_precedes_bounds;
18554 if (index.isNegative()) index = -index;
18564 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18566 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18568 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18569 ND = ME->getMemberDecl();
18573 PDiag(diag::note_array_declared_here) << ND);
18576void Sema::CheckArrayAccess(
const Expr *
expr) {
18577 int AllowOnePastEnd = 0;
18579 expr =
expr->IgnoreParenImpCasts();
18580 switch (
expr->getStmtClass()) {
18581 case Stmt::ArraySubscriptExprClass: {
18584 AllowOnePastEnd > 0);
18588 case Stmt::MemberExprClass: {
18589 expr = cast<MemberExpr>(
expr)->getBase();
18592 case Stmt::OMPArraySectionExprClass: {
18596 nullptr, AllowOnePastEnd > 0);
18599 case Stmt::UnaryOperatorClass: {
18615 case Stmt::ConditionalOperatorClass: {
18618 CheckArrayAccess(lhs);
18620 CheckArrayAccess(rhs);
18623 case Stmt::CXXOperatorCallExprClass: {
18624 const auto *OCE = cast<CXXOperatorCallExpr>(
expr);
18625 for (
const auto *Arg : OCE->arguments())
18626 CheckArrayAccess(Arg);
18639struct RetainCycleOwner {
18643 bool Indirect =
false;
18645 RetainCycleOwner() =
default;
18647 void setLocsFrom(
Expr *e) {
18664 owner.Variable = var;
18666 owner.setLocsFrom(ref);
18674 switch (
cast->getCastKind()) {
18676 case CK_LValueBitCast:
18677 case CK_LValueToRValue:
18678 case CK_ARCReclaimReturnedObject:
18679 e =
cast->getSubExpr();
18696 if (ref->isFreeIvar()) owner.setLocsFrom(ref);
18697 owner.Indirect =
true;
18701 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) {
18702 VarDecl *var = dyn_cast<VarDecl>(ref->getDecl());
18703 if (!var)
return false;
18707 if (
MemberExpr *member = dyn_cast<MemberExpr>(e)) {
18708 if (member->isArrow())
return false;
18711 e = member->getBase();
18718 = dyn_cast<ObjCPropertyRefExpr>(pseudo->getSyntacticForm()
18720 if (!pre)
return false;
18723 if (!property->isRetaining() &&
18724 !(property->getPropertyIvarDecl() &&
18725 property->getPropertyIvarDecl()->getType()
18729 owner.Indirect =
true;
18732 if (!owner.Variable)
18738 e =
const_cast<Expr*
>(cast<OpaqueValueExpr>(pre->
getBase())
18739 ->getSourceExpr());
18753 Expr *Capturer =
nullptr;
18754 bool VarWillBeReased =
false;
18761 if (ref->
getDecl() == Variable && !Capturer)
18766 if (Capturer)
return;
18772 void VisitBlockExpr(
BlockExpr *block) {
18779 if (Capturer)
return;
18785 if (!Variable || VarWillBeReased || BinOp->
getOpcode() != BO_Assign)
18788 if (
const DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(LHS)) {
18789 if (DRE->
getDecl() != Variable)
18793 std::optional<llvm::APSInt>
Value;
18795 (RHS && (
Value = RHS->getIntegerConstantExpr(Context)) &&
18807 assert(owner.Variable && owner.Loc.isValid());
18814 if (
Cmd.isUnarySelector() &&
Cmd.getNameForSlot(0) ==
"copy") {
18815 e = ME->getInstanceReceiver();
18820 }
else if (
CallExpr *CE = dyn_cast<CallExpr>(e)) {
18825 if (FnI && FnI->
isStr(
"_Block_copy")) {
18832 BlockExpr *block = dyn_cast<BlockExpr>(e);
18836 FindCaptureVisitor visitor(S.
Context, owner.Variable);
18838 return visitor.VarWillBeReased ? nullptr : visitor.Capturer;
18842 RetainCycleOwner &owner) {
18844 assert(owner.Variable && owner.Loc.isValid());
18848 S.
Diag(owner.Loc, diag::note_arc_retain_cycle_owner)
18849 << owner.Indirect << owner.Range;
18858 str = str.ltrim(
'_');
18859 if (str.starts_with(
"set"))
18860 str = str.substr(3);
18861 else if (str.starts_with(
"add")) {
18863 if (sel.
getNumArgs() == 1 && str.starts_with(
"addOperationWithBlock"))
18865 str = str.substr(3);
18869 if (str.empty())
return true;
18873static std::optional<int>
18875 bool IsMutableArray = S.
NSAPIObj->isSubclassOfNSClass(
18876 Message->getReceiverInterface(),
18878 if (!IsMutableArray) {
18879 return std::nullopt;
18882 Selector Sel = Message->getSelector();
18884 std::optional<NSAPI::NSArrayMethodKind> MKOpt =
18885 S.
NSAPIObj->getNSArrayMethodKind(Sel);
18887 return std::nullopt;
18901 return std::nullopt;
18904 return std::nullopt;
18907static std::optional<int>
18909 bool IsMutableDictionary = S.
NSAPIObj->isSubclassOfNSClass(
18910 Message->getReceiverInterface(),
18912 if (!IsMutableDictionary) {
18913 return std::nullopt;
18916 Selector Sel = Message->getSelector();
18918 std::optional<NSAPI::NSDictionaryMethodKind> MKOpt =
18919 S.
NSAPIObj->getNSDictionaryMethodKind(Sel);
18921 return std::nullopt;
18933 return std::nullopt;
18936 return std::nullopt;
18941 bool IsMutableSet = S.
NSAPIObj->isSubclassOfNSClass(
18942 Message->getReceiverInterface(),
18945 bool IsMutableOrderedSet = S.
NSAPIObj->isSubclassOfNSClass(
18946 Message->getReceiverInterface(),
18948 if (!IsMutableSet && !IsMutableOrderedSet) {
18949 return std::nullopt;
18952 Selector Sel = Message->getSelector();
18954 std::optional<NSAPI::NSSetMethodKind> MKOpt =
18955 S.
NSAPIObj->getNSSetMethodKind(Sel);
18957 return std::nullopt;
18972 return std::nullopt;
18976 if (!Message->isInstanceMessage()) {
18980 std::optional<int> ArgOpt;
18988 int ArgIndex = *ArgOpt;
18990 Expr *Arg = Message->getArg(ArgIndex)->IgnoreImpCasts();
18996 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
18997 if (ArgRE->isObjCSelfExpr()) {
18998 Diag(Message->getSourceRange().getBegin(),
18999 diag::warn_objc_circular_container)
19000 << ArgRE->getDecl() << StringRef(
"'super'");
19004 Expr *Receiver = Message->getInstanceReceiver()->IgnoreImpCasts();
19010 if (
DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {
19011 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19012 if (ReceiverRE->getDecl() == ArgRE->getDecl()) {
19014 Diag(Message->getSourceRange().getBegin(),
19015 diag::warn_objc_circular_container)
19017 if (!ArgRE->isObjCSelfExpr()) {
19019 diag::note_objc_circular_container_declared_here)
19024 }
else if (
ObjCIvarRefExpr *IvarRE = dyn_cast<ObjCIvarRefExpr>(Receiver)) {
19026 if (IvarRE->getDecl() == IvarArgRE->getDecl()) {
19028 Diag(Message->getSourceRange().getBegin(),
19029 diag::warn_objc_circular_container)
19032 diag::note_objc_circular_container_declared_here)
19047 RetainCycleOwner owner;
19060 for (
unsigned i = 0, e = msg->
getNumArgs(); i != e; ++i) {
19063 if (MD && MD->
parameters()[i]->hasAttr<NoEscapeAttr>())
19072 RetainCycleOwner owner;
19081 RetainCycleOwner Owner;
19095 Expr *RHS,
bool isProperty) {
19107 S.
Diag(Loc, diag::warn_arc_literal_assign)
19109 << (isProperty ? 0 : 1)
19117 Expr *RHS,
bool isProperty) {
19120 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19121 S.
Diag(Loc, diag::warn_arc_retained_assign)
19123 << (isProperty ? 0 : 1)
19127 RHS =
cast->getSubExpr();
19198 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19199 Diag(Loc, diag::warn_arc_retained_property_assign)
19203 RHS =
cast->getSubExpr();
19226 bool StmtLineInvalid;
19229 if (StmtLineInvalid)
19232 bool BodyLineInvalid;
19235 if (BodyLineInvalid)
19239 if (StmtLine != BodyLine)
19254 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19263 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19267 const Stmt *PossibleBody) {
19273 if (
const ForStmt *FS = dyn_cast<ForStmt>(S)) {
19274 StmtLoc = FS->getRParenLoc();
19275 Body = FS->getBody();
19276 DiagID = diag::warn_empty_for_body;
19277 }
else if (
const WhileStmt *WS = dyn_cast<WhileStmt>(S)) {
19278 StmtLoc = WS->getRParenLoc();
19279 Body = WS->getBody();
19280 DiagID = diag::warn_empty_while_body;
19285 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19308 bool ProbableTypo = isa<CompoundStmt>(PossibleBody);
19309 if (!ProbableTypo) {
19310 bool BodyColInvalid;
19313 if (BodyColInvalid)
19316 bool StmtColInvalid;
19319 if (StmtColInvalid)
19322 if (BodyCol > StmtCol)
19323 ProbableTypo =
true;
19326 if (ProbableTypo) {
19328 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19337 if (
Diags.
isIgnored(diag::warn_sizeof_pointer_expr_memaccess, OpLoc))
19349 if (
const auto *CE = dyn_cast<CallExpr>(RHSExpr);
19351 RHSExpr = CE->
getArg(0);
19352 else if (
const auto *CXXSCE = dyn_cast<CXXStaticCastExpr>(RHSExpr);
19353 CXXSCE && CXXSCE->isXValue())
19354 RHSExpr = CXXSCE->getSubExpr();
19358 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
19359 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
19362 if (LHSDeclRef && RHSDeclRef) {
19369 auto D =
Diag(OpLoc, diag::warn_self_move)
19385 const Expr *LHSBase = LHSExpr;
19386 const Expr *RHSBase = RHSExpr;
19387 const MemberExpr *LHSME = dyn_cast<MemberExpr>(LHSExpr);
19388 const MemberExpr *RHSME = dyn_cast<MemberExpr>(RHSExpr);
19389 if (!LHSME || !RHSME)
19392 while (LHSME && RHSME) {
19399 LHSME = dyn_cast<MemberExpr>(LHSBase);
19400 RHSME = dyn_cast<MemberExpr>(RHSBase);
19403 LHSDeclRef = dyn_cast<DeclRefExpr>(LHSBase);
19404 RHSDeclRef = dyn_cast<DeclRefExpr>(RHSBase);
19405 if (LHSDeclRef && RHSDeclRef) {
19412 Diag(OpLoc, diag::warn_self_move)
19418 if (isa<CXXThisExpr>(LHSBase) && isa<CXXThisExpr>(RHSBase))
19419 Diag(OpLoc, diag::warn_self_move)
19442 bool AreUnionMembers =
false) {
19443 [[maybe_unused]]
const Type *Field1Parent =
19445 [[maybe_unused]]
const Type *Field2Parent =
19450 "Can't evaluate layout compatibility between a struct field and a "
19453 (AreUnionMembers && Field1Parent->
isUnionType())) &&
19454 "AreUnionMembers should be 'true' for union fields (only).");
19467 if (Bits1 != Bits2)
19471 if (Field1->
hasAttr<clang::NoUniqueAddressAttr>() ||
19472 Field2->
hasAttr<clang::NoUniqueAddressAttr>())
19475 if (!AreUnionMembers &&
19487 if (
const CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(RD1)) {
19492 if (D1CXX->getNumBases() != D2CXX->
getNumBases())
19497 Base1 = D1CXX->bases_begin(),
19498 BaseEnd1 = D1CXX->bases_end(),
19501 ++Base1, ++Base2) {
19505 }
else if (
const CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(RD2)) {
19507 if (D2CXX->getNumBases() > 0)
19516 for ( ; Field1 != Field1End && Field2 != Field2End; ++Field1, ++Field2) {
19520 if (Field1 != Field1End || Field2 != Field2End)
19531 for (
auto *Field2 : RD2->
fields())
19532 UnmatchedFields.insert(Field2);
19534 for (
auto *Field1 : RD1->
fields()) {
19536 I = UnmatchedFields.begin(),
19537 E = UnmatchedFields.end();
19539 for ( ; I != E; ++I) {
19541 bool Result = UnmatchedFields.erase(*I);
19551 return UnmatchedFields.empty();
19577 if (
C.hasSameType(T1, T2))
19586 if (TC1 == Type::Enum) {
19588 cast<EnumType>(T1)->getDecl(),
19589 cast<EnumType>(T2)->getDecl());
19590 }
else if (TC1 == Type::Record) {
19595 cast<RecordType>(T1)->getDecl(),
19596 cast<RecordType>(T2)->getDecl());
19620 const ValueDecl **VD, uint64_t *MagicValue,
19621 bool isConstantEvaluated) {
19629 case Stmt::UnaryOperatorClass: {
19638 case Stmt::DeclRefExprClass: {
19639 const DeclRefExpr *DRE = cast<DeclRefExpr>(TypeExpr);
19644 case Stmt::IntegerLiteralClass: {
19646 llvm::APInt MagicValueAPInt = IL->
getValue();
19647 if (MagicValueAPInt.getActiveBits() <= 64) {
19648 *MagicValue = MagicValueAPInt.getZExtValue();
19654 case Stmt::BinaryConditionalOperatorClass:
19655 case Stmt::ConditionalOperatorClass: {
19657 cast<AbstractConditionalOperator>(TypeExpr);
19660 isConstantEvaluated)) {
19670 case Stmt::BinaryOperatorClass: {
19673 TypeExpr = BO->
getRHS();
19703 const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
19706 bool isConstantEvaluated) {
19707 FoundWrongKind =
false;
19712 uint64_t MagicValue;
19714 if (!
FindTypeTagExpr(TypeExpr, Ctx, &VD, &MagicValue, isConstantEvaluated))
19718 if (TypeTagForDatatypeAttr *I = VD->
getAttr<TypeTagForDatatypeAttr>()) {
19719 if (I->getArgumentKind() != ArgumentKind) {
19720 FoundWrongKind =
true;
19723 TypeInfo.Type = I->getMatchingCType();
19724 TypeInfo.LayoutCompatible = I->getLayoutCompatible();
19725 TypeInfo.MustBeNull = I->getMustBeNull();
19736 MagicValues->find(std::make_pair(ArgumentKind, MagicValue));
19737 if (I == MagicValues->end())
19746 bool LayoutCompatible,
19748 if (!TypeTagForDatatypeMagicValues)
19749 TypeTagForDatatypeMagicValues.reset(
19750 new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);
19753 (*TypeTagForDatatypeMagicValues)[Magic] =
19769 return (T1Kind == BuiltinType::SChar && T2Kind == BuiltinType::Char_S) ||
19770 (T1Kind == BuiltinType::UChar && T2Kind == BuiltinType::Char_U) ||
19771 (T1Kind == BuiltinType::Char_U && T2Kind == BuiltinType::UChar) ||
19772 (T1Kind == BuiltinType::Char_S && T2Kind == BuiltinType::SChar);
19775void Sema::CheckArgumentWithTypeTag(
const ArgumentWithTypeTagAttr *
Attr,
19779 bool IsPointerAttr =
Attr->getIsPointer();
19782 unsigned TypeTagIdxAST =
Attr->getTypeTagIdx().getASTIndex();
19783 if (TypeTagIdxAST >= ExprArgs.size()) {
19784 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19785 << 0 <<
Attr->getTypeTagIdx().getSourceIndex();
19788 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
19789 bool FoundWrongKind;
19792 TypeTagForDatatypeMagicValues.get(), FoundWrongKind,
19794 if (FoundWrongKind)
19796 diag::warn_type_tag_for_datatype_wrong_kind)
19802 unsigned ArgumentIdxAST =
Attr->getArgumentIdx().getASTIndex();
19803 if (ArgumentIdxAST >= ExprArgs.size()) {
19804 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19805 << 1 <<
Attr->getArgumentIdx().getSourceIndex();
19808 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
19809 if (IsPointerAttr) {
19811 if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgumentExpr))
19812 if (ICE->getType()->isVoidPointerType() &&
19813 ICE->getCastKind() == CK_BitCast)
19814 ArgumentExpr = ICE->getSubExpr();
19827 diag::warn_type_safety_null_pointer_required)
19839 bool mismatch =
false;
19862 Diag(ArgumentExpr->
getExprLoc(), diag::warn_type_safety_type_mismatch)
19863 << ArgumentType << ArgumentKind
19864 <<
TypeInfo.LayoutCompatible << RequiredType
19871 MisalignedMembers.emplace_back(E, RD, MD, Alignment);
19875 for (MisalignedMember &m : MisalignedMembers) {
19881 Diag(m.E->getBeginLoc(), diag::warn_taking_address_of_packed_member)
19884 MisalignedMembers.clear();
19891 if (isa<UnaryOperator>(E) &&
19892 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
19893 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
19894 if (isa<MemberExpr>(Op)) {
19895 auto *MA = llvm::find(MisalignedMembers, MisalignedMember(Op));
19896 if (MA != MisalignedMembers.end() &&
19901 MisalignedMembers.erase(MA);
19910 const auto *ME = dyn_cast<MemberExpr>(E);
19922 bool AnyIsPacked =
false;
19924 QualType BaseType = ME->getBase()->getType();
19934 auto *FD = dyn_cast<FieldDecl>(MD);
19940 AnyIsPacked || (RD->
hasAttr<PackedAttr>() || MD->
hasAttr<PackedAttr>());
19941 ReverseMemberChain.push_back(FD);
19944 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParens());
19946 assert(TopME &&
"We did not compute a topmost MemberExpr!");
19953 const auto *DRE = dyn_cast<DeclRefExpr>(TopBase);
19957 if (!DRE && !isa<CXXThisExpr>(TopBase))
19964 if (ExpectedAlignment.
isOne())
19969 for (
const FieldDecl *FD : llvm::reverse(ReverseMemberChain))
19974 ReverseMemberChain.back()->getParent()->getTypeForDecl());
19978 if (DRE && !TopME->
isArrow()) {
19981 CompleteObjectAlignment =
19986 if (Offset % ExpectedAlignment != 0 ||
19989 CompleteObjectAlignment < ExpectedAlignment) {
20000 for (
FieldDecl *FDI : ReverseMemberChain) {
20001 if (FDI->hasAttr<PackedAttr>() ||
20002 FDI->getParent()->hasAttr<PackedAttr>()) {
20004 Alignment = std::min(
20010 assert(FD &&
"We did not find a packed FieldDecl!");
20011 Action(E, FD->
getParent(), FD, Alignment);
20015void Sema::CheckAddressOfPackedMember(
Expr *rhs) {
20016 using namespace std::placeholders;
20019 rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*
this), _1,
20023bool Sema::PrepareBuiltinElementwiseMathOneArgCall(
CallExpr *TheCall) {
20041bool Sema::SemaBuiltinElementwiseMath(
CallExpr *TheCall) {
20055 TheCall->
setType(VecTy0->getElementType());
20079 diag::err_typecheck_call_different_arg_types)
20090bool Sema::SemaBuiltinElementwiseTernaryMath(
CallExpr *TheCall,
20091 bool CheckForFloatArgs) {
20096 for (
int I = 0; I < 3; ++I) {
20100 Args[I] = Converted.
get();
20103 if (CheckForFloatArgs) {
20104 int ArgOrdinal = 1;
20105 for (
Expr *Arg : Args) {
20107 Arg->
getType(), ArgOrdinal++))
20111 int ArgOrdinal = 1;
20112 for (
Expr *Arg : Args) {
20119 for (
int I = 1; I < 3; ++I) {
20120 if (Args[0]->getType().getCanonicalType() !=
20121 Args[I]->getType().getCanonicalType()) {
20122 return Diag(Args[0]->getBeginLoc(),
20123 diag::err_typecheck_call_different_arg_types)
20124 << Args[0]->getType() << Args[I]->getType();
20127 TheCall->
setArg(I, Args[I]);
20130 TheCall->
setType(Args[0]->getType());
20134bool Sema::PrepareBuiltinReduceMathOneArgCall(
CallExpr *TheCall) {
20146bool Sema::SemaBuiltinNonDeterministicValue(
CallExpr *TheCall) {
20155 << 1 << 0 << TyArg;
20169 Expr *Matrix = MatrixArg.
get();
20174 << 1 << 1 << Matrix->
getType();
20181 MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
20184 TheCall->
setType(ResultType);
20187 TheCall->
setArg(0, Matrix);
20192static std::optional<unsigned>
20195 std::optional<llvm::APSInt>
Value =
20202 uint64_t Dim =
Value->getZExtValue();
20221 unsigned PtrArgIdx = 0;
20227 bool ArgError =
false;
20234 PtrExpr = PtrConv.
get();
20235 TheCall->
setArg(0, PtrExpr);
20246 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20253 << PtrArgIdx + 1 << 2
20260 auto ApplyArgumentConversions = [
this](
Expr *E) {
20269 ExprResult RowsConv = ApplyArgumentConversions(RowsExpr);
20271 RowsExpr = RowsConv.
get();
20272 TheCall->
setArg(1, RowsExpr);
20274 RowsExpr =
nullptr;
20276 ExprResult ColumnsConv = ApplyArgumentConversions(ColumnsExpr);
20278 ColumnsExpr = ColumnsConv.
get();
20279 TheCall->
setArg(2, ColumnsExpr);
20281 ColumnsExpr =
nullptr;
20292 std::optional<unsigned> MaybeRows;
20296 std::optional<unsigned> MaybeColumns;
20301 ExprResult StrideConv = ApplyArgumentConversions(StrideExpr);
20304 StrideExpr = StrideConv.
get();
20305 TheCall->
setArg(3, StrideExpr);
20308 if (std::optional<llvm::APSInt>
Value =
20311 if (Stride < *MaybeRows) {
20313 diag::err_builtin_matrix_stride_too_small);
20319 if (ArgError || !MaybeRows || !MaybeColumns)
20332 unsigned PtrArgIdx = 1;
20337 bool ArgError =
false;
20343 MatrixExpr = MatrixConv.
get();
20344 TheCall->
setArg(0, MatrixExpr);
20354 << 1 << 1 << MatrixExpr->
getType();
20362 PtrExpr = PtrConv.
get();
20363 TheCall->
setArg(1, PtrExpr);
20374 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20379 Diag(PtrExpr->
getBeginLoc(), diag::err_builtin_matrix_store_to_const);
20386 diag::err_builtin_matrix_pointer_arg_mismatch)
20387 << ElementTy << MatrixTy->getElementType();
20402 StrideExpr = StrideConv.
get();
20403 TheCall->
setArg(2, StrideExpr);
20408 if (std::optional<llvm::APSInt>
Value =
20411 if (Stride < MatrixTy->getNumRows()) {
20413 diag::err_builtin_matrix_stride_too_small);
20430 const auto *ATy = dyn_cast<ArrayType>(ArgExpr->
getType());
20431 if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
20433 diag::err_wasm_builtin_arg_must_be_table_type)
20436 ElTy = ATy->getElementType();
20442 unsigned ArgIndex) {
20446 diag::err_wasm_builtin_arg_must_be_integer_type)
20454bool Sema::BuiltinWasmTableGet(
CallExpr *TheCall) {
20477bool Sema::BuiltinWasmTableSet(
CallExpr *TheCall) {
20495bool Sema::BuiltinWasmTableSize(
CallExpr *TheCall) {
20509bool Sema::BuiltinWasmTableGrow(
CallExpr *TheCall) {
20520 diag::err_wasm_builtin_arg_must_match_table_element_type)
20533bool Sema::BuiltinWasmTableFill(
CallExpr *TheCall) {
20547 diag::err_wasm_builtin_arg_must_match_table_element_type)
20560bool Sema::BuiltinWasmTableCopy(
CallExpr *TheCall) {
20575 diag::err_wasm_builtin_arg_must_match_table_element_type)
20579 for (
int I = 2; I <= 4; I++) {
20599 if (!Caller || !Caller->
hasAttr<EnforceTCBAttr>())
20604 llvm::StringSet<> CalleeTCBs;
20605 for (
const auto *A :
Callee->specific_attrs<EnforceTCBAttr>())
20606 CalleeTCBs.insert(A->getTCBName());
20607 for (
const auto *A :
Callee->specific_attrs<EnforceTCBLeafAttr>())
20608 CalleeTCBs.insert(A->getTCBName());
20612 for (
const auto *A : Caller->
specific_attrs<EnforceTCBAttr>()) {
20613 StringRef CallerTCB = A->getTCBName();
20614 if (CalleeTCBs.count(CallerTCB) == 0) {
20615 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 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 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 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 SemaBuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall)
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 bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_addressof is a glvalue, and set the result type to the correspon...
static ExprResult SemaBuiltinDumpStruct(Sema &S, CallExpr *TheCall)
static bool SemaBuiltinFunctionStart(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_function_start is a function.
static bool SemaBuiltinPreserveAI(Sema &S, CallExpr *TheCall)
Check the number of arguments and set the result type to the argument type.
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 CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant)
static AbsoluteValueKind getAbsoluteValueKind(QualType T)
static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID)
static bool isKnownToHaveUnsignedValue(Expr *E)
static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout structs are layout-compatible.
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 SemaBuiltinRWPipe(Sema &S, CallExpr *Call)
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 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 SemaBuiltinReserveRWPipe(Sema &S, CallExpr *Call)
bool CheckFloatOrHalfRepresentations(Sema *S, CallExpr *TheCall)
static bool isValidBPFPreserveTypeInfoArg(Expr *Arg)
static bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID)
Check that the value argument for __builtin_is_aligned(value, alignment) and __builtin_aligned_{up,...
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 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 bool SemaOpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different overload formats specified ...
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 ExprResult SemaPointerAuthAuthAndResign(Sema &S, CallExpr *Call)
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 ExprResult SemaPointerAuthSignOrAuth(Sema &S, CallExpr *Call, PointerAuthOpKind OpKind)
static std::optional< int > GetNSMutableDictionaryArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static void adornObjCBoolConversionDiagWithTernaryFixit(Sema &S, Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder)
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 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 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 bool SemaBuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall, const TargetInfo *AuxTI, unsigned BuiltinID)
SemaBuiltinCpu{Supports|Is} - Handle __builtin_cpu_{supports|is}(char *).
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 bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx)
Returns true if pipe element type is different from the pointer.
static ExprResult SemaBuiltinLaunder(Sema &S, CallExpr *TheCall)
static ExprResult SemaPointerAuthSignGenericData(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 bool SemaBuiltinPipePackets(Sema &S, CallExpr *Call)
static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range, unsigned AbsKind, QualType ArgType)
static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall)
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 ExprResult SemaPointerAuthStrip(Sema &S, CallExpr *Call)
static bool SemaBuiltinPopcountg(Sema &S, CallExpr *TheCall)
Checks that __builtin_popcountg was called with a single argument, which is an unsigned integer.
static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty)
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 bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall)
Check that the first argument to __builtin_annotation is an integer and the second argument is a non-...
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 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 requiresParensToAddCast(const Expr *E)
static ExprResult SemaPointerAuthBlendDiscriminator(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 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.
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 CharUnits getPresumedAlignmentOfPointer(const Expr *E, Sema &S)
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 bool SemaOpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID, CallExpr *Call)
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 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 SemaBuiltinCommitRWPipe(Sema &S, CallExpr *Call)
static bool SemaBuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall)
static bool SemaOpenCLBuiltinKernelWorkGroupSize(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 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 SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall, Scope::ScopeFlags NeededScopeFlags, unsigned DiagID)
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 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.
const char * getRequiredFeatures(unsigned ID) const
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.
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)
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.
const llvm::APInt & getSize() const
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.
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
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 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.
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.
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 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.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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....
bool SemaBuiltinVectorMath(CallExpr *TheCall, QualType &Res)
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 PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CCK_ImplicitConversion)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
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
bool SemaBuiltinVectorToScalarMath(CallExpr *TheCall)
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)
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
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)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
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
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
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...
ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
SemaConvertVectorExpr - Handle __builtin_convertvector.
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())
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
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)
ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall)
SemaBuiltinShuffleVector - Handle __builtin_shufflevector.
@ 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.
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
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.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ NonNull
Values of this type can never be null.
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.
for(auto typeArg :T->getTypeArgsAsWritten())
@ 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.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ Success
Template argument deduction was successful.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
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.