66#include "llvm/ADT/APFloat.h"
67#include "llvm/ADT/APInt.h"
68#include "llvm/ADT/APSInt.h"
69#include "llvm/ADT/ArrayRef.h"
70#include "llvm/ADT/DenseMap.h"
71#include "llvm/ADT/FoldingSet.h"
72#include "llvm/ADT/STLExtras.h"
73#include "llvm/ADT/SmallBitVector.h"
74#include "llvm/ADT/SmallPtrSet.h"
75#include "llvm/ADT/SmallString.h"
76#include "llvm/ADT/SmallVector.h"
77#include "llvm/ADT/StringExtras.h"
78#include "llvm/ADT/StringRef.h"
79#include "llvm/ADT/StringSet.h"
80#include "llvm/ADT/StringSwitch.h"
81#include "llvm/Support/AtomicOrdering.h"
82#include "llvm/Support/Casting.h"
83#include "llvm/Support/Compiler.h"
84#include "llvm/Support/ConvertUTF.h"
85#include "llvm/Support/ErrorHandling.h"
86#include "llvm/Support/Format.h"
87#include "llvm/Support/Locale.h"
88#include "llvm/Support/MathExtras.h"
89#include "llvm/Support/SaveAndRestore.h"
90#include "llvm/Support/raw_ostream.h"
91#include "llvm/TargetParser/RISCVTargetParser.h"
92#include "llvm/TargetParser/Triple.h"
106using namespace clang;
110 unsigned ByteNo)
const {
124 unsigned MinArgCount) {
125 unsigned ArgCount =
Call->getNumArgs();
126 if (ArgCount >= MinArgCount)
129 return S.
Diag(
Call->getEndLoc(), diag::err_typecheck_call_too_few_args)
130 << 0 << MinArgCount << ArgCount
131 << 0 <<
Call->getSourceRange();
138 unsigned ArgCount =
Call->getNumArgs();
139 if (ArgCount <= MaxArgCount)
142 diag::err_typecheck_call_too_many_args_at_most)
143 << 0 << MaxArgCount << ArgCount
144 << 0 <<
Call->getSourceRange();
151 unsigned MaxArgCount) {
159 unsigned ArgCount =
Call->getNumArgs();
160 if (ArgCount == DesiredArgCount)
165 assert(ArgCount > DesiredArgCount &&
"should have diagnosed this");
169 Call->getArg(ArgCount - 1)->getEndLoc());
172 << 0 << DesiredArgCount << ArgCount
173 << 0 <<
Call->getArg(1)->getSourceRange();
177 if (
Value->isTypeDependent())
208 if (!Literal || !Literal->isOrdinary()) {
221 S.
Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
229 auto *Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
230 if (!Literal || !Literal->isWide()) {
231 S.
Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
232 << Arg->getSourceRange();
266 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(
297 bool IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;
299 auto IsValidIntegerType = [](
QualType Ty) {
300 return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
307 if ((!SrcTy->
isPointerType() && !IsValidIntegerType(SrcTy)) ||
311 S.
Diag(Source->
getExprLoc(), diag::err_typecheck_expect_scalar_operand)
317 if (!IsValidIntegerType(AlignOp->
getType())) {
328 llvm::APSInt AlignValue = AlignResult.
Val.
getInt();
329 llvm::APSInt MaxValue(
330 llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
331 if (AlignValue < 1) {
332 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_too_small) << 1;
335 if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
340 if (!AlignValue.isPowerOf2()) {
341 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_not_power_of_two);
344 if (AlignValue == 1) {
345 S.
Diag(AlignOp->
getExprLoc(), diag::warn_alignment_builtin_useless)
346 << IsBooleanAlignBuiltin;
374 std::pair<unsigned, const char *> Builtins[] = {
375 { Builtin::BI__builtin_add_overflow,
"ckd_add" },
376 { Builtin::BI__builtin_sub_overflow,
"ckd_sub" },
377 { Builtin::BI__builtin_mul_overflow,
"ckd_mul" },
380 bool CkdOperation = llvm::any_of(Builtins, [&](
const std::pair<
unsigned,
382 return BuiltinID ==
P.first && TheCall->
getExprLoc().isMacroID() &&
387 auto ValidCkdIntType = [](
QualType QT) {
390 if (
const auto *BT = QT.getCanonicalType()->getAs<
BuiltinType>())
391 return (BT->getKind() >= BuiltinType::Short &&
392 BT->getKind() <= BuiltinType::Int128) || (
393 BT->getKind() >= BuiltinType::UShort &&
394 BT->getKind() <= BuiltinType::UInt128) ||
395 BT->getKind() == BuiltinType::UChar ||
396 BT->getKind() == BuiltinType::SChar;
401 for (
unsigned I = 0; I < 2; ++I) {
407 bool IsValid = CkdOperation ? ValidCkdIntType(Ty) : Ty->
isIntegerType();
426 !PtrTy->getPointeeType()->isIntegerType() ||
427 (!ValidCkdIntType(PtrTy->getPointeeType()) && CkdOperation) ||
428 PtrTy->getPointeeType().isConstQualified()) {
430 diag::err_overflow_builtin_must_be_ptr_int)
438 if (BuiltinID == Builtin::BI__builtin_mul_overflow) {
439 for (
unsigned I = 0; I < 3; ++I) {
440 const auto Arg = TheCall->
getArg(I);
443 if (Ty->isBitIntType() && Ty->isSignedIntegerType() &&
445 return S.
Diag(Arg->getBeginLoc(),
446 diag::err_overflow_builtin_bit_int_max_size)
455struct BuiltinDumpStructGenerator {
464 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
465 Policy(S.Context.getPrintingPolicy()) {
469 Expr *makeOpaqueValueExpr(
Expr *Inner) {
472 Inner->getObjectKind(), Inner);
473 Actions.push_back(OVE);
477 Expr *getStringLiteral(llvm::StringRef Str) {
483 bool callPrintFunction(llvm::StringRef Format,
487 Args.reserve((TheCall->
getNumArgs() - 2) + 1 + Exprs.size());
489 Args.push_back(getStringLiteral(Format));
490 Args.insert(Args.end(), Exprs.begin(), Exprs.end());
506 Actions.push_back(RealCall.
get());
512 Expr *getIndentString(
unsigned Depth) {
518 return getStringLiteral(Indent);
522 return getStringLiteral(
T.getAsString(Policy));
526 llvm::raw_svector_ostream OS(Str);
531 switch (BT->getKind()) {
532 case BuiltinType::Bool:
535 case BuiltinType::Char_U:
536 case BuiltinType::UChar:
539 case BuiltinType::Char_S:
540 case BuiltinType::SChar:
552 analyze_printf::PrintfConversionSpecifier::sArg) {
578 bool dumpUnnamedRecord(
const RecordDecl *RD,
Expr *E,
unsigned Depth) {
579 Expr *IndentLit = getIndentString(Depth);
581 if (IndentLit ? callPrintFunction(
"%s%s", {IndentLit, TypeLit})
582 : callPrintFunction(
"%s", {TypeLit}))
585 return dumpRecordValue(RD, E, IndentLit, Depth);
598 Expr *RecordArg = makeOpaqueValueExpr(E);
601 if (callPrintFunction(
" {\n"))
605 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
606 for (
const auto &
Base : CXXRD->bases()) {
614 dumpUnnamedRecord(
Base.getType()->getAsRecordDecl(), BasePtr.
get(),
620 Expr *FieldIndentArg = getIndentString(Depth + 1);
623 for (
auto *D : RD->
decls()) {
624 auto *IFD = dyn_cast<IndirectFieldDecl>(D);
625 auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
626 if (!FD || FD->isUnnamedBitField() || FD->isAnonymousStructOrUnion())
632 getStringLiteral(FD->getName())};
634 if (FD->isBitField()) {
638 FD->getBitWidthValue(S.
Context));
652 if (
Field.isInvalid())
655 auto *InnerRD = FD->getType()->getAsRecordDecl();
656 auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
657 if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
659 if (callPrintFunction(Format, Args) ||
660 dumpRecordValue(InnerRD,
Field.get(), FieldIndentArg, Depth + 1))
664 if (appendFormatSpecifier(FD->getType(), Format)) {
666 Args.push_back(
Field.get());
676 Args.push_back(FieldAddr.
get());
679 if (callPrintFunction(Format, Args))
684 return RecordIndent ? callPrintFunction(
"%s}\n", RecordIndent)
685 : callPrintFunction(
"}\n");
688 Expr *buildWrapper() {
691 TheCall->
setType(Wrapper->getType());
712 diag::err_expected_struct_pointer_argument)
721 diag::err_incomplete_type))
730 switch (BT ? BT->getKind() : BuiltinType::Void) {
731 case BuiltinType::Dependent:
732 case BuiltinType::Overload:
733 case BuiltinType::BoundMember:
734 case BuiltinType::PseudoObject:
735 case BuiltinType::UnknownAny:
736 case BuiltinType::BuiltinFn:
742 diag::err_expected_callable_argument)
748 BuiltinDumpStructGenerator Generator(S, TheCall);
754 Expr *PtrArg = PtrArgResult.
get();
758 if (Generator.dumpUnnamedRecord(RD, PtrArg, 0))
761 return Generator.buildWrapper();
773 if (
Call->getStmtClass() != Stmt::CallExprClass) {
774 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)
775 <<
Call->getSourceRange();
779 auto CE = cast<CallExpr>(
Call);
780 if (CE->getCallee()->getType()->isBlockPointerType()) {
781 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)
782 <<
Call->getSourceRange();
786 const Decl *TargetDecl = CE->getCalleeDecl();
787 if (
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
788 if (FD->getBuiltinID()) {
789 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)
790 <<
Call->getSourceRange();
794 if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {
795 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)
796 <<
Call->getSourceRange();
804 S.
Diag(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)
818 BuiltinCall->
setType(CE->getType());
822 BuiltinCall->
setArg(1, ChainResult.
get());
829class ScanfDiagnosticFormatHandler
833 using ComputeSizeFunction =
834 llvm::function_ref<std::optional<llvm::APSInt>(
unsigned)>;
838 using DiagnoseFunction =
839 llvm::function_ref<void(
unsigned,
unsigned,
unsigned)>;
841 ComputeSizeFunction ComputeSizeArgument;
842 DiagnoseFunction Diagnose;
845 ScanfDiagnosticFormatHandler(ComputeSizeFunction ComputeSizeArgument,
846 DiagnoseFunction Diagnose)
847 : ComputeSizeArgument(ComputeSizeArgument), Diagnose(Diagnose) {}
850 const char *StartSpecifier,
851 unsigned specifierLen)
override {
852 if (!FS.consumesDataArgument())
855 unsigned NulByte = 0;
856 switch ((FS.getConversionSpecifier().getKind())) {
869 analyze_format_string::OptionalAmount::HowSpecified::Constant)
874 std::optional<llvm::APSInt> DestSizeAPS =
875 ComputeSizeArgument(FS.getArgIndex());
879 unsigned DestSize = DestSizeAPS->getZExtValue();
881 if (DestSize < SourceSize)
882 Diagnose(FS.getArgIndex(), DestSize, SourceSize);
888class EstimateSizeFormatHandler
893 bool IsKernelCompatible =
true;
896 EstimateSizeFormatHandler(StringRef Format)
897 :
Size(
std::
min(Format.find(0), Format.size()) +
901 const char *,
unsigned SpecifierLen,
904 const size_t FieldWidth = computeFieldWidth(FS);
905 const size_t Precision = computePrecision(FS);
908 switch (FS.getConversionSpecifier().getKind()) {
912 Size += std::max(FieldWidth, (
size_t)1);
924 Size += std::max(FieldWidth, Precision);
940 Size += std::max(FieldWidth, 1 +
941 (Precision ? 1 + Precision
951 (Precision ? 1 + Precision : 0) +
961 (Precision ? 1 + Precision : 0) +
976 IsKernelCompatible =
false;
977 Size += std::max(FieldWidth, 2 + Precision);
989 Size += FS.hasPlusPrefix() || FS.hasSpacePrefix();
991 if (FS.hasAlternativeForm()) {
992 switch (FS.getConversionSpecifier().getKind()) {
1021 Size += (Precision ? 0 : 1);
1028 assert(SpecifierLen <= Size &&
"no underflow");
1029 Size -= SpecifierLen;
1033 size_t getSizeLowerBound()
const {
return Size; }
1034 bool isKernelCompatible()
const {
return IsKernelCompatible; }
1039 size_t FieldWidth = 0;
1047 size_t Precision = 0;
1052 switch (FS.getConversionSpecifier().getKind()) {
1094 StringRef &FormatStrRef,
size_t &StrLen,
1096 if (
const auto *Format = dyn_cast<StringLiteral>(FormatExpr);
1097 Format && (Format->isOrdinary() || Format->isUTF8())) {
1098 FormatStrRef = Format->getString();
1101 assert(
T &&
"String literal not of constant array type!");
1102 size_t TypeSize =
T->getZExtSize();
1104 StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, FormatStrRef.find(0));
1110void Sema::checkFortifiedBuiltinMemoryFunction(
FunctionDecl *FD,
1116 bool UseDABAttr =
false;
1119 const auto *DABAttr = FD->
getAttr<DiagnoseAsBuiltinAttr>();
1121 UseDecl = DABAttr->getFunction();
1122 assert(UseDecl &&
"Missing FunctionDecl in DiagnoseAsBuiltin attribute!");
1134 auto TranslateIndex = [&](
unsigned Index) -> std::optional<unsigned> {
1141 unsigned DABIndices = DABAttr->argIndices_size();
1142 unsigned NewIndex = Index < DABIndices
1143 ? DABAttr->argIndices_begin()[Index]
1146 return std::nullopt;
1150 auto ComputeExplicitObjectSizeArgument =
1151 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1152 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1154 return std::nullopt;
1155 unsigned NewIndex = *IndexOptional;
1159 return std::nullopt;
1165 auto ComputeSizeArgument =
1166 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1172 if (Index < FD->getNumParams()) {
1173 if (
const auto *POS =
1175 BOSType = POS->getType();
1178 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1180 return std::nullopt;
1181 unsigned NewIndex = *IndexOptional;
1184 return std::nullopt;
1186 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1189 return std::nullopt;
1192 return llvm::APSInt::getUnsigned(
Result).extOrTrunc(SizeTypeWidth);
1195 auto ComputeStrLenArgument =
1196 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1197 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1199 return std::nullopt;
1200 unsigned NewIndex = *IndexOptional;
1202 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1205 return std::nullopt;
1207 return llvm::APSInt::getUnsigned(
Result + 1).extOrTrunc(SizeTypeWidth);
1210 std::optional<llvm::APSInt> SourceSize;
1211 std::optional<llvm::APSInt> DestinationSize;
1212 unsigned DiagID = 0;
1213 bool IsChkVariant =
false;
1215 auto GetFunctionName = [&]() {
1221 FunctionName = FunctionName.drop_front(std::strlen(
"__builtin___"));
1222 FunctionName = FunctionName.drop_back(std::strlen(
"_chk"));
1224 FunctionName.consume_front(
"__builtin_");
1226 return FunctionName;
1229 switch (BuiltinID) {
1232 case Builtin::BI__builtin_strcpy:
1233 case Builtin::BIstrcpy: {
1234 DiagID = diag::warn_fortify_strlen_overflow;
1235 SourceSize = ComputeStrLenArgument(1);
1236 DestinationSize = ComputeSizeArgument(0);
1240 case Builtin::BI__builtin___strcpy_chk: {
1241 DiagID = diag::warn_fortify_strlen_overflow;
1242 SourceSize = ComputeStrLenArgument(1);
1243 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1244 IsChkVariant =
true;
1248 case Builtin::BIscanf:
1249 case Builtin::BIfscanf:
1250 case Builtin::BIsscanf: {
1251 unsigned FormatIndex = 1;
1252 unsigned DataIndex = 2;
1253 if (BuiltinID == Builtin::BIscanf) {
1258 const auto *FormatExpr =
1261 StringRef FormatStrRef;
1266 auto Diagnose = [&](
unsigned ArgIndex,
unsigned DestSize,
1267 unsigned SourceSize) {
1268 DiagID = diag::warn_fortify_scanf_overflow;
1269 unsigned Index = ArgIndex + DataIndex;
1270 StringRef FunctionName = GetFunctionName();
1272 PDiag(DiagID) << FunctionName << (Index + 1)
1273 << DestSize << SourceSize);
1276 auto ShiftedComputeSizeArgument = [&](
unsigned Index) {
1277 return ComputeSizeArgument(Index + DataIndex);
1279 ScanfDiagnosticFormatHandler H(ShiftedComputeSizeArgument,
Diagnose);
1280 const char *FormatBytes = FormatStrRef.data();
1291 case Builtin::BIsprintf:
1292 case Builtin::BI__builtin___sprintf_chk: {
1293 size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
1296 StringRef FormatStrRef;
1299 EstimateSizeFormatHandler H(FormatStrRef);
1300 const char *FormatBytes = FormatStrRef.data();
1302 H, FormatBytes, FormatBytes + StrLen,
getLangOpts(),
1304 DiagID = H.isKernelCompatible()
1305 ? diag::warn_format_overflow
1306 : diag::warn_format_overflow_non_kprintf;
1307 SourceSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1308 .extOrTrunc(SizeTypeWidth);
1309 if (BuiltinID == Builtin::BI__builtin___sprintf_chk) {
1310 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1311 IsChkVariant =
true;
1313 DestinationSize = ComputeSizeArgument(0);
1320 case Builtin::BI__builtin___memcpy_chk:
1321 case Builtin::BI__builtin___memmove_chk:
1322 case Builtin::BI__builtin___memset_chk:
1323 case Builtin::BI__builtin___strlcat_chk:
1324 case Builtin::BI__builtin___strlcpy_chk:
1325 case Builtin::BI__builtin___strncat_chk:
1326 case Builtin::BI__builtin___strncpy_chk:
1327 case Builtin::BI__builtin___stpncpy_chk:
1328 case Builtin::BI__builtin___memccpy_chk:
1329 case Builtin::BI__builtin___mempcpy_chk: {
1330 DiagID = diag::warn_builtin_chk_overflow;
1331 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 2);
1333 ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1334 IsChkVariant =
true;
1338 case Builtin::BI__builtin___snprintf_chk:
1339 case Builtin::BI__builtin___vsnprintf_chk: {
1340 DiagID = diag::warn_builtin_chk_overflow;
1341 SourceSize = ComputeExplicitObjectSizeArgument(1);
1342 DestinationSize = ComputeExplicitObjectSizeArgument(3);
1343 IsChkVariant =
true;
1347 case Builtin::BIstrncat:
1348 case Builtin::BI__builtin_strncat:
1349 case Builtin::BIstrncpy:
1350 case Builtin::BI__builtin_strncpy:
1351 case Builtin::BIstpncpy:
1352 case Builtin::BI__builtin_stpncpy: {
1358 DiagID = diag::warn_fortify_source_size_mismatch;
1359 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1360 DestinationSize = ComputeSizeArgument(0);
1364 case Builtin::BImemcpy:
1365 case Builtin::BI__builtin_memcpy:
1366 case Builtin::BImemmove:
1367 case Builtin::BI__builtin_memmove:
1368 case Builtin::BImemset:
1369 case Builtin::BI__builtin_memset:
1370 case Builtin::BImempcpy:
1371 case Builtin::BI__builtin_mempcpy: {
1372 DiagID = diag::warn_fortify_source_overflow;
1373 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1374 DestinationSize = ComputeSizeArgument(0);
1377 case Builtin::BIsnprintf:
1378 case Builtin::BI__builtin_snprintf:
1379 case Builtin::BIvsnprintf:
1380 case Builtin::BI__builtin_vsnprintf: {
1381 DiagID = diag::warn_fortify_source_size_mismatch;
1382 SourceSize = ComputeExplicitObjectSizeArgument(1);
1384 StringRef FormatStrRef;
1388 EstimateSizeFormatHandler H(FormatStrRef);
1389 const char *FormatBytes = FormatStrRef.data();
1391 H, FormatBytes, FormatBytes + StrLen,
getLangOpts(),
1393 llvm::APSInt FormatSize =
1394 llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1395 .extOrTrunc(SizeTypeWidth);
1396 if (FormatSize > *SourceSize && *SourceSize != 0) {
1397 unsigned TruncationDiagID =
1398 H.isKernelCompatible() ? diag::warn_format_truncation
1399 : diag::warn_format_truncation_non_kprintf;
1402 SourceSize->toString(SpecifiedSizeStr, 10);
1403 FormatSize.toString(FormatSizeStr, 10);
1405 PDiag(TruncationDiagID)
1406 << GetFunctionName() << SpecifiedSizeStr
1411 DestinationSize = ComputeSizeArgument(0);
1415 if (!SourceSize || !DestinationSize ||
1416 llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)
1419 StringRef FunctionName = GetFunctionName();
1423 DestinationSize->toString(DestinationStr, 10);
1424 SourceSize->toString(SourceStr, 10);
1427 << FunctionName << DestinationStr << SourceStr);
1440 while (S && !S->isSEHExceptScope())
1442 if (!S || !(S->getFlags() & NeededScopeFlags)) {
1445 << DRE->getDecl()->getIdentifier();
1463 unsigned ArgCounter = 0;
1464 bool IllegalParams =
false;
1468 I != E; ++I, ++ArgCounter) {
1469 if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
1470 (*I)->getPointeeType().getQualifiers().getAddressSpace() !=
1476 if (isa<BlockExpr>(BlockArg)) {
1477 BlockDecl *BD = cast<BlockExpr>(BlockArg)->getBlockDecl();
1479 }
else if (isa<DeclRefExpr>(BlockArg)) {
1480 ErrorLoc = cast<DeclRefExpr>(BlockArg)->getBeginLoc();
1483 diag::err_opencl_enqueue_kernel_blocks_non_local_void_args);
1484 IllegalParams =
true;
1488 return IllegalParams;
1498 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_requires_extension)
1499 << 1 <<
Call->getDirectCallee()
1500 <<
"cl_khr_subgroups or __opencl_c_subgroups";
1516 S.
Diag(NDRangeArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1523 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1539 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1551 unsigned Start,
unsigned End) {
1552 bool IllegalParams =
false;
1553 for (
unsigned I = Start; I <= End; ++I)
1556 return IllegalParams;
1563 unsigned NumNonVarArgs) {
1566 unsigned NumBlockParams =
1568 unsigned TotalNumArgs = TheCall->
getNumArgs();
1572 if (TotalNumArgs != NumBlockParams + NumNonVarArgs) {
1574 diag::err_opencl_enqueue_kernel_local_size_args);
1614 diag::err_typecheck_call_too_few_args_at_least)
1615 << 0 << 4 << NumArgs << 0;
1627 diag::err_opencl_builtin_expected_type)
1635 diag::err_opencl_builtin_expected_type)
1636 << TheCall->
getDirectCallee() <<
"'kernel_enqueue_flags_t' (i.e. uint)";
1643 diag::err_opencl_builtin_expected_type)
1662 diag::err_opencl_enqueue_kernel_blocks_no_args);
1686 diag::err_opencl_builtin_expected_type)
1699 diag::err_opencl_builtin_expected_type)
1711 diag::err_opencl_builtin_expected_type)
1725 diag::err_opencl_enqueue_kernel_incorrect_args);
1731 return D->
getAttr<OpenCLAccessAttr>();
1736 const Expr *Arg0 =
Call->getArg(0);
1739 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1743 OpenCLAccessAttr *AccessQual =
1749 switch (
Call->getDirectCallee()->getBuiltinID()) {
1750 case Builtin::BIread_pipe:
1751 case Builtin::BIreserve_read_pipe:
1752 case Builtin::BIcommit_read_pipe:
1753 case Builtin::BIwork_group_reserve_read_pipe:
1754 case Builtin::BIsub_group_reserve_read_pipe:
1755 case Builtin::BIwork_group_commit_read_pipe:
1756 case Builtin::BIsub_group_commit_read_pipe:
1757 if (!(!AccessQual || AccessQual->isReadOnly())) {
1759 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1764 case Builtin::BIwrite_pipe:
1765 case Builtin::BIreserve_write_pipe:
1766 case Builtin::BIcommit_write_pipe:
1767 case Builtin::BIwork_group_reserve_write_pipe:
1768 case Builtin::BIsub_group_reserve_write_pipe:
1769 case Builtin::BIwork_group_commit_write_pipe:
1770 case Builtin::BIsub_group_commit_write_pipe:
1771 if (!(AccessQual && AccessQual->isWriteOnly())) {
1773 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1786 const Expr *Arg0 =
Call->getArg(0);
1787 const Expr *ArgIdx =
Call->getArg(Idx);
1796 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1811 switch (
Call->getNumArgs()) {
1828 if (!
Call->getArg(1)->getType()->isReserveIDT()) {
1829 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1831 <<
Call->getArg(1)->getType() <<
Call->getArg(1)->getSourceRange();
1836 const Expr *Arg2 =
Call->getArg(2);
1839 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1850 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_arg_num)
1851 <<
Call->getDirectCallee() <<
Call->getSourceRange();
1871 if (!
Call->getArg(1)->getType()->isIntegerType() &&
1872 !
Call->getArg(1)->getType()->isUnsignedIntegerType()) {
1873 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1875 <<
Call->getArg(1)->getType() <<
Call->getArg(1)->getSourceRange();
1900 if (!
Call->getArg(1)->getType()->isReserveIDT()) {
1901 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1903 <<
Call->getArg(1)->getType() <<
Call->getArg(1)->getSourceRange();
1919 if (!
Call->getArg(0)->getType()->isPipeType()) {
1920 S.
Diag(
Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1921 <<
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))
2354 ? diag::err_builtin_aix_os_unsupported
2355 : diag::err_builtin_target_unsupported)
2360 if (!isa<StringLiteral>(Arg))
2361 return S.
Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
2365 StringRef Feature = cast<StringLiteral>(Arg)->getString();
2412 TheCall->
setArg(0, Arg0);
2418 << 1 << 7 << Arg0Ty;
2428 TheCall->
setArg(1, Arg1);
2434 << 2 << 8 << Arg1Ty;
2443Sema::CheckBuiltinFunctionCall(
FunctionDecl *FDecl,
unsigned BuiltinID,
2448 unsigned ICEArguments = 0;
2455 for (
unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
2457 if ((ICEArguments & (1 << ArgNo)) == 0)
continue;
2462 if (ArgNo < TheCall->getNumArgs() &&
2463 BuiltinConstantArg(TheCall, ArgNo,
Result))
2465 ICEArguments &= ~(1 << ArgNo);
2469 switch (BuiltinID) {
2470 case Builtin::BI__builtin_cpu_supports:
2471 case Builtin::BI__builtin_cpu_is:
2476 case Builtin::BI__builtin_cpu_init:
2483 case Builtin::BI__builtin___CFStringMakeConstantString:
2487 *
this, BuiltinID, TheCall,
2488 {llvm::Triple::GOFF, llvm::Triple::XCOFF}))
2491 "Wrong # arguments to builtin CFStringMakeConstantString");
2492 if (
ObjC().CheckObjCString(TheCall->
getArg(0)))
2495 case Builtin::BI__builtin_ms_va_start:
2496 case Builtin::BI__builtin_stdarg_start:
2497 case Builtin::BI__builtin_va_start:
2498 if (BuiltinVAStart(BuiltinID, TheCall))
2501 case Builtin::BI__va_start: {
2503 case llvm::Triple::aarch64:
2504 case llvm::Triple::arm:
2505 case llvm::Triple::thumb:
2506 if (BuiltinVAStartARMMicrosoft(TheCall))
2510 if (BuiltinVAStart(BuiltinID, TheCall))
2518 case Builtin::BI_interlockedbittestandset_acq:
2519 case Builtin::BI_interlockedbittestandset_rel:
2520 case Builtin::BI_interlockedbittestandset_nf:
2521 case Builtin::BI_interlockedbittestandreset_acq:
2522 case Builtin::BI_interlockedbittestandreset_rel:
2523 case Builtin::BI_interlockedbittestandreset_nf:
2525 *
this, BuiltinID, TheCall,
2526 {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
2531 case Builtin::BI_bittest64:
2532 case Builtin::BI_bittestandcomplement64:
2533 case Builtin::BI_bittestandreset64:
2534 case Builtin::BI_bittestandset64:
2535 case Builtin::BI_interlockedbittestandreset64:
2536 case Builtin::BI_interlockedbittestandset64:
2538 *
this, BuiltinID, TheCall,
2539 {llvm::Triple::x86_64, llvm::Triple::arm, llvm::Triple::thumb,
2540 llvm::Triple::aarch64, llvm::Triple::amdgcn}))
2544 case Builtin::BI__builtin_set_flt_rounds:
2546 *
this, BuiltinID, TheCall,
2547 {llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::arm,
2548 llvm::Triple::thumb, llvm::Triple::aarch64, llvm::Triple::amdgcn}))
2552 case Builtin::BI__builtin_isgreater:
2553 case Builtin::BI__builtin_isgreaterequal:
2554 case Builtin::BI__builtin_isless:
2555 case Builtin::BI__builtin_islessequal:
2556 case Builtin::BI__builtin_islessgreater:
2557 case Builtin::BI__builtin_isunordered:
2558 if (BuiltinUnorderedCompare(TheCall, BuiltinID))
2561 case Builtin::BI__builtin_fpclassify:
2562 if (BuiltinFPClassification(TheCall, 6, BuiltinID))
2565 case Builtin::BI__builtin_isfpclass:
2566 if (BuiltinFPClassification(TheCall, 2, BuiltinID))
2569 case Builtin::BI__builtin_isfinite:
2570 case Builtin::BI__builtin_isinf:
2571 case Builtin::BI__builtin_isinf_sign:
2572 case Builtin::BI__builtin_isnan:
2573 case Builtin::BI__builtin_issignaling:
2574 case Builtin::BI__builtin_isnormal:
2575 case Builtin::BI__builtin_issubnormal:
2576 case Builtin::BI__builtin_iszero:
2577 case Builtin::BI__builtin_signbit:
2578 case Builtin::BI__builtin_signbitf:
2579 case Builtin::BI__builtin_signbitl:
2580 if (BuiltinFPClassification(TheCall, 1, BuiltinID))
2583 case Builtin::BI__builtin_shufflevector:
2587 case Builtin::BI__builtin_prefetch:
2588 if (BuiltinPrefetch(TheCall))
2591 case Builtin::BI__builtin_alloca_with_align:
2592 case Builtin::BI__builtin_alloca_with_align_uninitialized:
2593 if (BuiltinAllocaWithAlign(TheCall))
2596 case Builtin::BI__builtin_alloca:
2597 case Builtin::BI__builtin_alloca_uninitialized:
2601 case Builtin::BI__arithmetic_fence:
2602 if (BuiltinArithmeticFence(TheCall))
2605 case Builtin::BI__assume:
2606 case Builtin::BI__builtin_assume:
2607 if (BuiltinAssume(TheCall))
2610 case Builtin::BI__builtin_assume_aligned:
2611 if (BuiltinAssumeAligned(TheCall))
2614 case Builtin::BI__builtin_dynamic_object_size:
2615 case Builtin::BI__builtin_object_size:
2616 if (BuiltinConstantArgRange(TheCall, 1, 0, 3))
2619 case Builtin::BI__builtin_longjmp:
2620 if (BuiltinLongjmp(TheCall))
2623 case Builtin::BI__builtin_setjmp:
2624 if (BuiltinSetjmp(TheCall))
2627 case Builtin::BI__builtin_classify_type:
2631 case Builtin::BI__builtin_complex:
2632 if (BuiltinComplex(TheCall))
2635 case Builtin::BI__builtin_constant_p: {
2643 case Builtin::BI__builtin_launder:
2645 case Builtin::BI__sync_fetch_and_add:
2646 case Builtin::BI__sync_fetch_and_add_1:
2647 case Builtin::BI__sync_fetch_and_add_2:
2648 case Builtin::BI__sync_fetch_and_add_4:
2649 case Builtin::BI__sync_fetch_and_add_8:
2650 case Builtin::BI__sync_fetch_and_add_16:
2651 case Builtin::BI__sync_fetch_and_sub:
2652 case Builtin::BI__sync_fetch_and_sub_1:
2653 case Builtin::BI__sync_fetch_and_sub_2:
2654 case Builtin::BI__sync_fetch_and_sub_4:
2655 case Builtin::BI__sync_fetch_and_sub_8:
2656 case Builtin::BI__sync_fetch_and_sub_16:
2657 case Builtin::BI__sync_fetch_and_or:
2658 case Builtin::BI__sync_fetch_and_or_1:
2659 case Builtin::BI__sync_fetch_and_or_2:
2660 case Builtin::BI__sync_fetch_and_or_4:
2661 case Builtin::BI__sync_fetch_and_or_8:
2662 case Builtin::BI__sync_fetch_and_or_16:
2663 case Builtin::BI__sync_fetch_and_and:
2664 case Builtin::BI__sync_fetch_and_and_1:
2665 case Builtin::BI__sync_fetch_and_and_2:
2666 case Builtin::BI__sync_fetch_and_and_4:
2667 case Builtin::BI__sync_fetch_and_and_8:
2668 case Builtin::BI__sync_fetch_and_and_16:
2669 case Builtin::BI__sync_fetch_and_xor:
2670 case Builtin::BI__sync_fetch_and_xor_1:
2671 case Builtin::BI__sync_fetch_and_xor_2:
2672 case Builtin::BI__sync_fetch_and_xor_4:
2673 case Builtin::BI__sync_fetch_and_xor_8:
2674 case Builtin::BI__sync_fetch_and_xor_16:
2675 case Builtin::BI__sync_fetch_and_nand:
2676 case Builtin::BI__sync_fetch_and_nand_1:
2677 case Builtin::BI__sync_fetch_and_nand_2:
2678 case Builtin::BI__sync_fetch_and_nand_4:
2679 case Builtin::BI__sync_fetch_and_nand_8:
2680 case Builtin::BI__sync_fetch_and_nand_16:
2681 case Builtin::BI__sync_add_and_fetch:
2682 case Builtin::BI__sync_add_and_fetch_1:
2683 case Builtin::BI__sync_add_and_fetch_2:
2684 case Builtin::BI__sync_add_and_fetch_4:
2685 case Builtin::BI__sync_add_and_fetch_8:
2686 case Builtin::BI__sync_add_and_fetch_16:
2687 case Builtin::BI__sync_sub_and_fetch:
2688 case Builtin::BI__sync_sub_and_fetch_1:
2689 case Builtin::BI__sync_sub_and_fetch_2:
2690 case Builtin::BI__sync_sub_and_fetch_4:
2691 case Builtin::BI__sync_sub_and_fetch_8:
2692 case Builtin::BI__sync_sub_and_fetch_16:
2693 case Builtin::BI__sync_and_and_fetch:
2694 case Builtin::BI__sync_and_and_fetch_1:
2695 case Builtin::BI__sync_and_and_fetch_2:
2696 case Builtin::BI__sync_and_and_fetch_4:
2697 case Builtin::BI__sync_and_and_fetch_8:
2698 case Builtin::BI__sync_and_and_fetch_16:
2699 case Builtin::BI__sync_or_and_fetch:
2700 case Builtin::BI__sync_or_and_fetch_1:
2701 case Builtin::BI__sync_or_and_fetch_2:
2702 case Builtin::BI__sync_or_and_fetch_4:
2703 case Builtin::BI__sync_or_and_fetch_8:
2704 case Builtin::BI__sync_or_and_fetch_16:
2705 case Builtin::BI__sync_xor_and_fetch:
2706 case Builtin::BI__sync_xor_and_fetch_1:
2707 case Builtin::BI__sync_xor_and_fetch_2:
2708 case Builtin::BI__sync_xor_and_fetch_4:
2709 case Builtin::BI__sync_xor_and_fetch_8:
2710 case Builtin::BI__sync_xor_and_fetch_16:
2711 case Builtin::BI__sync_nand_and_fetch:
2712 case Builtin::BI__sync_nand_and_fetch_1:
2713 case Builtin::BI__sync_nand_and_fetch_2:
2714 case Builtin::BI__sync_nand_and_fetch_4:
2715 case Builtin::BI__sync_nand_and_fetch_8:
2716 case Builtin::BI__sync_nand_and_fetch_16:
2717 case Builtin::BI__sync_val_compare_and_swap:
2718 case Builtin::BI__sync_val_compare_and_swap_1:
2719 case Builtin::BI__sync_val_compare_and_swap_2:
2720 case Builtin::BI__sync_val_compare_and_swap_4:
2721 case Builtin::BI__sync_val_compare_and_swap_8:
2722 case Builtin::BI__sync_val_compare_and_swap_16:
2723 case Builtin::BI__sync_bool_compare_and_swap:
2724 case Builtin::BI__sync_bool_compare_and_swap_1:
2725 case Builtin::BI__sync_bool_compare_and_swap_2:
2726 case Builtin::BI__sync_bool_compare_and_swap_4:
2727 case Builtin::BI__sync_bool_compare_and_swap_8:
2728 case Builtin::BI__sync_bool_compare_and_swap_16:
2729 case Builtin::BI__sync_lock_test_and_set:
2730 case Builtin::BI__sync_lock_test_and_set_1:
2731 case Builtin::BI__sync_lock_test_and_set_2:
2732 case Builtin::BI__sync_lock_test_and_set_4:
2733 case Builtin::BI__sync_lock_test_and_set_8:
2734 case Builtin::BI__sync_lock_test_and_set_16:
2735 case Builtin::BI__sync_lock_release:
2736 case Builtin::BI__sync_lock_release_1:
2737 case Builtin::BI__sync_lock_release_2:
2738 case Builtin::BI__sync_lock_release_4:
2739 case Builtin::BI__sync_lock_release_8:
2740 case Builtin::BI__sync_lock_release_16:
2741 case Builtin::BI__sync_swap:
2742 case Builtin::BI__sync_swap_1:
2743 case Builtin::BI__sync_swap_2:
2744 case Builtin::BI__sync_swap_4:
2745 case Builtin::BI__sync_swap_8:
2746 case Builtin::BI__sync_swap_16:
2747 return BuiltinAtomicOverloaded(TheCallResult);
2748 case Builtin::BI__sync_synchronize:
2752 case Builtin::BI__builtin_nontemporal_load:
2753 case Builtin::BI__builtin_nontemporal_store:
2754 return BuiltinNontemporalOverloaded(TheCallResult);
2755 case Builtin::BI__builtin_memcpy_inline: {
2768 case Builtin::BI__builtin_memset_inline: {
2779#define BUILTIN(ID, TYPE, ATTRS)
2780#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
2781 case Builtin::BI##ID: \
2782 return AtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
2783#include "clang/Basic/Builtins.inc"
2784 case Builtin::BI__annotation:
2788 case Builtin::BI__builtin_annotation:
2792 case Builtin::BI__builtin_addressof:
2796 case Builtin::BI__builtin_function_start:
2800 case Builtin::BI__builtin_is_aligned:
2801 case Builtin::BI__builtin_align_up:
2802 case Builtin::BI__builtin_align_down:
2806 case Builtin::BI__builtin_add_overflow:
2807 case Builtin::BI__builtin_sub_overflow:
2808 case Builtin::BI__builtin_mul_overflow:
2812 case Builtin::BI__builtin_operator_new:
2813 case Builtin::BI__builtin_operator_delete: {
2814 bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
2816 BuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
2821 case Builtin::BI__builtin_dump_struct:
2823 case Builtin::BI__builtin_expect_with_probability: {
2834 Diag(ProbArg->
getBeginLoc(), diag::err_probability_not_constant_float)
2841 bool LoseInfo =
false;
2842 Probability.convert(llvm::APFloat::IEEEdouble(),
2843 llvm::RoundingMode::Dynamic, &LoseInfo);
2844 if (!(Probability >= llvm::APFloat(0.0) &&
2845 Probability <= llvm::APFloat(1.0))) {
2852 case Builtin::BI__builtin_preserve_access_index:
2856 case Builtin::BI__builtin_call_with_static_chain:
2860 case Builtin::BI__exception_code:
2861 case Builtin::BI_exception_code:
2863 diag::err_seh___except_block))
2866 case Builtin::BI__exception_info:
2867 case Builtin::BI_exception_info:
2869 diag::err_seh___except_filter))
2872 case Builtin::BI__GetExceptionInfo:
2884 case Builtin::BIaddressof:
2885 case Builtin::BI__addressof:
2886 case Builtin::BIforward:
2887 case Builtin::BIforward_like:
2888 case Builtin::BImove:
2889 case Builtin::BImove_if_noexcept:
2890 case Builtin::BIas_const: {
2898 bool ReturnsPointer = BuiltinID == Builtin::BIaddressof ||
2899 BuiltinID == Builtin::BI__addressof;
2901 (ReturnsPointer ?
Result->isAnyPointerType()
2902 :
Result->isReferenceType()) &&
2904 Result->getPointeeType()))) {
2905 Diag(TheCall->
getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2911 case Builtin::BI__builtin_ptrauth_strip:
2913 case Builtin::BI__builtin_ptrauth_blend_discriminator:
2915 case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
2917 case Builtin::BI__builtin_ptrauth_auth:
2919 case Builtin::BI__builtin_ptrauth_sign_generic_data:
2921 case Builtin::BI__builtin_ptrauth_auth_and_resign:
2924 case Builtin::BIread_pipe:
2925 case Builtin::BIwrite_pipe:
2931 case Builtin::BIreserve_read_pipe:
2932 case Builtin::BIreserve_write_pipe:
2933 case Builtin::BIwork_group_reserve_read_pipe:
2934 case Builtin::BIwork_group_reserve_write_pipe:
2938 case Builtin::BIsub_group_reserve_read_pipe:
2939 case Builtin::BIsub_group_reserve_write_pipe:
2944 case Builtin::BIcommit_read_pipe:
2945 case Builtin::BIcommit_write_pipe:
2946 case Builtin::BIwork_group_commit_read_pipe:
2947 case Builtin::BIwork_group_commit_write_pipe:
2951 case Builtin::BIsub_group_commit_read_pipe:
2952 case Builtin::BIsub_group_commit_write_pipe:
2957 case Builtin::BIget_pipe_num_packets:
2958 case Builtin::BIget_pipe_max_packets:
2962 case Builtin::BIto_global:
2963 case Builtin::BIto_local:
2964 case Builtin::BIto_private:
2969 case Builtin::BIenqueue_kernel:
2973 case Builtin::BIget_kernel_work_group_size:
2974 case Builtin::BIget_kernel_preferred_work_group_size_multiple:
2978 case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
2979 case Builtin::BIget_kernel_sub_group_count_for_ndrange:
2983 case Builtin::BI__builtin_os_log_format:
2986 case Builtin::BI__builtin_os_log_format_buffer_size:
2987 if (BuiltinOSLogFormat(TheCall))
2990 case Builtin::BI__builtin_frame_address:
2991 case Builtin::BI__builtin_return_address: {
2992 if (BuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
3000 Result.Val.getInt() != 0)
3002 << ((BuiltinID == Builtin::BI__builtin_return_address)
3003 ?
"__builtin_return_address"
3004 :
"__builtin_frame_address")
3009 case Builtin::BI__builtin_nondeterministic_value: {
3010 if (BuiltinNonDeterministicValue(TheCall))
3017 case Builtin::BI__builtin_elementwise_abs: {
3018 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3025 EltTy = VecTy->getElementType();
3028 diag::err_builtin_invalid_arg_type)
3037 case Builtin::BI__builtin_elementwise_ceil:
3038 case Builtin::BI__builtin_elementwise_cos:
3039 case Builtin::BI__builtin_elementwise_exp:
3040 case Builtin::BI__builtin_elementwise_exp2:
3041 case Builtin::BI__builtin_elementwise_floor:
3042 case Builtin::BI__builtin_elementwise_log:
3043 case Builtin::BI__builtin_elementwise_log2:
3044 case Builtin::BI__builtin_elementwise_log10:
3045 case Builtin::BI__builtin_elementwise_roundeven:
3046 case Builtin::BI__builtin_elementwise_round:
3047 case Builtin::BI__builtin_elementwise_rint:
3048 case Builtin::BI__builtin_elementwise_nearbyint:
3049 case Builtin::BI__builtin_elementwise_sin:
3050 case Builtin::BI__builtin_elementwise_sqrt:
3051 case Builtin::BI__builtin_elementwise_tan:
3052 case Builtin::BI__builtin_elementwise_trunc:
3053 case Builtin::BI__builtin_elementwise_canonicalize: {
3054 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3063 case Builtin::BI__builtin_elementwise_fma: {
3064 if (BuiltinElementwiseTernaryMath(TheCall))
3071 case Builtin::BI__builtin_elementwise_pow: {
3072 if (BuiltinElementwiseMath(TheCall))
3086 case Builtin::BI__builtin_elementwise_add_sat:
3087 case Builtin::BI__builtin_elementwise_sub_sat: {
3088 if (BuiltinElementwiseMath(TheCall))
3096 EltTy = VecTy->getElementType();
3106 case Builtin::BI__builtin_elementwise_min:
3107 case Builtin::BI__builtin_elementwise_max:
3108 if (BuiltinElementwiseMath(TheCall))
3112 case Builtin::BI__builtin_elementwise_bitreverse: {
3113 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3121 EltTy = VecTy->getElementType();
3131 case Builtin::BI__builtin_elementwise_copysign: {
3151 diag::err_typecheck_call_different_arg_types)
3152 << MagnitudeTy << SignTy;
3160 case Builtin::BI__builtin_reduce_max:
3161 case Builtin::BI__builtin_reduce_min: {
3162 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3170 ElTy = TyA->getElementType();
3174 if (ElTy.isNull()) {
3186 case Builtin::BI__builtin_reduce_add:
3187 case Builtin::BI__builtin_reduce_mul:
3188 case Builtin::BI__builtin_reduce_xor:
3189 case Builtin::BI__builtin_reduce_or:
3190 case Builtin::BI__builtin_reduce_and: {
3191 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3199 ElTy = TyA->getElementType();
3203 if (ElTy.isNull() || !ElTy->isIntegerType()) {
3213 case Builtin::BI__builtin_matrix_transpose:
3214 return BuiltinMatrixTranspose(TheCall, TheCallResult);
3216 case Builtin::BI__builtin_matrix_column_major_load:
3217 return BuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
3219 case Builtin::BI__builtin_matrix_column_major_store:
3220 return BuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
3222 case Builtin::BI__builtin_get_device_side_mangled_name: {
3223 auto Check = [](
CallExpr *TheCall) {
3229 auto *D = DRE->getDecl();
3230 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
3232 return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
3233 D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
3235 if (!Check(TheCall)) {
3237 diag::err_hip_invalid_args_builtin_mangled_name);
3242 case Builtin::BI__builtin_popcountg:
3246 case Builtin::BI__builtin_clzg:
3247 case Builtin::BI__builtin_ctzg:
3252 case Builtin::BI__builtin_allow_runtime_check: {
3272 "Aux Target Builtin, but not an aux target?");
3274 if (CheckTSBuiltinFunctionCall(
3285 return TheCallResult;
3289static unsigned RFT(
unsigned t,
bool shift =
false,
bool ForceQuad =
false) {
3291 int IsQuad = ForceQuad ?
true :
Type.isQuad();
3292 switch (
Type.getEltType()) {
3295 return shift ? 7 : (8 << IsQuad) - 1;
3298 return shift ? 15 : (4 << IsQuad) - 1;
3300 return shift ? 31 : (2 << IsQuad) - 1;
3303 return shift ? 63 : (1 << IsQuad) - 1;
3305 return shift ? 127 : (1 << IsQuad) - 1;
3307 assert(!shift &&
"cannot shift float types!");
3308 return (4 << IsQuad) - 1;
3310 assert(!shift &&
"cannot shift float types!");
3311 return (2 << IsQuad) - 1;
3313 assert(!shift &&
"cannot shift float types!");
3314 return (1 << IsQuad) - 1;
3316 assert(!shift &&
"cannot shift float types!");
3317 return (4 << IsQuad) - 1;
3319 llvm_unreachable(
"Invalid NeonTypeFlag!");
3326 bool IsPolyUnsigned,
bool IsInt64Long) {
3360 llvm_unreachable(
"Invalid NeonTypeFlag!");
3384bool Sema::ParseSVEImmChecks(
3387 bool HasError =
false;
3388 for (
auto &I : ImmChecks) {
3389 int ArgNum, CheckTy, ElementSizeInBits;
3390 std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;
3396 auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
3397 int ErrDiag) ->
bool {
3405 if (BuiltinConstantArg(TheCall, ArgNum, Imm))
3408 if (!CheckImm(Imm.getSExtValue()))
3414 case SVETypeFlags::ImmCheck0_31:
3415 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
3418 case SVETypeFlags::ImmCheck0_13:
3419 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
3422 case SVETypeFlags::ImmCheck1_16:
3423 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
3426 case SVETypeFlags::ImmCheck0_7:
3427 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
3430 case SVETypeFlags::ImmCheck1_1:
3431 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 1))
3434 case SVETypeFlags::ImmCheck1_3:
3435 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 3))
3438 case SVETypeFlags::ImmCheck1_7:
3439 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 7))
3442 case SVETypeFlags::ImmCheckExtract:
3443 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3444 (2048 / ElementSizeInBits) - 1))
3447 case SVETypeFlags::ImmCheckShiftRight:
3448 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
3451 case SVETypeFlags::ImmCheckShiftRightNarrow:
3452 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits / 2))
3455 case SVETypeFlags::ImmCheckShiftLeft:
3456 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, ElementSizeInBits - 1))
3459 case SVETypeFlags::ImmCheckLaneIndex:
3460 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3461 (128 / (1 * ElementSizeInBits)) - 1))
3464 case SVETypeFlags::ImmCheckLaneIndexCompRotate:
3465 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3466 (128 / (2 * ElementSizeInBits)) - 1))
3469 case SVETypeFlags::ImmCheckLaneIndexDot:
3470 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3471 (128 / (4 * ElementSizeInBits)) - 1))
3474 case SVETypeFlags::ImmCheckComplexRot90_270:
3475 if (CheckImmediateInSet([](
int64_t V) {
return V == 90 ||
V == 270; },
3476 diag::err_rotation_argument_to_cadd))
3479 case SVETypeFlags::ImmCheckComplexRotAll90:
3480 if (CheckImmediateInSet(
3482 return V == 0 ||
V == 90 ||
V == 180 ||
V == 270;
3484 diag::err_rotation_argument_to_cmla))
3487 case SVETypeFlags::ImmCheck0_1:
3488 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
3491 case SVETypeFlags::ImmCheck0_2:
3492 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
3495 case SVETypeFlags::ImmCheck0_3:
3496 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
3499 case SVETypeFlags::ImmCheck0_0:
3500 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 0))
3503 case SVETypeFlags::ImmCheck0_15:
3504 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 15))
3507 case SVETypeFlags::ImmCheck0_255:
3508 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 255))
3511 case SVETypeFlags::ImmCheck2_4_Mul2:
3512 if (BuiltinConstantArgRange(TheCall, ArgNum, 2, 4) ||
3513 BuiltinConstantArgMultiple(TheCall, ArgNum, 2))
3523 if (FD->
hasAttr<ArmLocallyStreamingAttr>())
3527 if (FPT->getAArch64SMEAttributes() &
3530 if (FPT->getAArch64SMEAttributes() &
3544 llvm::StringMap<bool> CallerFeatureMap;
3553 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3559 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3565 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3574 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZA());
3581 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZT0());
3585 switch (BuiltinID) {
3588#define GET_SME_BUILTIN_GET_STATE
3589#include "clang/Basic/arm_sme_builtins_za_state.inc"
3590#undef GET_SME_BUILTIN_GET_STATE
3594bool Sema::CheckSMEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3598 switch (BuiltinID) {
3599#define GET_SME_STREAMING_ATTRS
3600#include "clang/Basic/arm_sme_streaming_attrs.inc"
3601#undef GET_SME_STREAMING_ATTRS
3609 diag::warn_attribute_arm_za_builtin_no_za_state)
3614 diag::warn_attribute_arm_zt0_builtin_no_zt0_state)
3621 switch (BuiltinID) {
3624#define GET_SME_IMMEDIATE_CHECK
3625#include "clang/Basic/arm_sme_sema_rangechecks.inc"
3626#undef GET_SME_IMMEDIATE_CHECK
3629 return ParseSVEImmChecks(TheCall, ImmChecks);
3632bool Sema::CheckSVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3636 switch (BuiltinID) {
3637#define GET_SVE_STREAMING_ATTRS
3638#include "clang/Basic/arm_sve_streaming_attrs.inc"
3639#undef GET_SVE_STREAMING_ATTRS
3647 switch (BuiltinID) {
3650#define GET_SVE_IMMEDIATE_CHECK
3651#include "clang/Basic/arm_sve_sema_rangechecks.inc"
3652#undef GET_SVE_IMMEDIATE_CHECK
3655 return ParseSVEImmChecks(TheCall, ImmChecks);
3658bool Sema::CheckNeonBuiltinFunctionCall(
const TargetInfo &TI,
3659 unsigned BuiltinID,
CallExpr *TheCall) {
3662 switch (BuiltinID) {
3665#define GET_NEON_BUILTINS
3666#define TARGET_BUILTIN(id, ...) case NEON::BI##id:
3667#define BUILTIN(id, ...) case NEON::BI##id:
3668#include "clang/Basic/arm_neon.inc"
3671#undef TARGET_BUILTIN
3673#undef GET_NEON_BUILTINS
3681 bool HasConstPtr =
false;
3682 switch (BuiltinID) {
3683#define GET_NEON_OVERLOAD_CHECK
3684#include "clang/Basic/arm_neon.inc"
3685#include "clang/Basic/arm_fp16.inc"
3686#undef GET_NEON_OVERLOAD_CHECK
3693 if (BuiltinConstantArg(TheCall, ImmArg,
Result))
3696 TV =
Result.getLimitedValue(64);
3697 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3702 if (PtrArgNum >= 0) {
3706 Arg = ICE->getSubExpr();
3710 llvm::Triple::ArchType Arch = TI.
getTriple().getArch();
3711 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3712 Arch == llvm::Triple::aarch64_32 ||
3713 Arch == llvm::Triple::aarch64_be;
3731 unsigned i = 0, l = 0, u = 0;
3732 switch (BuiltinID) {
3735 #define GET_NEON_IMMEDIATE_CHECK
3736 #include "clang/Basic/arm_neon.inc"
3737 #include "clang/Basic/arm_fp16.inc"
3738 #undef GET_NEON_IMMEDIATE_CHECK
3741 return BuiltinConstantArgRange(TheCall, i, l, u + l);
3744bool Sema::CheckMVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3745 switch (BuiltinID) {
3748 #include "clang/Basic/arm_mve_builtin_sema.inc"
3752bool Sema::CheckCDEBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3755 switch (BuiltinID) {
3758#include "clang/Basic/arm_cde_builtin_sema.inc"
3764 return CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
true);
3767bool Sema::CheckARMCoprocessorImmediate(
const TargetInfo &TI,
3768 const Expr *CoprocArg,
bool WantCDE) {
3777 int64_t CoprocNo = CoprocNoAP.getExtValue();
3778 assert(CoprocNo >= 0 &&
"Coprocessor immediate must be non-negative");
3781 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3783 if (IsCDECoproc != WantCDE)
3790bool Sema::CheckARMBuiltinExclusiveCall(
unsigned BuiltinID,
CallExpr *TheCall,
3791 unsigned MaxWidth) {
3792 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3793 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3794 BuiltinID == ARM::BI__builtin_arm_strex ||
3795 BuiltinID == ARM::BI__builtin_arm_stlex ||
3796 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3797 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3798 BuiltinID == AArch64::BI__builtin_arm_strex ||
3799 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3800 "unexpected ARM builtin");
3801 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3802 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3803 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3804 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3816 Expr *PointerArg = TheCall->
getArg(IsLdrex ? 0 : 1);
3820 PointerArg = PointerArgRes.
get();
3840 CastNeeded = CK_BitCast;
3841 Diag(DRE->
getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3851 PointerArg = PointerArgRes.
get();
3853 TheCall->
setArg(IsLdrex ? 0 : 1, PointerArg);
3858 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3865 assert(MaxWidth == 64 &&
"Diagnostic unexpectedly inaccurate");
3866 Diag(DRE->
getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3905bool Sema::CheckARMBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3907 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3908 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3909 BuiltinID == ARM::BI__builtin_arm_strex ||
3910 BuiltinID == ARM::BI__builtin_arm_stlex) {
3911 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3914 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3915 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3916 BuiltinConstantArgRange(TheCall, 2, 0, 1);
3919 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3920 BuiltinID == ARM::BI__builtin_arm_wsr64)
3921 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3,
false);
3923 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3924 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3925 BuiltinID == ARM::BI__builtin_arm_wsr ||
3926 BuiltinID == ARM::BI__builtin_arm_wsrp)
3927 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3929 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3931 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3933 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3939 switch (BuiltinID) {
3940 default:
return false;
3941 case ARM::BI__builtin_arm_ssat:
3942 return BuiltinConstantArgRange(TheCall, 1, 1, 32);
3943 case ARM::BI__builtin_arm_usat:
3944 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
3945 case ARM::BI__builtin_arm_ssat16:
3946 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
3947 case ARM::BI__builtin_arm_usat16:
3948 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
3949 case ARM::BI__builtin_arm_vcvtr_f:
3950 case ARM::BI__builtin_arm_vcvtr_d:
3951 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
3952 case ARM::BI__builtin_arm_dmb:
3953 case ARM::BI__builtin_arm_dsb:
3954 case ARM::BI__builtin_arm_isb:
3955 case ARM::BI__builtin_arm_dbg:
3956 return BuiltinConstantArgRange(TheCall, 0, 0, 15);
3957 case ARM::BI__builtin_arm_cdp:
3958 case ARM::BI__builtin_arm_cdp2:
3959 case ARM::BI__builtin_arm_mcr:
3960 case ARM::BI__builtin_arm_mcr2:
3961 case ARM::BI__builtin_arm_mrc:
3962 case ARM::BI__builtin_arm_mrc2:
3963 case ARM::BI__builtin_arm_mcrr:
3964 case ARM::BI__builtin_arm_mcrr2:
3965 case ARM::BI__builtin_arm_mrrc:
3966 case ARM::BI__builtin_arm_mrrc2:
3967 case ARM::BI__builtin_arm_ldc:
3968 case ARM::BI__builtin_arm_ldcl:
3969 case ARM::BI__builtin_arm_ldc2:
3970 case ARM::BI__builtin_arm_ldc2l:
3971 case ARM::BI__builtin_arm_stc:
3972 case ARM::BI__builtin_arm_stcl:
3973 case ARM::BI__builtin_arm_stc2:
3974 case ARM::BI__builtin_arm_stc2l:
3975 return BuiltinConstantArgRange(TheCall, 0, 0, 15) ||
3976 CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
3981bool Sema::CheckAArch64BuiltinFunctionCall(
const TargetInfo &TI,
3984 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3985 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3986 BuiltinID == AArch64::BI__builtin_arm_strex ||
3987 BuiltinID == AArch64::BI__builtin_arm_stlex) {
3988 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
3991 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
3992 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3993 BuiltinConstantArgRange(TheCall, 2, 0, 3) ||
3994 BuiltinConstantArgRange(TheCall, 3, 0, 1) ||
3995 BuiltinConstantArgRange(TheCall, 4, 0, 1);
3998 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
3999 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
4000 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
4001 BuiltinID == AArch64::BI__builtin_arm_wsr128)
4002 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
4005 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
4006 BuiltinID == AArch64::BI__builtin_arm_addg ||
4007 BuiltinID == AArch64::BI__builtin_arm_gmi ||
4008 BuiltinID == AArch64::BI__builtin_arm_ldg ||
4009 BuiltinID == AArch64::BI__builtin_arm_stg ||
4010 BuiltinID == AArch64::BI__builtin_arm_subp) {
4011 return BuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
4014 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
4015 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
4016 BuiltinID == AArch64::BI__builtin_arm_wsr ||
4017 BuiltinID == AArch64::BI__builtin_arm_wsrp)
4018 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
4023 if (BuiltinID == AArch64::BI_ReadStatusReg ||
4024 BuiltinID == AArch64::BI_WriteStatusReg)
4025 return BuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
4027 if (BuiltinID == AArch64::BI__getReg)
4028 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
4030 if (BuiltinID == AArch64::BI__break)
4031 return BuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
4033 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
4036 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
4039 if (CheckSMEBuiltinFunctionCall(BuiltinID, TheCall))
4044 unsigned i = 0, l = 0, u = 0;
4045 switch (BuiltinID) {
4046 default:
return false;
4047 case AArch64::BI__builtin_arm_dmb:
4048 case AArch64::BI__builtin_arm_dsb:
4049 case AArch64::BI__builtin_arm_isb: l = 0; u = 15;
break;
4050 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535;
break;
4053 return BuiltinConstantArgRange(TheCall, i, l, u + l);
4090 if (!RT->getDecl()->getDeclName().isEmpty())
4093 if (!ET->getDecl()->getDeclName().isEmpty())
4109 const auto *UO = dyn_cast<UnaryOperator>(Arg->
IgnoreParens());
4113 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
4116 if (CE->getCastKind() != CK_IntegralToPointer &&
4117 CE->getCastKind() != CK_NullToPointer)
4121 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
4126 dyn_cast<EnumConstantDecl>(DR->getDecl());
4137 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
4140bool Sema::CheckBPFBuiltinFunctionCall(
unsigned BuiltinID,
4142 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
4143 BuiltinID == BPF::BI__builtin_btf_type_id ||
4144 BuiltinID == BPF::BI__builtin_preserve_type_info ||
4145 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
4146 "unexpected BPF builtin");
4156 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
4157 kind = diag::err_preserve_field_info_not_const;
4158 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
4159 kind = diag::err_btf_type_id_not_const;
4160 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
4161 kind = diag::err_preserve_type_info_not_const;
4163 kind = diag::err_preserve_enum_value_not_const;
4169 Arg = TheCall->
getArg(0);
4170 bool InvalidArg =
false;
4171 bool ReturnUnsignedInt =
true;
4172 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
4175 kind = diag::err_preserve_field_info_not_field;
4177 }
else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
4180 kind = diag::err_preserve_type_info_invalid;
4182 }
else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
4185 kind = diag::err_preserve_enum_value_invalid;
4187 ReturnUnsignedInt =
false;
4188 }
else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
4189 ReturnUnsignedInt =
false;
4197 if (ReturnUnsignedInt)
4204bool Sema::CheckHexagonBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4217 { Hexagon::BI__builtin_circ_ldd, {{ 3,
true, 4, 3 }} },
4218 { Hexagon::BI__builtin_circ_ldw, {{ 3,
true, 4, 2 }} },
4219 { Hexagon::BI__builtin_circ_ldh, {{ 3,
true, 4, 1 }} },
4220 { Hexagon::BI__builtin_circ_lduh, {{ 3,
true, 4, 1 }} },
4221 { Hexagon::BI__builtin_circ_ldb, {{ 3,
true, 4, 0 }} },
4222 { Hexagon::BI__builtin_circ_ldub, {{ 3,
true, 4, 0 }} },
4223 { Hexagon::BI__builtin_circ_std, {{ 3,
true, 4, 3 }} },
4224 { Hexagon::BI__builtin_circ_stw, {{ 3,
true, 4, 2 }} },
4225 { Hexagon::BI__builtin_circ_sth, {{ 3,
true, 4, 1 }} },
4226 { Hexagon::BI__builtin_circ_sthhi, {{ 3,
true, 4, 1 }} },
4227 { Hexagon::BI__builtin_circ_stb, {{ 3,
true, 4, 0 }} },
4229 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1,
true, 4, 0 }} },
4230 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1,
true, 4, 0 }} },
4231 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1,
true, 4, 1 }} },
4232 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1,
true, 4, 1 }} },
4233 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1,
true, 4, 2 }} },
4234 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1,
true, 4, 3 }} },
4235 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1,
true, 4, 0 }} },
4236 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1,
true, 4, 1 }} },
4237 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1,
true, 4, 1 }} },
4238 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1,
true, 4, 2 }} },
4239 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1,
true, 4, 3 }} },
4241 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1,
true, 8, 0 }} },
4242 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1,
false, 16, 0 }} },
4243 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1,
false, 16, 0 }} },
4244 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0,
true, 8, 0 }} },
4245 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1,
false, 5, 0 }} },
4246 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1,
false, 8, 0 }} },
4247 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1,
true, 8, 0 }} },
4248 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1,
false, 5, 0 }} },
4249 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1,
false, 5, 0 }} },
4250 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1,
false, 5, 0 }} },
4251 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1,
false, 8, 0 }} },
4252 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1,
true, 8, 0 }} },
4253 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1,
false, 7, 0 }} },
4254 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1,
true, 8, 0 }} },
4255 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1,
true, 8, 0 }} },
4256 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1,
false, 7, 0 }} },
4257 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1,
true, 8, 0 }} },
4258 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1,
true, 8, 0 }} },
4259 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1,
false, 7, 0 }} },
4260 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1,
false, 6, 0 }} },
4261 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2,
true, 8, 0 }} },
4262 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1,
false, 6, 0 }} },
4263 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1,
false, 5, 0 }} },
4264 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0,
false, 10, 0 }} },
4265 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0,
false, 10, 0 }} },
4266 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1,
false, 5, 0 }} },
4267 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0,
false, 10, 0 }} },
4268 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0,
false, 10, 0 }} },
4269 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2,
false, 6, 0 }} },
4270 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1,
false, 6, 2 }} },
4271 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2,
false, 3, 0 }} },
4272 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2,
false, 6, 0 }} },
4273 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2,
false, 6, 0 }} },
4274 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1,
false, 6, 0 }} },
4275 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2,
false, 6, 0 }} },
4276 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2,
false, 6, 0 }} },
4277 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2,
false, 6, 0 }} },
4278 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2,
false, 5, 0 }} },
4279 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2,
false, 5, 0 }} },
4280 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1,
false, 5, 0 }} },
4281 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2,
false, 5, 0 }} },
4282 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2,
false, 5, 0 }} },
4283 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1,
false, 5, 0 }} },
4284 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2,
false, 5, 0 }} },
4285 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1,
false, 4, 0 }} },
4286 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1,
false, 5, 0 }} },
4287 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2,
false, 6, 0 }} },
4288 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2,
false, 6, 0 }} },
4289 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1,
false, 6, 0 }} },
4290 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2,
false, 6, 0 }} },
4291 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2,
false, 6, 0 }} },
4292 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
4293 {{ 1,
false, 6, 0 }} },
4294 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1,
false, 6, 0 }} },
4295 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2,
false, 5, 0 }} },
4296 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2,
false, 5, 0 }} },
4297 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1,
false, 5, 0 }} },
4298 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2,
false, 5, 0 }} },
4299 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2,
false, 5, 0 }} },
4300 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
4301 {{ 1,
false, 5, 0 }} },
4302 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1,
false, 5, 0 }} },
4303 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1,
false, 5, 0 }} },
4304 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1,
false, 4, 0 }} },
4305 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1,
false, 5, 0 }} },
4306 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1,
false, 5, 0 }} },
4307 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1,
false, 5, 0 },
4308 { 2,
false, 5, 0 }} },
4309 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1,
false, 6, 0 },
4310 { 2,
false, 6, 0 }} },
4311 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2,
false, 5, 0 },
4312 { 3,
false, 5, 0 }} },
4313 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2,
false, 6, 0 },
4314 { 3,
false, 6, 0 }} },
4315 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2,
false, 6, 0 }} },
4316 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2,
false, 6, 0 }} },
4317 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1,
false, 6, 0 }} },
4318 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2,
false, 6, 0 }} },
4319 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2,
false, 6, 0 }} },
4320 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2,
false, 6, 0 }} },
4321 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2,
false, 5, 0 }} },
4322 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2,
false, 5, 0 }} },
4323 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1,
false, 5, 0 }} },
4324 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2,
false, 5, 0 }} },
4325 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2,
false, 5, 0 }} },
4326 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2,
false, 5, 0 }} },
4327 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1,
false, 4, 0 }} },
4328 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1,
false, 5, 0 }} },
4329 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1,
false, 5, 0 }} },
4330 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
4331 {{ 2,
false, 4, 0 },
4332 { 3,
false, 5, 0 }} },
4333 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
4334 {{ 2,
false, 4, 0 },
4335 { 3,
false, 5, 0 }} },
4336 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
4337 {{ 2,
false, 4, 0 },
4338 { 3,
false, 5, 0 }} },
4339 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
4340 {{ 2,
false, 4, 0 },
4341 { 3,
false, 5, 0 }} },
4342 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1,
false, 5, 0 }} },
4343 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1,
false, 5, 0 }} },
4344 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2,
false, 3, 0 }} },
4345 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2,
false, 3, 0 }} },
4346 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2,
false, 5, 0 }} },
4347 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2,
false, 5, 0 }} },
4348 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2,
false, 5, 0 }} },
4349 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2,
false, 5, 0 }} },
4350 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1,
true , 6, 0 }} },
4351 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1,
true, 6, 0 }} },
4352 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1,
false, 5, 0 },
4353 { 2,
false, 5, 0 }} },
4354 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1,
false, 6, 0 },
4355 { 2,
false, 6, 0 }} },
4356 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0,
true, 6, 0 }} },
4357 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1,
false, 5, 0 }} },
4358 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2,
false, 5, 0 }} },
4359 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2,
false, 5, 0 }} },
4360 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2,
false, 5, 0 }} },
4361 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2,
false, 5, 0 }} },
4362 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3,
false, 2, 0 }} },
4363 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2,
false, 2, 0 }} },
4364 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
4365 {{ 1,
false, 4, 0 }} },
4366 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1,
false, 4, 0 }} },
4367 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
4368 {{ 1,
false, 4, 0 }} },
4369 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1,
false, 6, 0 }} },
4370 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2,
false, 6, 0 }} },
4371 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2,
false, 6, 0 }} },
4372 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2,
false, 6, 0 }} },
4373 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2,
false, 6, 0 }} },
4374 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2,
false, 6, 0 }} },
4375 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1,
false, 5, 0 }} },
4376 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2,
false, 5, 0 }} },
4377 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2,
false, 5, 0 }} },
4378 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2,
false, 5, 0 }} },
4379 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2,
false, 5, 0 }} },
4380 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2,
false, 5, 0 }} },
4381 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2,
false, 3, 0 }} },
4382 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2,
false, 3, 0 }} },
4383 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2,
false, 3, 0 }} },
4384 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2,
false, 3, 0 }} },
4385 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2,
false, 1, 0 }} },
4386 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2,
false, 1, 0 }} },
4387 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3,
false, 1, 0 }} },
4388 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
4389 {{ 3,
false, 1, 0 }} },
4390 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2,
false, 1, 0 }} },
4391 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2,
false, 1, 0 }} },
4392 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3,
false, 1, 0 }} },
4393 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
4394 {{ 3,
false, 1, 0 }} },
4395 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2,
false, 1, 0 }} },
4396 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2,
false, 1, 0 }} },
4397 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3,
false, 1, 0 }} },
4398 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
4399 {{ 3,
false, 1, 0 }} },
4401 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2,
false, 2, 0 }} },
4402 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
4403 {{ 2,
false, 2, 0 }} },
4404 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
4405 {{ 3,
false, 2, 0 }} },
4406 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
4407 {{ 3,
false, 2, 0 }} },
4408 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2,
false, 2, 0 }} },
4409 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
4410 {{ 2,
false, 2, 0 }} },
4411 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
4412 {{ 3,
false, 2, 0 }} },
4413 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
4414 {{ 3,
false, 2, 0 }} },
4415 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2,
false, 3, 0 }} },
4416 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2,
false, 3, 0 }} },
4417 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3,
false, 3, 0 }} },
4418 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
4419 {{ 3,
false, 3, 0 }} },
4420 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2,
false, 3, 0 }} },
4421 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2,
false, 3, 0 }} },
4422 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3,
false, 3, 0 }} },
4423 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
4424 {{ 3,
false, 3, 0 }} },
4429 static const bool SortOnce =
4432 return LHS.BuiltinID < RHS.BuiltinID;
4438 Infos, [=](
const BuiltinInfo &BI) {
return BI.BuiltinID < BuiltinID; });
4439 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
4444 for (
const ArgInfo &A : F->Infos) {
4446 if (A.BitWidth == 0)
4449 int32_t
Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
4450 int32_t
Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
4452 Error |= BuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4454 unsigned M = 1 << A.Align;
4457 Error |= BuiltinConstantArgRange(TheCall, A.OpNum,
Min,
Max);
4458 Error |= BuiltinConstantArgMultiple(TheCall, A.OpNum, M);
4464bool Sema::CheckHexagonBuiltinFunctionCall(
unsigned BuiltinID,
4466 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
4469bool Sema::CheckLoongArchBuiltinFunctionCall(
const TargetInfo &TI,
4472 switch (BuiltinID) {
4476 case LoongArch::BI__builtin_loongarch_cacop_d:
4477 case LoongArch::BI__builtin_loongarch_cacop_w: {
4478 BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
4479 BuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12), llvm::maxIntN(12));
4482 case LoongArch::BI__builtin_loongarch_break:
4483 case LoongArch::BI__builtin_loongarch_dbar:
4484 case LoongArch::BI__builtin_loongarch_ibar:
4485 case LoongArch::BI__builtin_loongarch_syscall:
4487 return BuiltinConstantArgRange(TheCall, 0, 0, 32767);
4488 case LoongArch::BI__builtin_loongarch_csrrd_w:
4489 case LoongArch::BI__builtin_loongarch_csrrd_d:
4490 return BuiltinConstantArgRange(TheCall, 0, 0, 16383);
4491 case LoongArch::BI__builtin_loongarch_csrwr_w:
4492 case LoongArch::BI__builtin_loongarch_csrwr_d:
4493 return BuiltinConstantArgRange(TheCall, 1, 0, 16383);
4494 case LoongArch::BI__builtin_loongarch_csrxchg_w:
4495 case LoongArch::BI__builtin_loongarch_csrxchg_d:
4496 return BuiltinConstantArgRange(TheCall, 2, 0, 16383);
4497 case LoongArch::BI__builtin_loongarch_lddir_d:
4498 case LoongArch::BI__builtin_loongarch_ldpte_d:
4499 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4500 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
4501 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
4502 return BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
4505 case LoongArch::BI__builtin_lsx_vbitclri_b:
4506 case LoongArch::BI__builtin_lsx_vbitrevi_b:
4507 case LoongArch::BI__builtin_lsx_vbitseti_b:
4508 case LoongArch::BI__builtin_lsx_vsat_b:
4509 case LoongArch::BI__builtin_lsx_vsat_bu:
4510 case LoongArch::BI__builtin_lsx_vslli_b:
4511 case LoongArch::BI__builtin_lsx_vsrai_b:
4512 case LoongArch::BI__builtin_lsx_vsrari_b:
4513 case LoongArch::BI__builtin_lsx_vsrli_b:
4514 case LoongArch::BI__builtin_lsx_vsllwil_h_b:
4515 case LoongArch::BI__builtin_lsx_vsllwil_hu_bu:
4516 case LoongArch::BI__builtin_lsx_vrotri_b:
4517 case LoongArch::BI__builtin_lsx_vsrlri_b:
4518 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4519 case LoongArch::BI__builtin_lsx_vbitclri_h:
4520 case LoongArch::BI__builtin_lsx_vbitrevi_h:
4521 case LoongArch::BI__builtin_lsx_vbitseti_h:
4522 case LoongArch::BI__builtin_lsx_vsat_h:
4523 case LoongArch::BI__builtin_lsx_vsat_hu:
4524 case LoongArch::BI__builtin_lsx_vslli_h:
4525 case LoongArch::BI__builtin_lsx_vsrai_h:
4526 case LoongArch::BI__builtin_lsx_vsrari_h:
4527 case LoongArch::BI__builtin_lsx_vsrli_h:
4528 case LoongArch::BI__builtin_lsx_vsllwil_w_h:
4529 case LoongArch::BI__builtin_lsx_vsllwil_wu_hu:
4530 case LoongArch::BI__builtin_lsx_vrotri_h:
4531 case LoongArch::BI__builtin_lsx_vsrlri_h:
4532 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4533 case LoongArch::BI__builtin_lsx_vssrarni_b_h:
4534 case LoongArch::BI__builtin_lsx_vssrarni_bu_h:
4535 case LoongArch::BI__builtin_lsx_vssrani_b_h:
4536 case LoongArch::BI__builtin_lsx_vssrani_bu_h:
4537 case LoongArch::BI__builtin_lsx_vsrarni_b_h:
4538 case LoongArch::BI__builtin_lsx_vsrlni_b_h:
4539 case LoongArch::BI__builtin_lsx_vsrlrni_b_h:
4540 case LoongArch::BI__builtin_lsx_vssrlni_b_h:
4541 case LoongArch::BI__builtin_lsx_vssrlni_bu_h:
4542 case LoongArch::BI__builtin_lsx_vssrlrni_b_h:
4543 case LoongArch::BI__builtin_lsx_vssrlrni_bu_h:
4544 case LoongArch::BI__builtin_lsx_vsrani_b_h:
4545 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4546 case LoongArch::BI__builtin_lsx_vslei_bu:
4547 case LoongArch::BI__builtin_lsx_vslei_hu:
4548 case LoongArch::BI__builtin_lsx_vslei_wu:
4549 case LoongArch::BI__builtin_lsx_vslei_du:
4550 case LoongArch::BI__builtin_lsx_vslti_bu:
4551 case LoongArch::BI__builtin_lsx_vslti_hu:
4552 case LoongArch::BI__builtin_lsx_vslti_wu:
4553 case LoongArch::BI__builtin_lsx_vslti_du:
4554 case LoongArch::BI__builtin_lsx_vmaxi_bu:
4555 case LoongArch::BI__builtin_lsx_vmaxi_hu:
4556 case LoongArch::BI__builtin_lsx_vmaxi_wu:
4557 case LoongArch::BI__builtin_lsx_vmaxi_du:
4558 case LoongArch::BI__builtin_lsx_vmini_bu:
4559 case LoongArch::BI__builtin_lsx_vmini_hu:
4560 case LoongArch::BI__builtin_lsx_vmini_wu:
4561 case LoongArch::BI__builtin_lsx_vmini_du:
4562 case LoongArch::BI__builtin_lsx_vaddi_bu:
4563 case LoongArch::BI__builtin_lsx_vaddi_hu:
4564 case LoongArch::BI__builtin_lsx_vaddi_wu:
4565 case LoongArch::BI__builtin_lsx_vaddi_du:
4566 case LoongArch::BI__builtin_lsx_vbitclri_w:
4567 case LoongArch::BI__builtin_lsx_vbitrevi_w:
4568 case LoongArch::BI__builtin_lsx_vbitseti_w:
4569 case LoongArch::BI__builtin_lsx_vsat_w:
4570 case LoongArch::BI__builtin_lsx_vsat_wu:
4571 case LoongArch::BI__builtin_lsx_vslli_w:
4572 case LoongArch::BI__builtin_lsx_vsrai_w:
4573 case LoongArch::BI__builtin_lsx_vsrari_w:
4574 case LoongArch::BI__builtin_lsx_vsrli_w:
4575 case LoongArch::BI__builtin_lsx_vsllwil_d_w:
4576 case LoongArch::BI__builtin_lsx_vsllwil_du_wu:
4577 case LoongArch::BI__builtin_lsx_vsrlri_w:
4578 case LoongArch::BI__builtin_lsx_vrotri_w:
4579 case LoongArch::BI__builtin_lsx_vsubi_bu:
4580 case LoongArch::BI__builtin_lsx_vsubi_hu:
4581 case LoongArch::BI__builtin_lsx_vbsrl_v:
4582 case LoongArch::BI__builtin_lsx_vbsll_v:
4583 case LoongArch::BI__builtin_lsx_vsubi_wu:
4584 case LoongArch::BI__builtin_lsx_vsubi_du:
4585 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4586 case LoongArch::BI__builtin_lsx_vssrarni_h_w:
4587 case LoongArch::BI__builtin_lsx_vssrarni_hu_w:
4588 case LoongArch::BI__builtin_lsx_vssrani_h_w:
4589 case LoongArch::BI__builtin_lsx_vssrani_hu_w:
4590 case LoongArch::BI__builtin_lsx_vsrarni_h_w:
4591 case LoongArch::BI__builtin_lsx_vsrani_h_w:
4592 case LoongArch::BI__builtin_lsx_vfrstpi_b:
4593 case LoongArch::BI__builtin_lsx_vfrstpi_h:
4594 case LoongArch::BI__builtin_lsx_vsrlni_h_w:
4595 case LoongArch::BI__builtin_lsx_vsrlrni_h_w:
4596 case LoongArch::BI__builtin_lsx_vssrlni_h_w:
4597 case LoongArch::BI__builtin_lsx_vssrlni_hu_w:
4598 case LoongArch::BI__builtin_lsx_vssrlrni_h_w:
4599 case LoongArch::BI__builtin_lsx_vssrlrni_hu_w:
4600 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4601 case LoongArch::BI__builtin_lsx_vbitclri_d:
4602 case LoongArch::BI__builtin_lsx_vbitrevi_d:
4603 case LoongArch::BI__builtin_lsx_vbitseti_d:
4604 case LoongArch::BI__builtin_lsx_vsat_d:
4605 case LoongArch::BI__builtin_lsx_vsat_du:
4606 case LoongArch::BI__builtin_lsx_vslli_d:
4607 case LoongArch::BI__builtin_lsx_vsrai_d:
4608 case LoongArch::BI__builtin_lsx_vsrli_d:
4609 case LoongArch::BI__builtin_lsx_vsrari_d:
4610 case LoongArch::BI__builtin_lsx_vrotri_d:
4611 case LoongArch::BI__builtin_lsx_vsrlri_d:
4612 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4613 case LoongArch::BI__builtin_lsx_vssrarni_w_d:
4614 case LoongArch::BI__builtin_lsx_vssrarni_wu_d:
4615 case LoongArch::BI__builtin_lsx_vssrani_w_d:
4616 case LoongArch::BI__builtin_lsx_vssrani_wu_d:
4617 case LoongArch::BI__builtin_lsx_vsrarni_w_d:
4618 case LoongArch::BI__builtin_lsx_vsrlni_w_d:
4619 case LoongArch::BI__builtin_lsx_vsrlrni_w_d:
4620 case LoongArch::BI__builtin_lsx_vssrlni_w_d:
4621 case LoongArch::BI__builtin_lsx_vssrlni_wu_d:
4622 case LoongArch::BI__builtin_lsx_vssrlrni_w_d:
4623 case LoongArch::BI__builtin_lsx_vssrlrni_wu_d:
4624 case LoongArch::BI__builtin_lsx_vsrani_w_d:
4625 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4626 case LoongArch::BI__builtin_lsx_vssrarni_d_q:
4627 case LoongArch::BI__builtin_lsx_vssrarni_du_q:
4628 case LoongArch::BI__builtin_lsx_vssrani_d_q:
4629 case LoongArch::BI__builtin_lsx_vssrani_du_q:
4630 case LoongArch::BI__builtin_lsx_vsrarni_d_q:
4631 case LoongArch::BI__builtin_lsx_vssrlni_d_q:
4632 case LoongArch::BI__builtin_lsx_vssrlni_du_q:
4633 case LoongArch::BI__builtin_lsx_vssrlrni_d_q:
4634 case LoongArch::BI__builtin_lsx_vssrlrni_du_q:
4635 case LoongArch::BI__builtin_lsx_vsrani_d_q:
4636 case LoongArch::BI__builtin_lsx_vsrlrni_d_q:
4637 case LoongArch::BI__builtin_lsx_vsrlni_d_q:
4638 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4639 case LoongArch::BI__builtin_lsx_vseqi_b:
4640 case LoongArch::BI__builtin_lsx_vseqi_h:
4641 case LoongArch::BI__builtin_lsx_vseqi_w:
4642 case LoongArch::BI__builtin_lsx_vseqi_d:
4643 case LoongArch::BI__builtin_lsx_vslti_b:
4644 case LoongArch::BI__builtin_lsx_vslti_h:
4645 case LoongArch::BI__builtin_lsx_vslti_w:
4646 case LoongArch::BI__builtin_lsx_vslti_d:
4647 case LoongArch::BI__builtin_lsx_vslei_b:
4648 case LoongArch::BI__builtin_lsx_vslei_h:
4649 case LoongArch::BI__builtin_lsx_vslei_w:
4650 case LoongArch::BI__builtin_lsx_vslei_d:
4651 case LoongArch::BI__builtin_lsx_vmaxi_b:
4652 case LoongArch::BI__builtin_lsx_vmaxi_h:
4653 case LoongArch::BI__builtin_lsx_vmaxi_w:
4654 case LoongArch::BI__builtin_lsx_vmaxi_d:
4655 case LoongArch::BI__builtin_lsx_vmini_b:
4656 case LoongArch::BI__builtin_lsx_vmini_h:
4657 case LoongArch::BI__builtin_lsx_vmini_w:
4658 case LoongArch::BI__builtin_lsx_vmini_d:
4659 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4660 case LoongArch::BI__builtin_lsx_vandi_b:
4661 case LoongArch::BI__builtin_lsx_vnori_b:
4662 case LoongArch::BI__builtin_lsx_vori_b:
4663 case LoongArch::BI__builtin_lsx_vshuf4i_b:
4664 case LoongArch::BI__builtin_lsx_vshuf4i_h:
4665 case LoongArch::BI__builtin_lsx_vshuf4i_w:
4666 case LoongArch::BI__builtin_lsx_vxori_b:
4667 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4668 case LoongArch::BI__builtin_lsx_vbitseli_b:
4669 case LoongArch::BI__builtin_lsx_vshuf4i_d:
4670 case LoongArch::BI__builtin_lsx_vextrins_b:
4671 case LoongArch::BI__builtin_lsx_vextrins_h:
4672 case LoongArch::BI__builtin_lsx_vextrins_w:
4673 case LoongArch::BI__builtin_lsx_vextrins_d:
4674 case LoongArch::BI__builtin_lsx_vpermi_w:
4675 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4676 case LoongArch::BI__builtin_lsx_vpickve2gr_b:
4677 case LoongArch::BI__builtin_lsx_vpickve2gr_bu:
4678 case LoongArch::BI__builtin_lsx_vreplvei_b:
4679 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4680 case LoongArch::BI__builtin_lsx_vinsgr2vr_b:
4681 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4682 case LoongArch::BI__builtin_lsx_vpickve2gr_h:
4683 case LoongArch::BI__builtin_lsx_vpickve2gr_hu:
4684 case LoongArch::BI__builtin_lsx_vreplvei_h:
4685 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4686 case LoongArch::BI__builtin_lsx_vinsgr2vr_h:
4687 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4688 case LoongArch::BI__builtin_lsx_vpickve2gr_w:
4689 case LoongArch::BI__builtin_lsx_vpickve2gr_wu:
4690 case LoongArch::BI__builtin_lsx_vreplvei_w:
4691 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4692 case LoongArch::BI__builtin_lsx_vinsgr2vr_w:
4693 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4694 case LoongArch::BI__builtin_lsx_vpickve2gr_d:
4695 case LoongArch::BI__builtin_lsx_vpickve2gr_du:
4696 case LoongArch::BI__builtin_lsx_vreplvei_d:
4697 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4698 case LoongArch::BI__builtin_lsx_vinsgr2vr_d:
4699 return BuiltinConstantArgRange(TheCall, 2, 0, 1);
4700 case LoongArch::BI__builtin_lsx_vstelm_b:
4701 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4702 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4703 case LoongArch::BI__builtin_lsx_vstelm_h:
4704 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4705 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4706 case LoongArch::BI__builtin_lsx_vstelm_w:
4707 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4708 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4709 case LoongArch::BI__builtin_lsx_vstelm_d:
4710 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4711 BuiltinConstantArgRange(TheCall, 3, 0, 1);
4712 case LoongArch::BI__builtin_lsx_vldrepl_b:
4713 case LoongArch::BI__builtin_lsx_vld:
4714 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4715 case LoongArch::BI__builtin_lsx_vldrepl_h:
4716 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4717 case LoongArch::BI__builtin_lsx_vldrepl_w:
4718 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4719 case LoongArch::BI__builtin_lsx_vldrepl_d:
4720 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4721 case LoongArch::BI__builtin_lsx_vst:
4722 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4723 case LoongArch::BI__builtin_lsx_vldi:
4724 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4725 case LoongArch::BI__builtin_lsx_vrepli_b:
4726 case LoongArch::BI__builtin_lsx_vrepli_h:
4727 case LoongArch::BI__builtin_lsx_vrepli_w:
4728 case LoongArch::BI__builtin_lsx_vrepli_d:
4729 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4732 case LoongArch::BI__builtin_lasx_xvbitclri_b:
4733 case LoongArch::BI__builtin_lasx_xvbitrevi_b:
4734 case LoongArch::BI__builtin_lasx_xvbitseti_b:
4735 case LoongArch::BI__builtin_lasx_xvsat_b:
4736 case LoongArch::BI__builtin_lasx_xvsat_bu:
4737 case LoongArch::BI__builtin_lasx_xvslli_b:
4738 case LoongArch::BI__builtin_lasx_xvsrai_b:
4739 case LoongArch::BI__builtin_lasx_xvsrari_b:
4740 case LoongArch::BI__builtin_lasx_xvsrli_b:
4741 case LoongArch::BI__builtin_lasx_xvsllwil_h_b:
4742 case LoongArch::BI__builtin_lasx_xvsllwil_hu_bu:
4743 case LoongArch::BI__builtin_lasx_xvrotri_b:
4744 case LoongArch::BI__builtin_lasx_xvsrlri_b:
4745 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4746 case LoongArch::BI__builtin_lasx_xvbitclri_h:
4747 case LoongArch::BI__builtin_lasx_xvbitrevi_h:
4748 case LoongArch::BI__builtin_lasx_xvbitseti_h:
4749 case LoongArch::BI__builtin_lasx_xvsat_h:
4750 case LoongArch::BI__builtin_lasx_xvsat_hu:
4751 case LoongArch::BI__builtin_lasx_xvslli_h:
4752 case LoongArch::BI__builtin_lasx_xvsrai_h:
4753 case LoongArch::BI__builtin_lasx_xvsrari_h:
4754 case LoongArch::BI__builtin_lasx_xvsrli_h:
4755 case LoongArch::BI__builtin_lasx_xvsllwil_w_h:
4756 case LoongArch::BI__builtin_lasx_xvsllwil_wu_hu:
4757 case LoongArch::BI__builtin_lasx_xvrotri_h:
4758 case LoongArch::BI__builtin_lasx_xvsrlri_h:
4759 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4760 case LoongArch::BI__builtin_lasx_xvssrarni_b_h:
4761 case LoongArch::BI__builtin_lasx_xvssrarni_bu_h:
4762 case LoongArch::BI__builtin_lasx_xvssrani_b_h:
4763 case LoongArch::BI__builtin_lasx_xvssrani_bu_h:
4764 case LoongArch::BI__builtin_lasx_xvsrarni_b_h:
4765 case LoongArch::BI__builtin_lasx_xvsrlni_b_h:
4766 case LoongArch::BI__builtin_lasx_xvsrlrni_b_h:
4767 case LoongArch::BI__builtin_lasx_xvssrlni_b_h:
4768 case LoongArch::BI__builtin_lasx_xvssrlni_bu_h:
4769 case LoongArch::BI__builtin_lasx_xvssrlrni_b_h:
4770 case LoongArch::BI__builtin_lasx_xvssrlrni_bu_h:
4771 case LoongArch::BI__builtin_lasx_xvsrani_b_h:
4772 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4773 case LoongArch::BI__builtin_lasx_xvslei_bu:
4774 case LoongArch::BI__builtin_lasx_xvslei_hu:
4775 case LoongArch::BI__builtin_lasx_xvslei_wu:
4776 case LoongArch::BI__builtin_lasx_xvslei_du:
4777 case LoongArch::BI__builtin_lasx_xvslti_bu:
4778 case LoongArch::BI__builtin_lasx_xvslti_hu:
4779 case LoongArch::BI__builtin_lasx_xvslti_wu:
4780 case LoongArch::BI__builtin_lasx_xvslti_du:
4781 case LoongArch::BI__builtin_lasx_xvmaxi_bu:
4782 case LoongArch::BI__builtin_lasx_xvmaxi_hu:
4783 case LoongArch::BI__builtin_lasx_xvmaxi_wu:
4784 case LoongArch::BI__builtin_lasx_xvmaxi_du:
4785 case LoongArch::BI__builtin_lasx_xvmini_bu:
4786 case LoongArch::BI__builtin_lasx_xvmini_hu:
4787 case LoongArch::BI__builtin_lasx_xvmini_wu:
4788 case LoongArch::BI__builtin_lasx_xvmini_du:
4789 case LoongArch::BI__builtin_lasx_xvaddi_bu:
4790 case LoongArch::BI__builtin_lasx_xvaddi_hu:
4791 case LoongArch::BI__builtin_lasx_xvaddi_wu:
4792 case LoongArch::BI__builtin_lasx_xvaddi_du:
4793 case LoongArch::BI__builtin_lasx_xvbitclri_w:
4794 case LoongArch::BI__builtin_lasx_xvbitrevi_w:
4795 case LoongArch::BI__builtin_lasx_xvbitseti_w:
4796 case LoongArch::BI__builtin_lasx_xvsat_w:
4797 case LoongArch::BI__builtin_lasx_xvsat_wu:
4798 case LoongArch::BI__builtin_lasx_xvslli_w:
4799 case LoongArch::BI__builtin_lasx_xvsrai_w:
4800 case LoongArch::BI__builtin_lasx_xvsrari_w:
4801 case LoongArch::BI__builtin_lasx_xvsrli_w:
4802 case LoongArch::BI__builtin_lasx_xvsllwil_d_w:
4803 case LoongArch::BI__builtin_lasx_xvsllwil_du_wu:
4804 case LoongArch::BI__builtin_lasx_xvsrlri_w:
4805 case LoongArch::BI__builtin_lasx_xvrotri_w:
4806 case LoongArch::BI__builtin_lasx_xvsubi_bu:
4807 case LoongArch::BI__builtin_lasx_xvsubi_hu:
4808 case LoongArch::BI__builtin_lasx_xvsubi_wu:
4809 case LoongArch::BI__builtin_lasx_xvsubi_du:
4810 case LoongArch::BI__builtin_lasx_xvbsrl_v:
4811 case LoongArch::BI__builtin_lasx_xvbsll_v:
4812 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4813 case LoongArch::BI__builtin_lasx_xvssrarni_h_w:
4814 case LoongArch::BI__builtin_lasx_xvssrarni_hu_w:
4815 case LoongArch::BI__builtin_lasx_xvssrani_h_w:
4816 case LoongArch::BI__builtin_lasx_xvssrani_hu_w:
4817 case LoongArch::BI__builtin_lasx_xvsrarni_h_w:
4818 case LoongArch::BI__builtin_lasx_xvsrani_h_w:
4819 case LoongArch::BI__builtin_lasx_xvfrstpi_b:
4820 case LoongArch::BI__builtin_lasx_xvfrstpi_h:
4821 case LoongArch::BI__builtin_lasx_xvsrlni_h_w:
4822 case LoongArch::BI__builtin_lasx_xvsrlrni_h_w:
4823 case LoongArch::BI__builtin_lasx_xvssrlni_h_w:
4824 case LoongArch::BI__builtin_lasx_xvssrlni_hu_w:
4825 case LoongArch::BI__builtin_lasx_xvssrlrni_h_w:
4826 case LoongArch::BI__builtin_lasx_xvssrlrni_hu_w:
4827 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4828 case LoongArch::BI__builtin_lasx_xvbitclri_d:
4829 case LoongArch::BI__builtin_lasx_xvbitrevi_d:
4830 case LoongArch::BI__builtin_lasx_xvbitseti_d:
4831 case LoongArch::BI__builtin_lasx_xvsat_d:
4832 case LoongArch::BI__builtin_lasx_xvsat_du:
4833 case LoongArch::BI__builtin_lasx_xvslli_d:
4834 case LoongArch::BI__builtin_lasx_xvsrai_d:
4835 case LoongArch::BI__builtin_lasx_xvsrli_d:
4836 case LoongArch::BI__builtin_lasx_xvsrari_d:
4837 case LoongArch::BI__builtin_lasx_xvrotri_d:
4838 case LoongArch::BI__builtin_lasx_xvsrlri_d:
4839 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4840 case LoongArch::BI__builtin_lasx_xvssrarni_w_d:
4841 case LoongArch::BI__builtin_lasx_xvssrarni_wu_d:
4842 case LoongArch::BI__builtin_lasx_xvssrani_w_d:
4843 case LoongArch::BI__builtin_lasx_xvssrani_wu_d:
4844 case LoongArch::BI__builtin_lasx_xvsrarni_w_d:
4845 case LoongArch::BI__builtin_lasx_xvsrlni_w_d:
4846 case LoongArch::BI__builtin_lasx_xvsrlrni_w_d:
4847 case LoongArch::BI__builtin_lasx_xvssrlni_w_d:
4848 case LoongArch::BI__builtin_lasx_xvssrlni_wu_d:
4849 case LoongArch::BI__builtin_lasx_xvssrlrni_w_d:
4850 case LoongArch::BI__builtin_lasx_xvssrlrni_wu_d:
4851 case LoongArch::BI__builtin_lasx_xvsrani_w_d:
4852 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4853 case LoongArch::BI__builtin_lasx_xvssrarni_d_q:
4854 case LoongArch::BI__builtin_lasx_xvssrarni_du_q:
4855 case LoongArch::BI__builtin_lasx_xvssrani_d_q:
4856 case LoongArch::BI__builtin_lasx_xvssrani_du_q:
4857 case LoongArch::BI__builtin_lasx_xvsrarni_d_q:
4858 case LoongArch::BI__builtin_lasx_xvssrlni_d_q:
4859 case LoongArch::BI__builtin_lasx_xvssrlni_du_q:
4860 case LoongArch::BI__builtin_lasx_xvssrlrni_d_q:
4861 case LoongArch::BI__builtin_lasx_xvssrlrni_du_q:
4862 case LoongArch::BI__builtin_lasx_xvsrani_d_q:
4863 case LoongArch::BI__builtin_lasx_xvsrlni_d_q:
4864 case LoongArch::BI__builtin_lasx_xvsrlrni_d_q:
4865 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4866 case LoongArch::BI__builtin_lasx_xvseqi_b:
4867 case LoongArch::BI__builtin_lasx_xvseqi_h:
4868 case LoongArch::BI__builtin_lasx_xvseqi_w:
4869 case LoongArch::BI__builtin_lasx_xvseqi_d:
4870 case LoongArch::BI__builtin_lasx_xvslti_b:
4871 case LoongArch::BI__builtin_lasx_xvslti_h:
4872 case LoongArch::BI__builtin_lasx_xvslti_w:
4873 case LoongArch::BI__builtin_lasx_xvslti_d:
4874 case LoongArch::BI__builtin_lasx_xvslei_b:
4875 case LoongArch::BI__builtin_lasx_xvslei_h:
4876 case LoongArch::BI__builtin_lasx_xvslei_w:
4877 case LoongArch::BI__builtin_lasx_xvslei_d:
4878 case LoongArch::BI__builtin_lasx_xvmaxi_b:
4879 case LoongArch::BI__builtin_lasx_xvmaxi_h:
4880 case LoongArch::BI__builtin_lasx_xvmaxi_w:
4881 case LoongArch::BI__builtin_lasx_xvmaxi_d:
4882 case LoongArch::BI__builtin_lasx_xvmini_b:
4883 case LoongArch::BI__builtin_lasx_xvmini_h:
4884 case LoongArch::BI__builtin_lasx_xvmini_w:
4885 case LoongArch::BI__builtin_lasx_xvmini_d:
4886 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4887 case LoongArch::BI__builtin_lasx_xvandi_b:
4888 case LoongArch::BI__builtin_lasx_xvnori_b:
4889 case LoongArch::BI__builtin_lasx_xvori_b:
4890 case LoongArch::BI__builtin_lasx_xvshuf4i_b:
4891 case LoongArch::BI__builtin_lasx_xvshuf4i_h:
4892 case LoongArch::BI__builtin_lasx_xvshuf4i_w:
4893 case LoongArch::BI__builtin_lasx_xvxori_b:
4894 case LoongArch::BI__builtin_lasx_xvpermi_d:
4895 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4896 case LoongArch::BI__builtin_lasx_xvbitseli_b:
4897 case LoongArch::BI__builtin_lasx_xvshuf4i_d:
4898 case LoongArch::BI__builtin_lasx_xvextrins_b:
4899 case LoongArch::BI__builtin_lasx_xvextrins_h:
4900 case LoongArch::BI__builtin_lasx_xvextrins_w:
4901 case LoongArch::BI__builtin_lasx_xvextrins_d:
4902 case LoongArch::BI__builtin_lasx_xvpermi_q:
4903 case LoongArch::BI__builtin_lasx_xvpermi_w:
4904 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4905 case LoongArch::BI__builtin_lasx_xvrepl128vei_b:
4906 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4907 case LoongArch::BI__builtin_lasx_xvrepl128vei_h:
4908 case LoongArch::BI__builtin_lasx_xvpickve2gr_w:
4909 case LoongArch::BI__builtin_lasx_xvpickve2gr_wu:
4910 case LoongArch::BI__builtin_lasx_xvpickve_w_f:
4911 case LoongArch::BI__builtin_lasx_xvpickve_w:
4912 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4913 case LoongArch::BI__builtin_lasx_xvinsgr2vr_w:
4914 case LoongArch::BI__builtin_lasx_xvinsve0_w:
4915 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4916 case LoongArch::BI__builtin_lasx_xvrepl128vei_w:
4917 case LoongArch::BI__builtin_lasx_xvpickve2gr_d:
4918 case LoongArch::BI__builtin_lasx_xvpickve2gr_du:
4919 case LoongArch::BI__builtin_lasx_xvpickve_d_f:
4920 case LoongArch::BI__builtin_lasx_xvpickve_d:
4921 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4922 case LoongArch::BI__builtin_lasx_xvinsve0_d:
4923 case LoongArch::BI__builtin_lasx_xvinsgr2vr_d:
4924 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4925 case LoongArch::BI__builtin_lasx_xvstelm_b:
4926 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4927 BuiltinConstantArgRange(TheCall, 3, 0, 31);
4928 case LoongArch::BI__builtin_lasx_xvstelm_h:
4929 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4930 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4931 case LoongArch::BI__builtin_lasx_xvstelm_w:
4932 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4933 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4934 case LoongArch::BI__builtin_lasx_xvstelm_d:
4935 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4936 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4937 case LoongArch::BI__builtin_lasx_xvrepl128vei_d:
4938 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4939 case LoongArch::BI__builtin_lasx_xvldrepl_b:
4940 case LoongArch::BI__builtin_lasx_xvld:
4941 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4942 case LoongArch::BI__builtin_lasx_xvldrepl_h:
4943 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4944 case LoongArch::BI__builtin_lasx_xvldrepl_w:
4945 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4946 case LoongArch::BI__builtin_lasx_xvldrepl_d:
4947 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4948 case LoongArch::BI__builtin_lasx_xvst:
4949 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4950 case LoongArch::BI__builtin_lasx_xvldi:
4951 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4952 case LoongArch::BI__builtin_lasx_xvrepli_b:
4953 case LoongArch::BI__builtin_lasx_xvrepli_h:
4954 case LoongArch::BI__builtin_lasx_xvrepli_w:
4955 case LoongArch::BI__builtin_lasx_xvrepli_d:
4956 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4961bool Sema::CheckMipsBuiltinFunctionCall(
const TargetInfo &TI,
4962 unsigned BuiltinID,
CallExpr *TheCall) {
4963 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
4964 CheckMipsBuiltinArgument(BuiltinID, TheCall);
4967bool Sema::CheckMipsBuiltinCpu(
const TargetInfo &TI,
unsigned BuiltinID,
4970 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
4971 BuiltinID <= Mips::BI__builtin_mips_lwx) {
4973 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_dsp);
4976 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
4977 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
4980 diag::err_mips_builtin_requires_dspr2);
4983 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
4984 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
4986 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_msa);
5001bool Sema::CheckMipsBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
5002 unsigned i = 0, l = 0, u = 0, m = 0;
5003 switch (BuiltinID) {
5004 default:
return false;
5005 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63;
break;
5006 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63;
break;
5007 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31;
break;
5008 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3;
break;
5009 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31;
break;
5010 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31;
break;
5011 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31;
break;
5015 case Mips::BI__builtin_msa_bclri_b:
5016 case Mips::BI__builtin_msa_bnegi_b:
5017 case Mips::BI__builtin_msa_bseti_b:
5018 case Mips::BI__builtin_msa_sat_s_b:
5019 case Mips::BI__builtin_msa_sat_u_b:
5020 case Mips::BI__builtin_msa_slli_b:
5021 case Mips::BI__builtin_msa_srai_b:
5022 case Mips::BI__builtin_msa_srari_b:
5023 case Mips::BI__builtin_msa_srli_b:
5024 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7;
break;
5025 case Mips::BI__builtin_msa_binsli_b:
5026 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7;
break;
5028 case Mips::BI__builtin_msa_bclri_h:
5029 case Mips::BI__builtin_msa_bnegi_h:
5030 case Mips::BI__builtin_msa_bseti_h:
5031 case Mips::BI__builtin_msa_sat_s_h:
5032 case Mips::BI__builtin_msa_sat_u_h:
5033 case Mips::BI__builtin_msa_slli_h:
5034 case Mips::BI__builtin_msa_srai_h:
5035 case Mips::BI__builtin_msa_srari_h:
5036 case Mips::BI__builtin_msa_srli_h:
5037 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15;
break;
5038 case Mips::BI__builtin_msa_binsli_h:
5039 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15;
break;
5043 case Mips::BI__builtin_msa_cfcmsa:
5044 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31;
break;
5045 case Mips::BI__builtin_msa_clei_u_b:
5046 case Mips::BI__builtin_msa_clei_u_h:
5047 case Mips::BI__builtin_msa_clei_u_w:
5048 case Mips::BI__builtin_msa_clei_u_d:
5049 case Mips::BI__builtin_msa_clti_u_b:
5050 case Mips::BI__builtin_msa_clti_u_h:
5051 case Mips::BI__builtin_msa_clti_u_w:
5052 case Mips::BI__builtin_msa_clti_u_d:
5053 case Mips::BI__builtin_msa_maxi_u_b:
5054 case Mips::BI__builtin_msa_maxi_u_h:
5055 case Mips::BI__builtin_msa_maxi_u_w:
5056 case Mips::BI__builtin_msa_maxi_u_d:
5057 case Mips::BI__builtin_msa_mini_u_b:
5058 case Mips::BI__builtin_msa_mini_u_h:
5059 case Mips::BI__builtin_msa_mini_u_w:
5060 case Mips::BI__builtin_msa_mini_u_d:
5061 case Mips::BI__builtin_msa_addvi_b:
5062 case Mips::BI__builtin_msa_addvi_h:
5063 case Mips::BI__builtin_msa_addvi_w:
5064 case Mips::BI__builtin_msa_addvi_d:
5065 case Mips::BI__builtin_msa_bclri_w:
5066 case Mips::BI__builtin_msa_bnegi_w:
5067 case Mips::BI__builtin_msa_bseti_w:
5068 case Mips::BI__builtin_msa_sat_s_w:
5069 case Mips::BI__builtin_msa_sat_u_w:
5070 case Mips::BI__builtin_msa_slli_w:
5071 case Mips::BI__builtin_msa_srai_w:
5072 case Mips::BI__builtin_msa_srari_w:
5073 case Mips::BI__builtin_msa_srli_w:
5074 case Mips::BI__builtin_msa_srlri_w:
5075 case Mips::BI__builtin_msa_subvi_b:
5076 case Mips::BI__builtin_msa_subvi_h:
5077 case Mips::BI__builtin_msa_subvi_w:
5078 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31;
break;
5079 case Mips::BI__builtin_msa_binsli_w:
5080 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31;
break;
5082 case Mips::BI__builtin_msa_bclri_d:
5083 case Mips::BI__builtin_msa_bnegi_d:
5084 case Mips::BI__builtin_msa_bseti_d:
5085 case Mips::BI__builtin_msa_sat_s_d:
5086 case Mips::BI__builtin_msa_sat_u_d:
5087 case Mips::BI__builtin_msa_slli_d:
5088 case Mips::BI__builtin_msa_srai_d:
5089 case Mips::BI__builtin_msa_srari_d:
5090 case Mips::BI__builtin_msa_srli_d:
5091 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63;
break;
5092 case Mips::BI__builtin_msa_binsli_d:
5093 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63;
break;
5095 case Mips::BI__builtin_msa_ceqi_b:
5096 case Mips::BI__builtin_msa_ceqi_h:
5097 case Mips::BI__builtin_msa_ceqi_w:
5098 case Mips::BI__builtin_msa_ceqi_d:
5099 case Mips::BI__builtin_msa_clti_s_b:
5100 case Mips::BI__builtin_msa_clti_s_h:
5101 case Mips::BI__builtin_msa_clti_s_w:
5102 case Mips::BI__builtin_msa_clti_s_d:
5103 case Mips::BI__builtin_msa_clei_s_b:
5104 case Mips::BI__builtin_msa_clei_s_h:
5105 case Mips::BI__builtin_msa_clei_s_w:
5106 case Mips::BI__builtin_msa_clei_s_d:
5107 case Mips::BI__builtin_msa_maxi_s_b:
5108 case Mips::BI__builtin_msa_maxi_s_h:
5109 case Mips::BI__builtin_msa_maxi_s_w:
5110 case Mips::BI__builtin_msa_maxi_s_d:
5111 case Mips::BI__builtin_msa_mini_s_b:
5112 case Mips::BI__builtin_msa_mini_s_h:
5113 case Mips::BI__builtin_msa_mini_s_w:
5114 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15;
break;
5116 case Mips::BI__builtin_msa_andi_b:
5117 case Mips::BI__builtin_msa_nori_b:
5118 case Mips::BI__builtin_msa_ori_b:
5119 case Mips::BI__builtin_msa_shf_b:
5120 case Mips::BI__builtin_msa_shf_h:
5121 case Mips::BI__builtin_msa_shf_w:
5122 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255;
break;
5123 case Mips::BI__builtin_msa_bseli_b:
5124 case Mips::BI__builtin_msa_bmnzi_b:
5125 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255;
break;
5128 case Mips::BI__builtin_msa_copy_s_b:
5129 case Mips::BI__builtin_msa_copy_u_b:
5130 case Mips::BI__builtin_msa_insve_b:
5131 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15;
break;
5132 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15;
break;
5134 case Mips::BI__builtin_msa_copy_s_h:
5135 case Mips::BI__builtin_msa_copy_u_h:
5136 case Mips::BI__builtin_msa_insve_h:
5137 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7;
break;
5138 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7;
break;
5140 case Mips::BI__builtin_msa_copy_s_w:
5141 case Mips::BI__builtin_msa_copy_u_w:
5142 case Mips::BI__builtin_msa_insve_w:
5143 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3;
break;
5144 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3;
break;
5146 case Mips::BI__builtin_msa_copy_s_d:
5147 case Mips::BI__builtin_msa_copy_u_d:
5148 case Mips::BI__builtin_msa_insve_d:
5149 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1;
break;
5150 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1;
break;
5153 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255;
break;
5154 case Mips::BI__builtin_msa_ldi_h:
5155 case Mips::BI__builtin_msa_ldi_w:
5156 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511;
break;
5157 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1;
break;
5158 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2;
break;
5159 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5160 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5161 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5162 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5163 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1;
break;
5164 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2;
break;
5165 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5166 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5167 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5168 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5172 return BuiltinConstantArgRange(TheCall, i, l, u);
5174 return BuiltinConstantArgRange(TheCall, i, l, u) ||
5175 BuiltinConstantArgMultiple(TheCall, i, m);
5186 bool RequireICE =
false;
5194 unsigned size = strtoul(Str, &End, 10);
5195 assert(End != Str &&
"Missing constant parameter constraint");
5198 return Context.
IntTy;
5202 unsigned size = strtoul(Str, &End, 10);
5203 assert(End != Str &&
"Missing PowerPC MMA type size");
5207 #define PPC_VECTOR_TYPE(typeName, Id, size) \
5208 case size: Type = Context.Id##Ty; break;
5209 #include "clang/Basic/PPCTypes.def"
5210 default: llvm_unreachable(
"Invalid PowerPC MMA vector type");
5212 bool CheckVectorArgs =
false;
5213 while (!CheckVectorArgs) {
5222 CheckVectorArgs =
true;
5230 return Context.
DecodeTypeStr(--Str, Context, Error, RequireICE,
true);
5236 switch (BuiltinID) {
5237 case PPC::BI__builtin_divde:
5238 case PPC::BI__builtin_divdeu:
5239 case PPC::BI__builtin_bpermd:
5240 case PPC::BI__builtin_pdepd:
5241 case PPC::BI__builtin_pextd:
5242 case PPC::BI__builtin_ppc_ldarx:
5243 case PPC::BI__builtin_ppc_stdcx:
5244 case PPC::BI__builtin_ppc_tdw:
5245 case PPC::BI__builtin_ppc_trapd:
5246 case PPC::BI__builtin_ppc_cmpeqb:
5247 case PPC::BI__builtin_ppc_setb:
5248 case PPC::BI__builtin_ppc_mulhd:
5249 case PPC::BI__builtin_ppc_mulhdu:
5250 case PPC::BI__builtin_ppc_maddhd:
5251 case PPC::BI__builtin_ppc_maddhdu:
5252 case PPC::BI__builtin_ppc_maddld:
5253 case PPC::BI__builtin_ppc_load8r:
5254 case PPC::BI__builtin_ppc_store8r:
5255 case PPC::BI__builtin_ppc_insert_exp:
5256 case PPC::BI__builtin_ppc_extract_sig:
5257 case PPC::BI__builtin_ppc_addex:
5258 case PPC::BI__builtin_darn:
5259 case PPC::BI__builtin_darn_raw:
5260 case PPC::BI__builtin_ppc_compare_and_swaplp:
5261 case PPC::BI__builtin_ppc_fetch_and_addlp:
5262 case PPC::BI__builtin_ppc_fetch_and_andlp:
5263 case PPC::BI__builtin_ppc_fetch_and_orlp:
5264 case PPC::BI__builtin_ppc_fetch_and_swaplp:
5274bool Sema::ValueIsRunOfOnes(
CallExpr *TheCall,
unsigned ArgNum) {
5282 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
5286 if (
Result.isShiftedMask() || (~
Result).isShiftedMask())
5290 diag::err_argument_not_contiguous_bit_field)
5294bool Sema::CheckPPCBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
5296 unsigned i = 0, l = 0, u = 0;
5301 return Diag(TheCall->
getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
5304 switch (BuiltinID) {
5305 default:
return false;
5306 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
5307 case PPC::BI__builtin_altivec_crypto_vshasigmad:
5308 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
5309 BuiltinConstantArgRange(TheCall, 2, 0, 15);
5310 case PPC::BI__builtin_altivec_dss:
5311 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
5312 case PPC::BI__builtin_tbegin:
5313 case PPC::BI__builtin_tend:
5314 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5315 case PPC::BI__builtin_tsr:
5316 return BuiltinConstantArgRange(TheCall, 0, 0, 7);
5317 case PPC::BI__builtin_tabortwc:
5318 case PPC::BI__builtin_tabortdc:
5319 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5320 case PPC::BI__builtin_tabortwci:
5321 case PPC::BI__builtin_tabortdci:
5322 return BuiltinConstantArgRange(TheCall, 0, 0, 31) ||
5323 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5327 case PPC::BI__builtin_unpack_longdouble:
5328 if (BuiltinConstantArgRange(TheCall, 1, 0, 1))
5331 case PPC::BI__builtin_pack_longdouble:
5333 return Diag(TheCall->
getBeginLoc(), diag::err_ppc_builtin_requires_abi)
5336 case PPC::BI__builtin_altivec_dst:
5337 case PPC::BI__builtin_altivec_dstt:
5338 case PPC::BI__builtin_altivec_dstst:
5339 case PPC::BI__builtin_altivec_dststt:
5340 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
5341 case PPC::BI__builtin_vsx_xxpermdi:
5342 case PPC::BI__builtin_vsx_xxsldwi:
5343 return BuiltinVSX(TheCall);
5344 case PPC::BI__builtin_unpack_vector_int128:
5345 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5346 case PPC::BI__builtin_altivec_vgnb:
5347 return BuiltinConstantArgRange(TheCall, 1, 2, 7);
5348 case PPC::BI__builtin_vsx_xxeval:
5349 return BuiltinConstantArgRange(TheCall, 3, 0, 255);
5350 case PPC::BI__builtin_altivec_vsldbi:
5351 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5352 case PPC::BI__builtin_altivec_vsrdbi:
5353 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5354 case PPC::BI__builtin_vsx_xxpermx:
5355 return BuiltinConstantArgRange(TheCall, 3, 0, 7);
5356 case PPC::BI__builtin_ppc_tw:
5357 case PPC::BI__builtin_ppc_tdw:
5358 return BuiltinConstantArgRange(TheCall, 2, 1, 31);
5359 case PPC::BI__builtin_ppc_cmprb:
5360 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5363 case PPC::BI__builtin_ppc_rlwnm:
5364 return ValueIsRunOfOnes(TheCall, 2);
5365 case PPC::BI__builtin_ppc_rlwimi:
5366 return BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5367 ValueIsRunOfOnes(TheCall, 3);
5368 case PPC::BI__builtin_ppc_rldimi:
5369 return BuiltinConstantArgRange(TheCall, 2, 0, 63) ||
5370 ValueIsRunOfOnes(TheCall, 3);
5371 case PPC::BI__builtin_ppc_addex: {
5372 if (BuiltinConstantArgRange(TheCall, 2, 0, 3))
5382 case PPC::BI__builtin_ppc_mtfsb0:
5383 case PPC::BI__builtin_ppc_mtfsb1:
5384 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5385 case PPC::BI__builtin_ppc_mtfsf:
5386 return BuiltinConstantArgRange(TheCall, 0, 0, 255);
5387 case PPC::BI__builtin_ppc_mtfsfi:
5388 return BuiltinConstantArgRange(TheCall, 0, 0, 7) ||
5389 BuiltinConstantArgRange(TheCall, 1, 0, 15);
5390 case PPC::BI__builtin_ppc_alignx:
5391 return BuiltinConstantArgPower2(TheCall, 0);
5392 case PPC::BI__builtin_ppc_rdlam:
5393 return ValueIsRunOfOnes(TheCall, 2);
5394 case PPC::BI__builtin_vsx_ldrmb:
5395 case PPC::BI__builtin_vsx_strmb:
5396 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
5397 case PPC::BI__builtin_altivec_vcntmbb:
5398 case PPC::BI__builtin_altivec_vcntmbh:
5399 case PPC::BI__builtin_altivec_vcntmbw:
5400 case PPC::BI__builtin_altivec_vcntmbd:
5401 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5402 case PPC::BI__builtin_vsx_xxgenpcvbm:
5403 case PPC::BI__builtin_vsx_xxgenpcvhm:
5404 case PPC::BI__builtin_vsx_xxgenpcvwm:
5405 case PPC::BI__builtin_vsx_xxgenpcvdm:
5406 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
5407 case PPC::BI__builtin_ppc_test_data_class: {
5415 diag::err_ppc_invalid_test_data_class_type);
5416 return BuiltinConstantArgRange(TheCall, 1, 0, 127);
5418 case PPC::BI__builtin_ppc_maxfe:
5419 case PPC::BI__builtin_ppc_minfe:
5420 case PPC::BI__builtin_ppc_maxfl:
5421 case PPC::BI__builtin_ppc_minfl:
5422 case PPC::BI__builtin_ppc_maxfs:
5423 case PPC::BI__builtin_ppc_minfs: {
5425 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
5426 BuiltinID == PPC::BI__builtin_ppc_minfe))
5427 return Diag(TheCall->
getBeginLoc(), diag::err_target_unsupported_type)
5432 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
5433 BuiltinID == PPC::BI__builtin_ppc_minfl)
5435 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
5436 BuiltinID == PPC::BI__builtin_ppc_minfs)
5438 for (
unsigned I = 0, E = TheCall->
getNumArgs(); I < E; ++I)
5441 diag::err_typecheck_convert_incompatible)
5445#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
5446 case PPC::BI__builtin_##Name: \
5447 return BuiltinPPCMMACall(TheCall, BuiltinID, Types);
5448#include "clang/Basic/BuiltinsPPC.def"
5450 return BuiltinConstantArgRange(TheCall, i, l, u);
5459 QualType CoreType =
Type.getCanonicalType().getUnqualifiedType();
5460#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
5462#include
"clang/Basic/PPCTypes.def"
5464 Diag(
TypeLoc, diag::err_ppc_invalid_use_mma_type);
5480 for (
unsigned i = 1; i < TheCall->
getNumArgs(); ++i) {
5484 if (VecTyA ==
nullptr && VecTyB ==
nullptr)
5487 if (VecTyA && VecTyB) {
5488 bool retValue =
false;
5489 if (VecTyA->getElementType() != VecTyB->getElementType()) {
5493 diag::err_vec_builtin_incompatible_vector)
5498 if (VecTyA->getNumElements() != VecTyB->getNumElements()) {
5502 S->
Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
5514 S->
Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
5524 for (
unsigned i = 0; i < TheCall->
getNumArgs(); ++i) {
5526 if (Check(PassedType)) {
5529 ExpectedType, VecTyA->getNumElements(), VecTyA->getVectorKind());
5531 diag::err_typecheck_convert_incompatible)
5541 return !PassedType->hasFloatingRepresentation();
5544 checkAllFloatTypes);
5561 if (
const auto *VecTy = PassedType->getAs<
VectorType>())
5562 return VecTy->getElementType()->isDoubleType();
5571 return !PassedType->hasUnsignedIntegerRepresentation();
5574 checkAllUnsignedTypes);
5589 switch (BuiltinID) {
5590 case Builtin::BI__builtin_hlsl_elementwise_all:
5591 case Builtin::BI__builtin_hlsl_elementwise_any: {
5596 case Builtin::BI__builtin_hlsl_elementwise_clamp: {
5601 if (BuiltinElementwiseTernaryMath(
5607 case Builtin::BI__builtin_hlsl_dot: {
5618 case Builtin::BI__builtin_hlsl_elementwise_rcp: {
5621 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5625 case Builtin::BI__builtin_hlsl_elementwise_rsqrt:
5626 case Builtin::BI__builtin_hlsl_elementwise_frac: {
5629 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5633 case Builtin::BI__builtin_hlsl_elementwise_isinf: {
5636 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5641 case Builtin::BI__builtin_hlsl_lerp: {
5646 if (BuiltinElementwiseTernaryMath(TheCall))
5652 case Builtin::BI__builtin_hlsl_mad: {
5657 if (BuiltinElementwiseTernaryMath(
5665 case Builtin::BI__builtin_elementwise_bitreverse: {
5670 case Builtin::BI__builtin_elementwise_ceil:
5671 case Builtin::BI__builtin_elementwise_cos:
5672 case Builtin::BI__builtin_elementwise_exp:
5673 case Builtin::BI__builtin_elementwise_exp2:
5674 case Builtin::BI__builtin_elementwise_floor:
5675 case Builtin::BI__builtin_elementwise_log:
5676 case Builtin::BI__builtin_elementwise_log2:
5677 case Builtin::BI__builtin_elementwise_log10:
5678 case Builtin::BI__builtin_elementwise_pow:
5679 case Builtin::BI__builtin_elementwise_roundeven:
5680 case Builtin::BI__builtin_elementwise_sin:
5681 case Builtin::BI__builtin_elementwise_sqrt:
5682 case Builtin::BI__builtin_elementwise_tan:
5683 case Builtin::BI__builtin_elementwise_trunc: {
5692bool Sema::CheckAMDGCNBuiltinFunctionCall(
unsigned BuiltinID,
5695 unsigned OrderIndex, ScopeIndex;
5696 switch (BuiltinID) {
5697 case AMDGPU::BI__builtin_amdgcn_get_fpenv:
5698 case AMDGPU::BI__builtin_amdgcn_set_fpenv:
5700 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
5701 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
5702 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
5703 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
5707 case AMDGPU::BI__builtin_amdgcn_fence:
5716 auto ArgExpr = Arg.
get();
5719 if (!ArgExpr->EvaluateAsInt(ArgResult,
Context))
5720 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
5721 << ArgExpr->getType();
5722 auto Ord = ArgResult.
Val.
getInt().getZExtValue();
5726 if (!llvm::isValidAtomicOrderingCABI(Ord))
5727 return Diag(ArgExpr->getBeginLoc(),
5728 diag::warn_atomic_op_has_invalid_memory_order)
5729 << 0 << ArgExpr->getSourceRange();
5730 switch (
static_cast<llvm::AtomicOrderingCABI
>(Ord)) {
5731 case llvm::AtomicOrderingCABI::relaxed:
5732 case llvm::AtomicOrderingCABI::consume:
5733 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
5734 return Diag(ArgExpr->getBeginLoc(),
5735 diag::warn_atomic_op_has_invalid_memory_order)
5736 << 0 << ArgExpr->getSourceRange();
5738 case llvm::AtomicOrderingCABI::acquire:
5739 case llvm::AtomicOrderingCABI::release:
5740 case llvm::AtomicOrderingCABI::acq_rel:
5741 case llvm::AtomicOrderingCABI::seq_cst:
5745 Arg = TheCall->
getArg(ScopeIndex);
5746 ArgExpr = Arg.
get();
5749 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1,
Context))
5750 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
5751 << ArgExpr->getType();
5756bool Sema::CheckRISCVLMUL(
CallExpr *TheCall,
unsigned ArgNum) {
5765 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
5769 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
5772 return Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
5778 assert((EGW == 128 || EGW == 256) &&
"EGW can only be 128 or 256 bits");
5784 unsigned MinElemCount = Info.
EC.getKnownMinValue();
5786 unsigned EGS = EGW / ElemSize;
5789 if (EGS <= MinElemCount)
5793 assert(EGS % MinElemCount == 0);
5794 unsigned VScaleFactor = EGS / MinElemCount;
5796 unsigned MinRequiredVLEN = VScaleFactor * llvm::RISCV::RVVBitsPerBlock;
5797 std::string RequiredExt =
"zvl" + std::to_string(MinRequiredVLEN) +
"b";
5800 diag::err_riscv_type_requires_extension) <<
Type << RequiredExt;
5805bool Sema::CheckRISCVBuiltinFunctionCall(
const TargetInfo &TI,
5810 switch (BuiltinID) {
5813 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
5814 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
5815 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
5816 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
5817 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
5818 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
5819 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
5820 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
5821 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
5822 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
5823 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
5824 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
5825 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
5826 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
5827 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
5828 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
5829 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
5830 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
5831 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
5832 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
5833 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
5834 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
5835 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
5836 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
5837 case RISCVVector::BI__builtin_rvv_vmulh_vv:
5838 case RISCVVector::BI__builtin_rvv_vmulh_vx:
5839 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
5840 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
5841 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
5842 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
5843 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
5844 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
5845 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
5846 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
5847 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
5848 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
5849 case RISCVVector::BI__builtin_rvv_vsmul_vv:
5850 case RISCVVector::BI__builtin_rvv_vsmul_vx:
5851 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
5852 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
5853 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
5854 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
5855 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
5856 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
5857 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
5858 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
5859 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
5860 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
5866 diag::err_riscv_builtin_requires_extension)
5873 switch (BuiltinID) {
5874 case RISCVVector::BI__builtin_rvv_vsetvli:
5875 return BuiltinConstantArgRange(TheCall, 1, 0, 3) ||
5876 CheckRISCVLMUL(TheCall, 2);
5877 case RISCVVector::BI__builtin_rvv_vsetvlimax:
5878 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5879 CheckRISCVLMUL(TheCall, 1);
5880 case RISCVVector::BI__builtin_rvv_vget_v: {
5891 MaxIndex = (VecInfo.
EC.getKnownMinValue() * VecInfo.
NumVectors) /
5892 (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors);
5893 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5895 case RISCVVector::BI__builtin_rvv_vset_v: {
5906 MaxIndex = (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors) /
5908 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5911 case RISCVVector::BI__builtin_rvv_vaeskf1_vi_tu:
5912 case RISCVVector::BI__builtin_rvv_vaeskf2_vi_tu:
5913 case RISCVVector::BI__builtin_rvv_vaeskf2_vi:
5914 case RISCVVector::BI__builtin_rvv_vsm4k_vi_tu: {
5919 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5921 case RISCVVector::BI__builtin_rvv_vsm3c_vi_tu:
5922 case RISCVVector::BI__builtin_rvv_vsm3c_vi: {
5925 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5927 case RISCVVector::BI__builtin_rvv_vaeskf1_vi:
5928 case RISCVVector::BI__builtin_rvv_vsm4k_vi: {
5931 BuiltinConstantArgRange(TheCall, 1, 0, 31);
5933 case RISCVVector::BI__builtin_rvv_vaesdf_vv:
5934 case RISCVVector::BI__builtin_rvv_vaesdf_vs:
5935 case RISCVVector::BI__builtin_rvv_vaesdm_vv:
5936 case RISCVVector::BI__builtin_rvv_vaesdm_vs:
5937 case RISCVVector::BI__builtin_rvv_vaesef_vv:
5938 case RISCVVector::BI__builtin_rvv_vaesef_vs:
5939 case RISCVVector::BI__builtin_rvv_vaesem_vv:
5940 case RISCVVector::BI__builtin_rvv_vaesem_vs:
5941 case RISCVVector::BI__builtin_rvv_vaesz_vs:
5942 case RISCVVector::BI__builtin_rvv_vsm4r_vv:
5943 case RISCVVector::BI__builtin_rvv_vsm4r_vs:
5944 case RISCVVector::BI__builtin_rvv_vaesdf_vv_tu:
5945 case RISCVVector::BI__builtin_rvv_vaesdf_vs_tu:
5946 case RISCVVector::BI__builtin_rvv_vaesdm_vv_tu:
5947 case RISCVVector::BI__builtin_rvv_vaesdm_vs_tu:
5948 case RISCVVector::BI__builtin_rvv_vaesef_vv_tu:
5949 case RISCVVector::BI__builtin_rvv_vaesef_vs_tu:
5950 case RISCVVector::BI__builtin_rvv_vaesem_vv_tu:
5951 case RISCVVector::BI__builtin_rvv_vaesem_vs_tu:
5952 case RISCVVector::BI__builtin_rvv_vaesz_vs_tu:
5953 case RISCVVector::BI__builtin_rvv_vsm4r_vv_tu:
5954 case RISCVVector::BI__builtin_rvv_vsm4r_vs_tu: {
5960 case RISCVVector::BI__builtin_rvv_vsha2ch_vv:
5961 case RISCVVector::BI__builtin_rvv_vsha2cl_vv:
5962 case RISCVVector::BI__builtin_rvv_vsha2ms_vv:
5963 case RISCVVector::BI__builtin_rvv_vsha2ch_vv_tu:
5964 case RISCVVector::BI__builtin_rvv_vsha2cl_vv_tu:
5965 case RISCVVector::BI__builtin_rvv_vsha2ms_vv_tu: {
5972 if (ElemSize == 64 && !TI.
hasFeature(
"zvknhb"))
5974 diag::err_riscv_builtin_requires_extension)
5982 case RISCVVector::BI__builtin_rvv_sf_vc_i_se:
5984 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5985 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5986 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5987 BuiltinConstantArgRange(TheCall, 3, -16, 15) ||
5988 CheckRISCVLMUL(TheCall, 5);
5989 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
5991 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5992 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5993 BuiltinConstantArgRange(TheCall, 3, -16, 15);
5994 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
5995 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
5997 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5998 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
5999 BuiltinConstantArgRange(TheCall, 2, -16, 15);
6000 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
6001 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
6003 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6004 BuiltinConstantArgRange(TheCall, 2, -16, 15);
6005 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
6006 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
6007 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
6008 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
6009 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
6010 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
6012 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6013 BuiltinConstantArgRange(TheCall, 3, -16, 15);
6014 case RISCVVector::BI__builtin_rvv_sf_vc_x_se:
6016 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6017 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
6018 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
6019 CheckRISCVLMUL(TheCall, 5);
6020 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
6021 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
6023 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
6024 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
6026 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6027 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6028 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
6029 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
6030 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
6031 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
6033 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
6034 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
6035 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
6036 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
6038 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
6039 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
6040 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
6041 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
6042 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
6043 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
6044 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
6045 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
6047 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
6048 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
6050 return BuiltinConstantArgRange(TheCall, 0, 0, 1) ||
6051 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6052 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
6053 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
6054 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
6055 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
6056 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
6057 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
6059 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
6060 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
6062 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
6064 case RISCV::BI__builtin_riscv_aes32dsi:
6065 case RISCV::BI__builtin_riscv_aes32dsmi:
6066 case RISCV::BI__builtin_riscv_aes32esi:
6067 case RISCV::BI__builtin_riscv_aes32esmi:
6068 case RISCV::BI__builtin_riscv_sm4ks:
6069 case RISCV::BI__builtin_riscv_sm4ed:
6070 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6072 case RISCV::BI__builtin_riscv_aes64ks1i:
6073 return BuiltinConstantArgRange(TheCall, 1, 0, 10);
6075 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
6076 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
6077 case RISCVVector::BI__builtin_rvv_vaadd_vv:
6078 case RISCVVector::BI__builtin_rvv_vaadd_vx:
6079 case RISCVVector::BI__builtin_rvv_vasubu_vv:
6080 case RISCVVector::BI__builtin_rvv_vasubu_vx:
6081 case RISCVVector::BI__builtin_rvv_vasub_vv:
6082 case RISCVVector::BI__builtin_rvv_vasub_vx:
6083 case RISCVVector::BI__builtin_rvv_vsmul_vv:
6084 case RISCVVector::BI__builtin_rvv_vsmul_vx:
6085 case RISCVVector::BI__builtin_rvv_vssra_vv:
6086 case RISCVVector::BI__builtin_rvv_vssra_vx:
6087 case RISCVVector::BI__builtin_rvv_vssrl_vv:
6088 case RISCVVector::BI__builtin_rvv_vssrl_vx:
6089 case RISCVVector::BI__builtin_rvv_vnclip_wv:
6090 case RISCVVector::BI__builtin_rvv_vnclip_wx:
6091 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
6092 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
6093 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6094 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
6095 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
6096 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
6097 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
6098 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
6099 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
6100 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
6101 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
6102 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
6103 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
6104 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
6105 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
6106 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
6107 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
6108 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
6109 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
6110 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
6111 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
6112 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
6113 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
6114 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
6115 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
6116 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
6117 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
6118 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
6119 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
6120 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
6121 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
6122 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
6123 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
6124 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
6125 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
6126 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
6127 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
6128 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
6129 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
6130 return BuiltinConstantArgRange(TheCall, 3, 0, 3);
6131 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
6132 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
6133 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
6134 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
6135 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
6136 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
6137 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
6138 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
6139 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
6140 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
6141 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
6142 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
6143 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
6144 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
6145 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
6146 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
6147 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
6148 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
6149 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
6150 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
6151 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
6152 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
6153 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
6154 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
6155 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
6156 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
6157 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
6158 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
6159 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
6160 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
6161 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
6162 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
6163 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
6164 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
6165 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
6166 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
6167 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
6168 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
6169 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
6170 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
6171 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
6172 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
6173 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
6174 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
6175 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
6176 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
6177 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
6178 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
6179 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
6180 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
6181 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
6182 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
6183 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
6184 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
6185 return BuiltinConstantArgRange(TheCall, 4, 0, 3);
6186 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
6187 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
6188 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
6189 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
6190 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
6191 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
6192 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
6193 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
6194 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
6195 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
6196 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
6197 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
6198 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
6199 return BuiltinConstantArgRange(TheCall, 1, 0, 4);
6200 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
6201 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
6202 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
6203 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
6204 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
6205 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
6206 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
6207 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
6208 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
6209 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
6210 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
6211 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
6212 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
6213 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
6214 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
6215 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
6216 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
6217 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
6218 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
6219 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
6220 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
6221 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
6222 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
6223 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
6224 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
6225 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
6226 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
6227 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
6228 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
6229 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
6230 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
6231 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
6232 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
6233 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
6234 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
6235 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
6236 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
6237 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
6238 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
6239 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
6240 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
6241 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
6242 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
6243 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
6244 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
6245 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
6246 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
6247 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
6248 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
6249 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
6250 return BuiltinConstantArgRange(TheCall, 2, 0, 4);
6251 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
6252 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
6253 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
6254 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
6255 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
6256 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
6257 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
6258 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
6259 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
6260 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
6261 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
6262 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
6263 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
6264 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
6265 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
6266 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
6267 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
6268 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
6269 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
6270 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
6271 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
6272 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
6273 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
6274 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
6275 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
6276 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
6277 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
6278 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
6279 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
6280 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
6281 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
6282 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
6283 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
6284 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
6285 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
6286 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
6287 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
6288 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
6289 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
6290 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
6291 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
6292 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
6293 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
6294 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
6295 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
6296 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
6297 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
6298 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
6299 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
6300 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
6301 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
6302 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
6303 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
6304 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
6305 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
6306 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
6307 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
6308 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
6309 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
6310 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
6311 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
6312 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
6313 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
6314 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
6315 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
6316 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
6317 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
6318 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
6319 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
6320 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
6321 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
6322 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
6323 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
6324 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
6325 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
6326 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
6327 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
6328 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
6329 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
6330 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
6331 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
6332 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
6333 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
6334 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
6335 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
6336 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
6337 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
6338 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
6339 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
6340 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
6341 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
6342 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
6343 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
6344 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
6345 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
6346 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
6347 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
6348 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
6349 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
6350 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
6351 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
6352 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
6353 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
6354 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
6355 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
6356 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
6357 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
6358 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
6359 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
6360 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
6361 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
6362 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
6363 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
6364 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
6365 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
6366 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
6367 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
6368 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
6369 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
6370 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
6371 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
6372 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
6373 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
6374 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
6375 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
6376 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
6377 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
6378 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
6379 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
6380 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
6381 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
6382 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
6383 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
6384 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
6385 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
6386 return BuiltinConstantArgRange(TheCall, 3, 0, 4);
6387 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
6388 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
6389 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
6390 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
6391 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
6392 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
6393 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
6394 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
6395 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
6396 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
6397 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
6398 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
6399 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
6400 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
6401 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
6402 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
6403 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
6404 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
6405 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
6406 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
6407 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
6408 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
6409 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
6410 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
6411 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
6412 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
6413 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
6414 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
6415 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
6416 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
6417 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
6418 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
6419 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
6420 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
6421 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
6422 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
6423 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
6424 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
6425 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
6426 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
6427 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
6428 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
6429 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
6430 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
6431 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
6432 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
6433 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
6434 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
6435 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
6436 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
6437 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
6438 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
6439 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
6440 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
6441 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
6442 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
6443 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
6444 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
6445 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
6446 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
6447 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
6448 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
6449 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
6450 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
6451 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
6452 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
6453 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
6454 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
6455 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
6456 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
6457 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
6458 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
6459 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
6460 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
6461 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
6462 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
6463 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
6464 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
6465 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
6466 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
6467 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
6468 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
6469 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
6470 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
6471 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
6472 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
6473 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
6474 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
6475 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
6476 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
6477 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
6478 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
6479 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
6480 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
6481 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
6482 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
6483 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
6484 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
6485 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
6486 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
6487 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
6488 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
6489 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
6490 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
6491 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
6492 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
6493 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
6494 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
6495 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
6496 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
6497 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
6498 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
6499 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
6500 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
6501 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
6502 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
6503 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
6504 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
6505 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
6506 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
6507 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
6508 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
6509 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
6510 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
6511 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
6512 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
6513 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
6514 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
6515 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
6516 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
6517 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
6518 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
6519 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
6520 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
6521 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
6522 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
6523 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
6524 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
6525 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
6526 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
6527 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
6528 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
6529 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
6530 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
6531 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
6532 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
6533 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
6534 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
6535 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
6536 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
6537 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
6538 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
6539 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
6540 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
6541 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
6542 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
6543 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
6544 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
6545 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
6546 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
6547 return BuiltinConstantArgRange(TheCall, 4, 0, 4);
6548 case RISCV::BI__builtin_riscv_ntl_load:
6549 case RISCV::BI__builtin_riscv_ntl_store:
6552 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
6553 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
6554 "Unexpected RISC-V nontemporal load/store builtin!");
6555 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
6556 unsigned NumArgs = IsStore ? 3 : 2;
6567 BuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
6576 PointerArg = PointerArgResult.
get();
6580 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
6591 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
6616bool Sema::CheckSystemZBuiltinFunctionCall(
unsigned BuiltinID,
6618 if (BuiltinID == SystemZ::BI__builtin_tabort) {
6620 if (std::optional<llvm::APSInt> AbortCode =
6622 if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
6623 return Diag(Arg->
getBeginLoc(), diag::err_systemz_invalid_tabort_code)
6629 unsigned i = 0, l = 0, u = 0;
6630 switch (BuiltinID) {
6631 default:
return false;
6632 case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15;
break;
6633 case SystemZ::BI__builtin_s390_verimb:
6634 case SystemZ::BI__builtin_s390_verimh:
6635 case SystemZ::BI__builtin_s390_verimf:
6636 case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255;
break;
6637 case SystemZ::BI__builtin_s390_vfaeb:
6638 case SystemZ::BI__builtin_s390_vfaeh:
6639 case SystemZ::BI__builtin_s390_vfaef:
6640 case SystemZ::BI__builtin_s390_vfaebs:
6641 case SystemZ::BI__builtin_s390_vfaehs:
6642 case SystemZ::BI__builtin_s390_vfaefs:
6643 case SystemZ::BI__builtin_s390_vfaezb:
6644 case SystemZ::BI__builtin_s390_vfaezh:
6645 case SystemZ::BI__builtin_s390_vfaezf:
6646 case SystemZ::BI__builtin_s390_vfaezbs:
6647 case SystemZ::BI__builtin_s390_vfaezhs:
6648 case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15;
break;
6649 case SystemZ::BI__builtin_s390_vfisb:
6650 case SystemZ::BI__builtin_s390_vfidb:
6651 return BuiltinConstantArgRange(TheCall, 1, 0, 15) ||
6652 BuiltinConstantArgRange(TheCall, 2, 0, 15);
6653 case SystemZ::BI__builtin_s390_vftcisb:
6654 case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095;
break;
6655 case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15;
break;
6656 case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15;
break;
6657 case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15;
break;
6658 case SystemZ::BI__builtin_s390_vstrcb:
6659 case SystemZ::BI__builtin_s390_vstrch:
6660 case SystemZ::BI__builtin_s390_vstrcf:
6661 case SystemZ::BI__builtin_s390_vstrczb:
6662 case SystemZ::BI__builtin_s390_vstrczh:
6663 case SystemZ::BI__builtin_s390_vstrczf:
6664 case SystemZ::BI__builtin_s390_vstrcbs:
6665 case SystemZ::BI__builtin_s390_vstrchs:
6666 case SystemZ::BI__builtin_s390_vstrcfs:
6667 case SystemZ::BI__builtin_s390_vstrczbs:
6668 case SystemZ::BI__builtin_s390_vstrczhs:
6669 case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15;
break;
6670 case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15;
break;
6671 case SystemZ::BI__builtin_s390_vfminsb:
6672 case SystemZ::BI__builtin_s390_vfmaxsb:
6673 case SystemZ::BI__builtin_s390_vfmindb:
6674 case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15;
break;
6675 case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7;
break;
6676 case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7;
break;
6677 case SystemZ::BI__builtin_s390_vclfnhs:
6678 case SystemZ::BI__builtin_s390_vclfnls:
6679 case SystemZ::BI__builtin_s390_vcfn:
6680 case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15;
break;
6681 case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15;
break;
6683 return BuiltinConstantArgRange(TheCall, i, l, u);
6686bool Sema::CheckWebAssemblyBuiltinFunctionCall(
const TargetInfo &TI,
6689 switch (BuiltinID) {
6690 case WebAssembly::BI__builtin_wasm_ref_null_extern:
6691 return BuiltinWasmRefNullExtern(TheCall);
6692 case WebAssembly::BI__builtin_wasm_ref_null_func:
6693 return BuiltinWasmRefNullFunc(TheCall);
6694 case WebAssembly::BI__builtin_wasm_table_get:
6695 return BuiltinWasmTableGet(TheCall);
6696 case WebAssembly::BI__builtin_wasm_table_set:
6697 return BuiltinWasmTableSet(TheCall);
6698 case WebAssembly::BI__builtin_wasm_table_size:
6699 return BuiltinWasmTableSize(TheCall);
6700 case WebAssembly::BI__builtin_wasm_table_grow:
6701 return BuiltinWasmTableGrow(TheCall);
6702 case WebAssembly::BI__builtin_wasm_table_fill:
6703 return BuiltinWasmTableFill(TheCall);
6704 case WebAssembly::BI__builtin_wasm_table_copy:
6705 return BuiltinWasmTableCopy(TheCall);
6712 const llvm::StringMap<bool> &FeatureMap) {
6716 unsigned MinElts = Info.
EC.getKnownMinValue();
6719 !FeatureMap.lookup(
"zve64d"))
6720 Diag(
Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64d";
6725 !FeatureMap.lookup(
"zve64x"))
6726 Diag(
Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64x";
6728 !FeatureMap.lookup(
"zvfhmin"))
6729 Diag(
Loc, diag::err_riscv_type_requires_extension, D)
6730 << Ty <<
"zvfh or zvfhmin";
6732 !FeatureMap.lookup(
"experimental-zvfbfmin"))
6733 Diag(
Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zvfbfmin";
6735 !FeatureMap.lookup(
"zve32f"))
6736 Diag(
Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32f";
6739 else if (!FeatureMap.lookup(
"zve32x"))
6740 Diag(
Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32x";
6743bool Sema::CheckNVPTXBuiltinFunctionCall(
const TargetInfo &TI,
6746 switch (BuiltinID) {
6747 case NVPTX::BI__nvvm_cp_async_ca_shared_global_4:
6748 case NVPTX::BI__nvvm_cp_async_ca_shared_global_8:
6749 case NVPTX::BI__nvvm_cp_async_ca_shared_global_16:
6750 case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
6758bool Sema::CheckX86BuiltinRoundingOrSAE(
unsigned BuiltinID,
CallExpr *TheCall) {
6762 unsigned ArgNum = 0;
6763 switch (BuiltinID) {
6766 case X86::BI__builtin_ia32_vcvttsd2si32:
6767 case X86::BI__builtin_ia32_vcvttsd2si64:
6768 case X86::BI__builtin_ia32_vcvttsd2usi32:
6769 case X86::BI__builtin_ia32_vcvttsd2usi64:
6770 case X86::BI__builtin_ia32_vcvttss2si32:
6771 case X86::BI__builtin_ia32_vcvttss2si64:
6772 case X86::BI__builtin_ia32_vcvttss2usi32:
6773 case X86::BI__builtin_ia32_vcvttss2usi64:
6774 case X86::BI__builtin_ia32_vcvttsh2si32:
6775 case X86::BI__builtin_ia32_vcvttsh2si64:
6776 case X86::BI__builtin_ia32_vcvttsh2usi32:
6777 case X86::BI__builtin_ia32_vcvttsh2usi64:
6780 case X86::BI__builtin_ia32_maxpd512:
6781 case X86::BI__builtin_ia32_maxps512:
6782 case X86::BI__builtin_ia32_minpd512:
6783 case X86::BI__builtin_ia32_minps512:
6784 case X86::BI__builtin_ia32_maxph512:
6785 case X86::BI__builtin_ia32_minph512:
6788 case X86::BI__builtin_ia32_vcvtph2pd512_mask:
6789 case X86::BI__builtin_ia32_vcvtph2psx512_mask:
6790 case X86::BI__builtin_ia32_cvtps2pd512_mask:
6791 case X86::BI__builtin_ia32_cvttpd2dq512_mask:
6792 case X86::BI__builtin_ia32_cvttpd2qq512_mask:
6793 case X86::BI__builtin_ia32_cvttpd2udq512_mask:
6794 case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
6795 case X86::BI__builtin_ia32_cvttps2dq512_mask:
6796 case X86::BI__builtin_ia32_cvttps2qq512_mask:
6797 case X86::BI__builtin_ia32_cvttps2udq512_mask:
6798 case X86::BI__builtin_ia32_cvttps2uqq512_mask:
6799 case X86::BI__builtin_ia32_vcvttph2w512_mask:
6800 case X86::BI__builtin_ia32_vcvttph2uw512_mask:
6801 case X86::BI__builtin_ia32_vcvttph2dq512_mask:
6802 case X86::BI__builtin_ia32_vcvttph2udq512_mask:
6803 case X86::BI__builtin_ia32_vcvttph2qq512_mask:
6804 case X86::BI__builtin_ia32_vcvttph2uqq512_mask:
6805 case X86::BI__builtin_ia32_exp2pd_mask:
6806 case X86::BI__builtin_ia32_exp2ps_mask:
6807 case X86::BI__builtin_ia32_getexppd512_mask:
6808 case X86::BI__builtin_ia32_getexpps512_mask:
6809 case X86::BI__builtin_ia32_getexpph512_mask:
6810 case X86::BI__builtin_ia32_rcp28pd_mask:
6811 case X86::BI__builtin_ia32_rcp28ps_mask:
6812 case X86::BI__builtin_ia32_rsqrt28pd_mask:
6813 case X86::BI__builtin_ia32_rsqrt28ps_mask:
6814 case X86::BI__builtin_ia32_vcomisd:
6815 case X86::BI__builtin_ia32_vcomiss:
6816 case X86::BI__builtin_ia32_vcomish:
6817 case X86::BI__builtin_ia32_vcvtph2ps512_mask:
6820 case X86::BI__builtin_ia32_cmppd512_mask:
6821 case X86::BI__builtin_ia32_cmpps512_mask:
6822 case X86::BI__builtin_ia32_cmpsd_mask:
6823 case X86::BI__builtin_ia32_cmpss_mask:
6824 case X86::BI__builtin_ia32_cmpsh_mask:
6825 case X86::BI__builtin_ia32_vcvtsh2sd_round_mask:
6826 case X86::BI__builtin_ia32_vcvtsh2ss_round_mask:
6827 case X86::BI__builtin_ia32_cvtss2sd_round_mask:
6828 case X86::BI__builtin_ia32_getexpsd128_round_mask:
6829 case X86::BI__builtin_ia32_getexpss128_round_mask:
6830 case X86::BI__builtin_ia32_getexpsh128_round_mask:
6831 case X86::BI__builtin_ia32_getmantpd512_mask:
6832 case X86::BI__builtin_ia32_getmantps512_mask:
6833 case X86::BI__builtin_ia32_getmantph512_mask:
6834 case X86::BI__builtin_ia32_maxsd_round_mask:
6835 case X86::BI__builtin_ia32_maxss_round_mask:
6836 case X86::BI__builtin_ia32_maxsh_round_mask:
6837 case X86::BI__builtin_ia32_minsd_round_mask:
6838 case X86::BI__builtin_ia32_minss_round_mask:
6839 case X86::BI__builtin_ia32_minsh_round_mask:
6840 case X86::BI__builtin_ia32_rcp28sd_round_mask:
6841 case X86::BI__builtin_ia32_rcp28ss_round_mask:
6842 case X86::BI__builtin_ia32_reducepd512_mask:
6843 case X86::BI__builtin_ia32_reduceps512_mask:
6844 case X86::BI__builtin_ia32_reduceph512_mask:
6845 case X86::BI__builtin_ia32_rndscalepd_mask:
6846 case X86::BI__builtin_ia32_rndscaleps_mask:
6847 case X86::BI__builtin_ia32_rndscaleph_mask:
6848 case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
6849 case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
6852 case X86::BI__builtin_ia32_fixupimmpd512_mask:
6853 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
6854 case X86::BI__builtin_ia32_fixupimmps512_mask:
6855 case X86::BI__builtin_ia32_fixupimmps512_maskz:
6856 case X86::BI__builtin_ia32_fixupimmsd_mask:
6857 case X86::BI__builtin_ia32_fixupimmsd_maskz:
6858 case X86::BI__builtin_ia32_fixupimmss_mask:
6859 case X86::BI__builtin_ia32_fixupimmss_maskz:
6860 case X86::BI__builtin_ia32_getmantsd_round_mask:
6861 case X86::BI__builtin_ia32_getmantss_round_mask:
6862 case X86::BI__builtin_ia32_getmantsh_round_mask:
6863 case X86::BI__builtin_ia32_rangepd512_mask:
6864 case X86::BI__builtin_ia32_rangeps512_mask:
6865 case X86::BI__builtin_ia32_rangesd128_round_mask:
6866 case X86::BI__builtin_ia32_rangess128_round_mask:
6867 case X86::BI__builtin_ia32_reducesd_mask:
6868 case X86::BI__builtin_ia32_reducess_mask:
6869 case X86::BI__builtin_ia32_reducesh_mask:
6870 case X86::BI__builtin_ia32_rndscalesd_round_mask:
6871 case X86::BI__builtin_ia32_rndscaless_round_mask:
6872 case X86::BI__builtin_ia32_rndscalesh_round_mask:
6875 case X86::BI__builtin_ia32_vcvtsd2si64:
6876 case X86::BI__builtin_ia32_vcvtsd2si32:
6877 case X86::BI__builtin_ia32_vcvtsd2usi32:
6878 case X86::BI__builtin_ia32_vcvtsd2usi64:
6879 case X86::BI__builtin_ia32_vcvtss2si32:
6880 case X86::BI__builtin_ia32_vcvtss2si64:
6881 case X86::BI__builtin_ia32_vcvtss2usi32:
6882 case X86::BI__builtin_ia32_vcvtss2usi64:
6883 case X86::BI__builtin_ia32_vcvtsh2si32:
6884 case X86::BI__builtin_ia32_vcvtsh2si64:
6885 case X86::BI__builtin_ia32_vcvtsh2usi32:
6886 case X86::BI__builtin_ia32_vcvtsh2usi64:
6887 case X86::BI__builtin_ia32_sqrtpd512:
6888 case X86::BI__builtin_ia32_sqrtps512:
6889 case X86::BI__builtin_ia32_sqrtph512:
6893 case X86::BI__builtin_ia32_addph512:
6894 case X86::BI__builtin_ia32_divph512:
6895 case X86::BI__builtin_ia32_mulph512:
6896 case X86::BI__builtin_ia32_subph512:
6897 case X86::BI__builtin_ia32_addpd512:
6898 case X86::BI__builtin_ia32_addps512:
6899 case X86::BI__builtin_ia32_divpd512:
6900 case X86::BI__builtin_ia32_divps512:
6901 case X86::BI__builtin_ia32_mulpd512:
6902 case X86::BI__builtin_ia32_mulps512:
6903 case X86::BI__builtin_ia32_subpd512:
6904 case X86::BI__builtin_ia32_subps512:
6905 case X86::BI__builtin_ia32_cvtsi2sd64:
6906 case X86::BI__builtin_ia32_cvtsi2ss32:
6907 case X86::BI__builtin_ia32_cvtsi2ss64:
6908 case X86::BI__builtin_ia32_cvtusi2sd64:
6909 case X86::BI__builtin_ia32_cvtusi2ss32:
6910 case X86::BI__builtin_ia32_cvtusi2ss64:
6911 case X86::BI__builtin_ia32_vcvtusi2sh:
6912 case X86::BI__builtin_ia32_vcvtusi642sh:
6913 case X86::BI__builtin_ia32_vcvtsi2sh:
6914 case X86::BI__builtin_ia32_vcvtsi642sh:
6918 case X86::BI__builtin_ia32_cvtdq2ps512_mask:
6919 case X86::BI__builtin_ia32_cvtudq2ps512_mask:
6920 case X86::BI__builtin_ia32_vcvtpd2ph512_mask:
6921 case X86::BI__builtin_ia32_vcvtps2phx512_mask:
6922 case X86::BI__builtin_ia32_cvtpd2ps512_mask:
6923 case X86::BI__builtin_ia32_cvtpd2dq512_mask:
6924 case X86::BI__builtin_ia32_cvtpd2qq512_mask:
6925 case X86::BI__builtin_ia32_cvtpd2udq512_mask:
6926 case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
6927 case X86::BI__builtin_ia32_cvtps2dq512_mask:
6928 case X86::BI__builtin_ia32_cvtps2qq512_mask:
6929 case X86::BI__builtin_ia32_cvtps2udq512_mask:
6930 case X86::BI__builtin_ia32_cvtps2uqq512_mask:
6931 case X86::BI__builtin_ia32_cvtqq2pd512_mask:
6932 case X86::BI__builtin_ia32_cvtqq2ps512_mask:
6933 case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
6934 case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
6935 case X86::BI__builtin_ia32_vcvtdq2ph512_mask:
6936 case X86::BI__builtin_ia32_vcvtudq2ph512_mask:
6937 case X86::BI__builtin_ia32_vcvtw2ph512_mask:
6938 case X86::BI__builtin_ia32_vcvtuw2ph512_mask:
6939 case X86::BI__builtin_ia32_vcvtph2w512_mask:
6940 case X86::BI__builtin_ia32_vcvtph2uw512_mask:
6941 case X86::BI__builtin_ia32_vcvtph2dq512_mask:
6942 case X86::BI__builtin_ia32_vcvtph2udq512_mask:
6943 case X86::BI__builtin_ia32_vcvtph2qq512_mask:
6944 case X86::BI__builtin_ia32_vcvtph2uqq512_mask:
6945 case X86::BI__builtin_ia32_vcvtqq2ph512_mask:
6946 case X86::BI__builtin_ia32_vcvtuqq2ph512_mask:
6950 case X86::BI__builtin_ia32_addsh_round_mask:
6951 case X86::BI__builtin_ia32_addss_round_mask:
6952 case X86::BI__builtin_ia32_addsd_round_mask:
6953 case X86::BI__builtin_ia32_divsh_round_mask:
6954 case X86::BI__builtin_ia32_divss_round_mask:
6955 case X86::BI__builtin_ia32_divsd_round_mask:
6956 case X86::BI__builtin_ia32_mulsh_round_mask:
6957 case X86::BI__builtin_ia32_mulss_round_mask:
6958 case X86::BI__builtin_ia32_mulsd_round_mask:
6959 case X86::BI__builtin_ia32_subsh_round_mask:
6960 case X86::BI__builtin_ia32_subss_round_mask:
6961 case X86::BI__builtin_ia32_subsd_round_mask:
6962 case X86::BI__builtin_ia32_scalefph512_mask:
6963 case X86::BI__builtin_ia32_scalefpd512_mask:
6964 case X86::BI__builtin_ia32_scalefps512_mask:
6965 case X86::BI__builtin_ia32_scalefsd_round_mask:
6966 case X86::BI__builtin_ia32_scalefss_round_mask:
6967 case X86::BI__builtin_ia32_scalefsh_round_mask:
6968 case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
6969 case X86::BI__builtin_ia32_vcvtss2sh_round_mask:
6970 case X86::BI__builtin_ia32_vcvtsd2sh_round_mask:
6971 case X86::BI__builtin_ia32_sqrtsd_round_mask:
6972 case X86::BI__builtin_ia32_sqrtss_round_mask:
6973 case X86::BI__builtin_ia32_sqrtsh_round_mask:
6974 case X86::BI__builtin_ia32_vfmaddsd3_mask:
6975 case X86::BI__builtin_ia32_vfmaddsd3_maskz:
6976 case X86::BI__builtin_ia32_vfmaddsd3_mask3:
6977 case X86::BI__builtin_ia32_vfmaddss3_mask:
6978 case X86::BI__builtin_ia32_vfmaddss3_maskz:
6979 case X86::BI__builtin_ia32_vfmaddss3_mask3:
6980 case X86::BI__builtin_ia32_vfmaddsh3_mask:
6981 case X86::BI__builtin_ia32_vfmaddsh3_maskz:
6982 case X86::BI__builtin_ia32_vfmaddsh3_mask3:
6983 case X86::BI__builtin_ia32_vfmaddpd512_mask:
6984 case X86::BI__builtin_ia32_vfmaddpd512_maskz:
6985 case X86::BI__builtin_ia32_vfmaddpd512_mask3:
6986 case X86::BI__builtin_ia32_vfmsubpd512_mask3:
6987 case X86::BI__builtin_ia32_vfmaddps512_mask:
6988 case X86::BI__builtin_ia32_vfmaddps512_maskz:
6989 case X86::BI__builtin_ia32_vfmaddps512_mask3:
6990 case X86::BI__builtin_ia32_vfmsubps512_mask3:
6991 case X86::BI__builtin_ia32_vfmaddph512_mask:
6992 case X86::BI__builtin_ia32_vfmaddph512_maskz:
6993 case X86::BI__builtin_ia32_vfmaddph512_mask3:
6994 case X86::BI__builtin_ia32_vfmsubph512_mask3:
6995 case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
6996 case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
6997 case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
6998 case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
6999 case X86::BI__builtin_ia32_vfmaddsubps512_mask:
7000 case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
7001 case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
7002 case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
7003 case X86::BI__builtin_ia32_vfmaddsubph512_mask:
7004 case X86::BI__builtin_ia32_vfmaddsubph512_maskz:
7005 case X86::BI__builtin_ia32_vfmaddsubph512_mask3:
7006 case X86::BI__builtin_ia32_vfmsubaddph512_mask3:
7007 case X86::BI__builtin_ia32_vfmaddcsh_mask:
7008 case X86::BI__builtin_ia32_vfmaddcsh_round_mask:
7009 case X86::BI__builtin_ia32_vfmaddcsh_round_mask3:
7010 case X86::BI__builtin_ia32_vfmaddcph512_mask:
7011 case X86::BI__builtin_ia32_vfmaddcph512_maskz:
7012 case X86::BI__builtin_ia32_vfmaddcph512_mask3:
7013 case X86::BI__builtin_ia32_vfcmaddcsh_mask:
7014 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask:
7015 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask3:
7016 case X86::BI__builtin_ia32_vfcmaddcph512_mask:
7017 case X86::BI__builtin_ia32_vfcmaddcph512_maskz:
7018 case X86::BI__builtin_ia32_vfcmaddcph512_mask3:
7019 case X86::BI__builtin_ia32_vfmulcsh_mask:
7020 case X86::BI__builtin_ia32_vfmulcph512_mask:
7021 case X86::BI__builtin_ia32_vfcmulcsh_mask:
7022 case X86::BI__builtin_ia32_vfcmulcph512_mask:
7036 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7045 (!HasRC &&
Result == 12) ||
7046 (HasRC &&
Result.getZExtValue() >= 8 &&
Result.getZExtValue() <= 11))
7049 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
7054bool Sema::CheckX86BuiltinGatherScatterScale(
unsigned BuiltinID,
7056 unsigned ArgNum = 0;
7057 switch (BuiltinID) {
7060 case X86::BI__builtin_ia32_gatherpfdpd:
7061 case X86::BI__builtin_ia32_gatherpfdps:
7062 case X86::BI__builtin_ia32_gatherpfqpd:
7063 case X86::BI__builtin_ia32_gatherpfqps:
7064 case X86::BI__builtin_ia32_scatterpfdpd:
7065 case X86::BI__builtin_ia32_scatterpfdps:
7066 case X86::BI__builtin_ia32_scatterpfqpd:
7067 case X86::BI__builtin_ia32_scatterpfqps:
7070 case X86::BI__builtin_ia32_gatherd_pd:
7071 case X86::BI__builtin_ia32_gatherd_pd256:
7072 case X86::BI__builtin_ia32_gatherq_pd:
7073 case X86::BI__builtin_ia32_gatherq_pd256:
7074 case X86::BI__builtin_ia32_gatherd_ps:
7075 case X86::BI__builtin_ia32_gatherd_ps256:
7076 case X86::BI__builtin_ia32_gatherq_ps:
7077 case X86::BI__builtin_ia32_gatherq_ps256:
7078 case X86::BI__builtin_ia32_gatherd_q:
7079 case X86::BI__builtin_ia32_gatherd_q256:
7080 case X86::BI__builtin_ia32_gatherq_q:
7081 case X86::BI__builtin_ia32_gatherq_q256:
7082 case X86::BI__builtin_ia32_gatherd_d:
7083 case X86::BI__builtin_ia32_gatherd_d256:
7084 case X86::BI__builtin_ia32_gatherq_d:
7085 case X86::BI__builtin_ia32_gatherq_d256:
7086 case X86::BI__builtin_ia32_gather3div2df:
7087 case X86::BI__builtin_ia32_gather3div2di:
7088 case X86::BI__builtin_ia32_gather3div4df:
7089 case X86::BI__builtin_ia32_gather3div4di:
7090 case X86::BI__builtin_ia32_gather3div4sf:
7091 case X86::BI__builtin_ia32_gather3div4si:
7092 case X86::BI__builtin_ia32_gather3div8sf:
7093 case X86::BI__builtin_ia32_gather3div8si:
7094 case X86::BI__builtin_ia32_gather3siv2df:
7095 case X86::BI__builtin_ia32_gather3siv2di:
7096 case X86::BI__builtin_ia32_gather3siv4df:
7097 case X86::BI__builtin_ia32_gather3siv4di:
7098 case X86::BI__builtin_ia32_gather3siv4sf:
7099 case X86::BI__builtin_ia32_gather3siv4si:
7100 case X86::BI__builtin_ia32_gather3siv8sf:
7101 case X86::BI__builtin_ia32_gather3siv8si:
7102 case X86::BI__builtin_ia32_gathersiv8df:
7103 case X86::BI__builtin_ia32_gathersiv16sf:
7104 case X86::BI__builtin_ia32_gatherdiv8df:
7105 case X86::BI__builtin_ia32_gatherdiv16sf:
7106 case X86::BI__builtin_ia32_gathersiv8di:
7107 case X86::BI__builtin_ia32_gathersiv16si:
7108 case X86::BI__builtin_ia32_gatherdiv8di:
7109 case X86::BI__builtin_ia32_gatherdiv16si:
7110 case X86::BI__builtin_ia32_scatterdiv2df:
7111 case X86::BI__builtin_ia32_scatterdiv2di:
7112 case X86::BI__builtin_ia32_scatterdiv4df:
7113 case X86::BI__builtin_ia32_scatterdiv4di:
7114 case X86::BI__builtin_ia32_scatterdiv4sf:
7115 case X86::BI__builtin_ia32_scatterdiv4si:
7116 case X86::BI__builtin_ia32_scatterdiv8sf:
7117 case X86::BI__builtin_ia32_scatterdiv8si:
7118 case X86::BI__builtin_ia32_scattersiv2df:
7119 case X86::BI__builtin_ia32_scattersiv2di:
7120 case X86::BI__builtin_ia32_scattersiv4df:
7121 case X86::BI__builtin_ia32_scattersiv4di:
7122 case X86::BI__builtin_ia32_scattersiv4sf:
7123 case X86::BI__builtin_ia32_scattersiv4si:
7124 case X86::BI__builtin_ia32_scattersiv8sf:
7125 case X86::BI__builtin_ia32_scattersiv8si:
7126 case X86::BI__builtin_ia32_scattersiv8df:
7127 case X86::BI__builtin_ia32_scattersiv16sf:
7128 case X86::BI__builtin_ia32_scatterdiv8df:
7129 case X86::BI__builtin_ia32_scatterdiv16sf:
7130 case X86::BI__builtin_ia32_scattersiv8di:
7131 case X86::BI__builtin_ia32_scattersiv16si:
7132 case X86::BI__builtin_ia32_scatterdiv8di:
7133 case X86::BI__builtin_ia32_scatterdiv16si:
7146 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7152 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_scale)
7158bool Sema::CheckX86BuiltinTileArgumentsRange(
CallExpr *TheCall,
7160 for (
int ArgNum : ArgNums) {
7167bool Sema::CheckX86BuiltinTileDuplicate(
CallExpr *TheCall,
7171 std::bitset<TileRegHigh + 1> ArgValues;
7172 for (
int ArgNum : ArgNums) {
7178 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
7180 int ArgExtValue =
Result.getExtValue();
7182 "Incorrect tile register num.");
7183 if (ArgValues.test(ArgExtValue))
7185 diag::err_x86_builtin_tile_arg_duplicate)
7187 ArgValues.set(ArgExtValue);
7192bool Sema::CheckX86BuiltinTileRangeAndDuplicate(
CallExpr *TheCall,
7194 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
7195 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
7198bool Sema::CheckX86BuiltinTileArguments(
unsigned BuiltinID,
CallExpr *TheCall) {
7199 switch (BuiltinID) {
7202 case X86::BI__builtin_ia32_tileloadd64:
7203 case X86::BI__builtin_ia32_tileloaddt164:
7204 case X86::BI__builtin_ia32_tilestored64:
7205 case X86::BI__builtin_ia32_tilezero:
7206 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
7207 case X86::BI__builtin_ia32_tdpbssd:
7208 case X86::BI__builtin_ia32_tdpbsud:
7209 case X86::BI__builtin_ia32_tdpbusd:
7210 case X86::BI__builtin_ia32_tdpbuud:
7211 case X86::BI__builtin_ia32_tdpbf16ps:
7212 case X86::BI__builtin_ia32_tdpfp16ps:
7213 case X86::BI__builtin_ia32_tcmmimfp16ps:
7214 case X86::BI__builtin_ia32_tcmmrlfp16ps:
7215 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
7220 switch (BuiltinID) {
7221 case X86::BI__builtin_ia32_readeflags_u32:
7222 case X86::BI__builtin_ia32_writeeflags_u32:
7229bool Sema::CheckX86BuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
7232 const llvm::Triple &TT = TI.
getTriple();
7235 diag::err_32_bit_builtin_64_bit_tgt);
7238 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
7242 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
7246 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
7251 int i = 0, l = 0, u = 0;
7252 switch (BuiltinID) {
7255 case X86::BI__builtin_ia32_vec_ext_v2si:
7256 case X86::BI__builtin_ia32_vec_ext_v2di:
7257 case X86::BI__builtin_ia32_vextractf128_pd256:
7258 case X86::BI__builtin_ia32_vextractf128_ps256:
7259 case X86::BI__builtin_ia32_vextractf128_si256:
7260 case X86::BI__builtin_ia32_extract128i256:
7261 case X86::BI__builtin_ia32_extractf64x4_mask:
7262 case X86::BI__builtin_ia32_extracti64x4_mask:
7263 case X86::BI__builtin_ia32_extractf32x8_mask:
7264 case X86::BI__builtin_ia32_extracti32x8_mask:
7265 case X86::BI__builtin_ia32_extractf64x2_256_mask:
7266 case X86::BI__builtin_ia32_extracti64x2_256_mask:
7267 case X86::BI__builtin_ia32_extractf32x4_256_mask:
7268 case X86::BI__builtin_ia32_extracti32x4_256_mask:
7269 i = 1; l = 0; u = 1;
7271 case X86::BI__builtin_ia32_vec_set_v2di:
7272 case X86::BI__builtin_ia32_vinsertf128_pd256:
7273 case X86::BI__builtin_ia32_vinsertf128_ps256:
7274 case X86::BI__builtin_ia32_vinsertf128_si256:
7275 case X86::BI__builtin_ia32_insert128i256:
7276 case X86::BI__builtin_ia32_insertf32x8:
7277 case X86::BI__builtin_ia32_inserti32x8:
7278 case X86::BI__builtin_ia32_insertf64x4:
7279 case X86::BI__builtin_ia32_inserti64x4:
7280 case X86::BI__builtin_ia32_insertf64x2_256:
7281 case X86::BI__builtin_ia32_inserti64x2_256:
7282 case X86::BI__builtin_ia32_insertf32x4_256:
7283 case X86::BI__builtin_ia32_inserti32x4_256:
7284 i = 2; l = 0; u = 1;
7286 case X86::BI__builtin_ia32_vpermilpd:
7287 case X86::BI__builtin_ia32_vec_ext_v4hi:
7288 case X86::BI__builtin_ia32_vec_ext_v4si:
7289 case X86::BI__builtin_ia32_vec_ext_v4sf:
7290 case X86::BI__builtin_ia32_vec_ext_v4di:
7291 case X86::BI__builtin_ia32_extractf32x4_mask:
7292 case X86::BI__builtin_ia32_extracti32x4_mask:
7293 case X86::BI__builtin_ia32_extractf64x2_512_mask:
7294 case X86::BI__builtin_ia32_extracti64x2_512_mask:
7295 i = 1; l = 0; u = 3;
7297 case X86::BI_mm_prefetch:
7298 case X86::BI__builtin_ia32_vec_ext_v8hi:
7299 case X86::BI__builtin_ia32_vec_ext_v8si:
7300 i = 1; l = 0; u = 7;
7302 case X86::BI__builtin_ia32_sha1rnds4:
7303 case X86::BI__builtin_ia32_blendpd:
7304 case X86::BI__builtin_ia32_shufpd:
7305 case X86::BI__builtin_ia32_vec_set_v4hi:
7306 case X86::BI__builtin_ia32_vec_set_v4si:
7307 case X86::BI__builtin_ia32_vec_set_v4di:
7308 case X86::BI__builtin_ia32_shuf_f32x4_256:
7309 case X86::BI__builtin_ia32_shuf_f64x2_256:
7310 case X86::BI__builtin_ia32_shuf_i32x4_256:
7311 case X86::BI__builtin_ia32_shuf_i64x2_256:
7312 case X86::BI__builtin_ia32_insertf64x2_512:
7313 case X86::BI__builtin_ia32_inserti64x2_512:
7314 case X86::BI__builtin_ia32_insertf32x4:
7315 case X86::BI__builtin_ia32_inserti32x4:
7316 i = 2; l = 0; u = 3;
7318 case X86::BI__builtin_ia32_vpermil2pd:
7319 case X86::BI__builtin_ia32_vpermil2pd256:
7320 case X86::BI__builtin_ia32_vpermil2ps:
7321 case X86::BI__builtin_ia32_vpermil2ps256:
7322 i = 3; l = 0; u = 3;
7324 case X86::BI__builtin_ia32_cmpb128_mask:
7325 case X86::BI__builtin_ia32_cmpw128_mask:
7326 case X86::BI__builtin_ia32_cmpd128_mask:
7327 case X86::BI__builtin_ia32_cmpq128_mask:
7328 case X86::BI__builtin_ia32_cmpb256_mask:
7329 case X86::BI__builtin_ia32_cmpw256_mask:
7330 case X86::BI__builtin_ia32_cmpd256_mask:
7331 case X86::BI__builtin_ia32_cmpq256_mask:
7332 case X86::BI__builtin_ia32_cmpb512_mask:
7333 case X86::BI__builtin_ia32_cmpw512_mask:
7334 case X86::BI__builtin_ia32_cmpd512_mask:
7335 case X86::BI__builtin_ia32_cmpq512_mask:
7336 case X86::BI__builtin_ia32_ucmpb128_mask:
7337 case X86::BI__builtin_ia32_ucmpw128_mask:
7338 case X86::BI__builtin_ia32_ucmpd128_mask:
7339 case X86::BI__builtin_ia32_ucmpq128_mask:
7340 case X86::BI__builtin_ia32_ucmpb256_mask:
7341 case X86::BI__builtin_ia32_ucmpw256_mask:
7342 case X86::BI__builtin_ia32_ucmpd256_mask:
7343 case X86::BI__builtin_ia32_ucmpq256_mask:
7344 case X86::BI__builtin_ia32_ucmpb512_mask:
7345 case X86::BI__builtin_ia32_ucmpw512_mask:
7346 case X86::BI__builtin_ia32_ucmpd512_mask:
7347 case X86::BI__builtin_ia32_ucmpq512_mask:
7348 case X86::BI__builtin_ia32_vpcomub:
7349 case X86::BI__builtin_ia32_vpcomuw:
7350 case X86::BI__builtin_ia32_vpcomud:
7351 case X86::BI__builtin_ia32_vpcomuq:
7352 case X86::BI__builtin_ia32_vpcomb:
7353 case X86::BI__builtin_ia32_vpcomw:
7354 case X86::BI__builtin_ia32_vpcomd:
7355 case X86::BI__builtin_ia32_vpcomq:
7356 case X86::BI__builtin_ia32_vec_set_v8hi:
7357 case X86::BI__builtin_ia32_vec_set_v8si:
7358 i = 2; l = 0; u = 7;
7360 case X86::BI__builtin_ia32_vpermilpd256:
7361 case X86::BI__builtin_ia32_roundps:
7362 case X86::BI__builtin_ia32_roundpd:
7363 case X86::BI__builtin_ia32_roundps256:
7364 case X86::BI__builtin_ia32_roundpd256:
7365 case X86::BI__builtin_ia32_getmantpd128_mask:
7366 case X86::BI__builtin_ia32_getmantpd256_mask:
7367 case X86::BI__builtin_ia32_getmantps128_mask:
7368 case X86::BI__builtin_ia32_getmantps256_mask:
7369 case X86::BI__builtin_ia32_getmantpd512_mask:
7370 case X86::BI__builtin_ia32_getmantps512_mask:
7371 case X86::BI__builtin_ia32_getmantph128_mask:
7372 case X86::BI__builtin_ia32_getmantph256_mask:
7373 case X86::BI__builtin_ia32_getmantph512_mask:
7374 case X86::BI__builtin_ia32_vec_ext_v16qi:
7375 case X86::BI__builtin_ia32_vec_ext_v16hi:
7376 i = 1; l = 0; u = 15;
7378 case X86::BI__builtin_ia32_pblendd128:
7379 case X86::BI__builtin_ia32_blendps:
7380 case X86::BI__builtin_ia32_blendpd256:
7381 case X86::BI__builtin_ia32_shufpd256:
7382 case X86::BI__builtin_ia32_roundss:
7383 case X86::BI__builtin_ia32_roundsd:
7384 case X86::BI__builtin_ia32_rangepd128_mask:
7385 case X86::BI__builtin_ia32_rangepd256_mask:
7386 case X86::BI__builtin_ia32_rangepd512_mask:
7387 case X86::BI__builtin_ia32_rangeps128_mask:
7388 case X86::BI__builtin_ia32_rangeps256_mask:
7389 case X86::BI__builtin_ia32_rangeps512_mask:
7390 case X86::BI__builtin_ia32_getmantsd_round_mask:
7391 case X86::BI__builtin_ia32_getmantss_round_mask:
7392 case X86::BI__builtin_ia32_getmantsh_round_mask:
7393 case X86::BI__builtin_ia32_vec_set_v16qi:
7394 case X86::BI__builtin_ia32_vec_set_v16hi:
7395 i = 2; l = 0; u = 15;
7397 case X86::BI__builtin_ia32_vec_ext_v32qi:
7398 i = 1; l = 0; u = 31;
7400 case X86::BI__builtin_ia32_cmpps:
7401 case X86::BI__builtin_ia32_cmpss:
7402 case X86::BI__builtin_ia32_cmppd:
7403 case X86::BI__builtin_ia32_cmpsd:
7404 case X86::BI__builtin_ia32_cmpps256:
7405 case X86::BI__builtin_ia32_cmppd256:
7406 case X86::BI__builtin_ia32_cmpps128_mask:
7407 case X86::BI__builtin_ia32_cmppd128_mask:
7408 case X86::BI__builtin_ia32_cmpps256_mask:
7409 case X86::BI__builtin_ia32_cmppd256_mask:
7410 case X86::BI__builtin_ia32_cmpps512_mask:
7411 case X86::BI__builtin_ia32_cmppd512_mask:
7412 case X86::BI__builtin_ia32_cmpsd_mask:
7413 case X86::BI__builtin_ia32_cmpss_mask:
7414 case X86::BI__builtin_ia32_vec_set_v32qi:
7415 i = 2; l = 0; u = 31;
7417 case X86::BI__builtin_ia32_permdf256:
7418 case X86::BI__builtin_ia32_permdi256:
7419 case X86::BI__builtin_ia32_permdf512:
7420 case X86::BI__builtin_ia32_permdi512:
7421 case X86::BI__builtin_ia32_vpermilps:
7422 case X86::BI__builtin_ia32_vpermilps256:
7423 case X86::BI__builtin_ia32_vpermilpd512:
7424 case X86::BI__builtin_ia32_vpermilps512:
7425 case X86::BI__builtin_ia32_pshufd:
7426 case X86::BI__builtin_ia32_pshufd256:
7427 case X86::BI__builtin_ia32_pshufd512:
7428 case X86::BI__builtin_ia32_pshufhw:
7429 case X86::BI__builtin_ia32_pshufhw256:
7430 case X86::BI__builtin_ia32_pshufhw512:
7431 case X86::BI__builtin_ia32_pshuflw:
7432 case X86::BI__builtin_ia32_pshuflw256:
7433 case X86::BI__builtin_ia32_pshuflw512:
7434 case X86::BI__builtin_ia32_vcvtps2ph:
7435 case X86::BI__builtin_ia32_vcvtps2ph_mask:
7436 case X86::BI__builtin_ia32_vcvtps2ph256:
7437 case X86::BI__builtin_ia32_vcvtps2ph256_mask:
7438 case X86::BI__builtin_ia32_vcvtps2ph512_mask:
7439 case X86::BI__builtin_ia32_rndscaleps_128_mask:
7440 case X86::BI__builtin_ia32_rndscalepd_128_mask:
7441 case X86::BI__builtin_ia32_rndscaleps_256_mask:
7442 case X86::BI__builtin_ia32_rndscalepd_256_mask:
7443 case X86::BI__builtin_ia32_rndscaleps_mask:
7444 case X86::BI__builtin_ia32_rndscalepd_mask:
7445 case X86::BI__builtin_ia32_rndscaleph_mask:
7446 case X86::BI__builtin_ia32_reducepd128_mask:
7447 case X86::BI__builtin_ia32_reducepd256_mask:
7448 case X86::BI__builtin_ia32_reducepd512_mask:
7449 case X86::BI__builtin_ia32_reduceps128_mask:
7450 case X86::BI__builtin_ia32_reduceps256_mask:
7451 case X86::BI__builtin_ia32_reduceps512_mask:
7452 case X86::BI__builtin_ia32_reduceph128_mask:
7453 case X86::BI__builtin_ia32_reduceph256_mask:
7454 case X86::BI__builtin_ia32_reduceph512_mask:
7455 case X86::BI__builtin_ia32_prold512:
7456 case X86::BI__builtin_ia32_prolq512:
7457 case X86::BI__builtin_ia32_prold128:
7458 case X86::BI__builtin_ia32_prold256:
7459 case X86::BI__builtin_ia32_prolq128:
7460 case X86::BI__builtin_ia32_prolq256:
7461 case X86::BI__builtin_ia32_prord512:
7462 case X86::BI__builtin_ia32_prorq512:
7463 case X86::BI__builtin_ia32_prord128:
7464 case X86::BI__builtin_ia32_prord256:
7465 case X86::BI__builtin_ia32_prorq128:
7466 case X86::BI__builtin_ia32_prorq256:
7467 case X86::BI__builtin_ia32_fpclasspd128_mask:
7468 case X86::BI__builtin_ia32_fpclasspd256_mask:
7469 case X86::BI__builtin_ia32_fpclassps128_mask:
7470 case X86::BI__builtin_ia32_fpclassps256_mask:
7471 case X86::BI__builtin_ia32_fpclassps512_mask:
7472 case X86::BI__builtin_ia32_fpclasspd512_mask:
7473 case X86::BI__builtin_ia32_fpclassph128_mask:
7474 case X86::BI__builtin_ia32_fpclassph256_mask:
7475 case X86::BI__builtin_ia32_fpclassph512_mask:
7476 case X86::BI__builtin_ia32_fpclasssd_mask:
7477 case X86::BI__builtin_ia32_fpclassss_mask:
7478 case X86::BI__builtin_ia32_fpclasssh_mask:
7479 case X86::BI__builtin_ia32_pslldqi128_byteshift:
7480 case X86::BI__builtin_ia32_pslldqi256_byteshift:
7481 case X86::BI__builtin_ia32_pslldqi512_byteshift:
7482 case X86::BI__builtin_ia32_psrldqi128_byteshift:
7483 case X86::BI__builtin_ia32_psrldqi256_byteshift:
7484 case X86::BI__builtin_ia32_psrldqi512_byteshift:
7485 case X86::BI__builtin_ia32_kshiftliqi:
7486 case X86::BI__builtin_ia32_kshiftlihi:
7487 case X86::BI__builtin_ia32_kshiftlisi:
7488 case X86::BI__builtin_ia32_kshiftlidi:
7489 case X86::BI__builtin_ia32_kshiftriqi:
7490 case X86::BI__builtin_ia32_kshiftrihi:
7491 case X86::BI__builtin_ia32_kshiftrisi:
7492 case X86::BI__builtin_ia32_kshiftridi:
7493 i = 1; l = 0; u = 255;
7495 case X86::BI__builtin_ia32_vperm2f128_pd256:
7496 case X86::BI__builtin_ia32_vperm2f128_ps256:
7497 case X86::BI__builtin_ia32_vperm2f128_si256:
7498 case X86::BI__builtin_ia32_permti256:
7499 case X86::BI__builtin_ia32_pblendw128:
7500 case X86::BI__builtin_ia32_pblendw256:
7501 case X86::BI__builtin_ia32_blendps256:
7502 case X86::BI__builtin_ia32_pblendd256:
7503 case X86::BI__builtin_ia32_palignr128:
7504 case X86::BI__builtin_ia32_palignr256:
7505 case X86::BI__builtin_ia32_palignr512:
7506 case X86::BI__builtin_ia32_alignq512:
7507 case X86::BI__builtin_ia32_alignd512:
7508 case X86::BI__builtin_ia32_alignd128:
7509 case X86::BI__builtin_ia32_alignd256:
7510 case X86::BI__builtin_ia32_alignq128:
7511 case X86::BI__builtin_ia32_alignq256:
7512 case X86::BI__builtin_ia32_vcomisd:
7513 case X86::BI__builtin_ia32_vcomiss:
7514 case X86::BI__builtin_ia32_shuf_f32x4:
7515 case X86::BI__builtin_ia32_shuf_f64x2:
7516 case X86::BI__builtin_ia32_shuf_i32x4:
7517 case X86::BI__builtin_ia32_shuf_i64x2:
7518 case X86::BI__builtin_ia32_shufpd512:
7519 case X86::BI__builtin_ia32_shufps:
7520 case X86::BI__builtin_ia32_shufps256:
7521 case X86::BI__builtin_ia32_shufps512:
7522 case X86::BI__builtin_ia32_dbpsadbw128:
7523 case X86::BI__builtin_ia32_dbpsadbw256:
7524 case X86::BI__builtin_ia32_dbpsadbw512:
7525 case X86::BI__builtin_ia32_vpshldd128:
7526 case X86::BI__builtin_ia32_vpshldd256:
7527 case X86::BI__builtin_ia32_vpshldd512:
7528 case X86::BI__builtin_ia32_vpshldq128:
7529 case X86::BI__builtin_ia32_vpshldq256:
7530 case X86::BI__builtin_ia32_vpshldq512:
7531 case X86::BI__builtin_ia32_vpshldw128:
7532 case X86::BI__builtin_ia32_vpshldw256:
7533 case X86::BI__builtin_ia32_vpshldw512:
7534 case X86::BI__builtin_ia32_vpshrdd128:
7535 case X86::BI__builtin_ia32_vpshrdd256:
7536 case X86::BI__builtin_ia32_vpshrdd512:
7537 case X86::BI__builtin_ia32_vpshrdq128:
7538 case X86::BI__builtin_ia32_vpshrdq256:
7539 case X86::BI__builtin_ia32_vpshrdq512:
7540 case X86::BI__builtin_ia32_vpshrdw128:
7541 case X86::BI__builtin_ia32_vpshrdw256:
7542 case X86::BI__builtin_ia32_vpshrdw512:
7543 i = 2; l = 0; u = 255;
7545 case X86::BI__builtin_ia32_fixupimmpd512_mask:
7546 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
7547 case X86::BI__builtin_ia32_fixupimmps512_mask:
7548 case X86::BI__builtin_ia32_fixupimmps512_maskz:
7549 case X86::BI__builtin_ia32_fixupimmsd_mask:
7550 case X86::BI__builtin_ia32_fixupimmsd_maskz:
7551 case X86::BI__builtin_ia32_fixupimmss_mask:
7552 case X86::BI__builtin_ia32_fixupimmss_maskz:
7553 case X86::BI__builtin_ia32_fixupimmpd128_mask:
7554 case X86::BI__builtin_ia32_fixupimmpd128_maskz:
7555 case X86::BI__builtin_ia32_fixupimmpd256_mask:
7556 case X86::BI__builtin_ia32_fixupimmpd256_maskz:
7557 case X86::BI__builtin_ia32_fixupimmps128_mask:
7558 case X86::BI__builtin_ia32_fixupimmps128_maskz:
7559 case X86::BI__builtin_ia32_fixupimmps256_mask:
7560 case X86::BI__builtin_ia32_fixupimmps256_maskz:
7561 case X86::BI__builtin_ia32_pternlogd512_mask:
7562 case X86::BI__builtin_ia32_pternlogd512_maskz:
7563 case X86::BI__builtin_ia32_pternlogq512_mask:
7564 case X86::BI__builtin_ia32_pternlogq512_maskz:
7565 case X86::BI__builtin_ia32_pternlogd128_mask:
7566 case X86::BI__builtin_ia32_pternlogd128_maskz:
7567 case X86::BI__builtin_ia32_pternlogd256_mask:
7568 case X86::BI__builtin_ia32_pternlogd256_maskz:
7569 case X86::BI__builtin_ia32_pternlogq128_mask:
7570 case X86::BI__builtin_ia32_pternlogq128_maskz:
7571 case X86::BI__builtin_ia32_pternlogq256_mask:
7572 case X86::BI__builtin_ia32_pternlogq256_maskz:
7573 case X86::BI__builtin_ia32_vsm3rnds2:
7574 i = 3; l = 0; u = 255;
7576 case X86::BI__builtin_ia32_gatherpfdpd:
7577 case X86::BI__builtin_ia32_gatherpfdps:
7578 case X86::BI__builtin_ia32_gatherpfqpd:
7579 case X86::BI__builtin_ia32_gatherpfqps:
7580 case X86::BI__builtin_ia32_scatterpfdpd:
7581 case X86::BI__builtin_ia32_scatterpfdps:
7582 case X86::BI__builtin_ia32_scatterpfqpd:
7583 case X86::BI__builtin_ia32_scatterpfqps:
7584 i = 4; l = 2; u = 3;
7586 case X86::BI__builtin_ia32_reducesd_mask:
7587 case X86::BI__builtin_ia32_reducess_mask:
7588 case X86::BI__builtin_ia32_rndscalesd_round_mask:
7589 case X86::BI__builtin_ia32_rndscaless_round_mask:
7590 case X86::BI__builtin_ia32_rndscalesh_round_mask:
7591 case X86::BI__builtin_ia32_reducesh_mask:
7592 i = 4; l = 0; u = 255;
7594 case X86::BI__builtin_ia32_cmpccxadd32:
7595 case X86::BI__builtin_ia32_cmpccxadd64:
7596 i = 3; l = 0; u = 15;
7604 return BuiltinConstantArgRange(TheCall, i, l, u,
false);
7613 if (Format->getFirstArg() == 0)
7615 else if (IsVariadic)
7619 FSI->
FormatIdx = Format->getFormatIdx() - 1;
7643 if (isa<CXXNullPtrLiteralExpr>(
7658 if (
const auto *CLE = dyn_cast<CompoundLiteralExpr>(
Expr))
7659 if (
const auto *ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))
7660 Expr = ILE->getInit(0);
7670 const Expr *ArgExpr,
7674 S.
PDiag(diag::warn_null_arg)
7696 bool Format =
false;
7709 if (!Format || NumArgs <= Idx)
7711 const Expr *FormatExpr = Args[Idx];
7712 if (
const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
7713 FormatExpr = CSCE->getSubExpr();
7723 S.
Diag(FormatExpr->
getExprLoc(), diag::warn_objc_cdirective_format_string)
7732 if (
auto nullability =
type->getNullability())
7743 assert((FDecl || Proto) &&
"Need a function declaration or prototype");
7749 llvm::SmallBitVector NonNullArgs;
7755 for (
const auto *Arg : Args)
7762 unsigned IdxAST = Idx.getASTIndex();
7763 if (IdxAST >= Args.size())
7765 if (NonNullArgs.empty())
7766 NonNullArgs.resize(Args.size());
7767 NonNullArgs.set(IdxAST);
7772 if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
7776 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
7779 parms = cast<ObjCMethodDecl>(FDecl)->parameters();
7781 unsigned ParamIndex = 0;
7783 I != E; ++I, ++ParamIndex) {
7786 if (NonNullArgs.empty())
7787 NonNullArgs.resize(Args.size());
7789 NonNullArgs.set(ParamIndex);
7796 if (
const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
7801 type = blockType->getPointeeType();
7815 if (NonNullArgs.empty())
7816 NonNullArgs.resize(Args.size());
7818 NonNullArgs.set(Index);
7827 for (
unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
7828 ArgIndex != ArgIndexEnd; ++ArgIndex) {
7829 if (NonNullArgs[ArgIndex])
7842 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->
IgnoreParens());
7846 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
7850 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
7851 if (!PD || !PD->getType()->isRecordType())
7857 if (
const auto *AA = FD->
getAttr<AlignedAttr>()) {
7862 Diag(
Loc, diag::note_misaligned_member_used_here) << PD;
7873 StringRef ParamName,
QualType ArgTy,
7901 if (ArgAlign < ParamAlign)
7902 Diag(
Loc, diag::warn_param_mismatched_alignment)
7904 << ParamName << (FDecl !=
nullptr) << FDecl;
7919 llvm::SmallBitVector CheckedVarArgs;
7923 CheckedVarArgs.resize(Args.size());
7925 CheckFormatArguments(I, Args, IsMemberFunction, CallType,
Loc,
Range,
7932 auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
7936 : FDecl && isa<FunctionDecl>(FDecl)
7937 ? cast<FunctionDecl>(FDecl)->getNumParams()
7938 : FDecl && isa<ObjCMethodDecl>(FDecl)
7939 ? cast<ObjCMethodDecl>(FDecl)->param_size()
7942 for (
unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
7944 if (
const Expr *Arg = Args[ArgIdx]) {
7945 if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
7951 if (FDecl || Proto) {
7956 for (
const auto *I : FDecl->
specific_attrs<ArgumentWithTypeTagAttr>())
7957 CheckArgumentWithTypeTag(I, Args,
Loc);
7963 if (!Proto && FDecl) {
7965 if (isa_and_nonnull<FunctionProtoType>(FT))
7971 const auto N = std::min<unsigned>(Proto->
getNumParams(), Args.size());
7973 bool IsScalableArg =
false;
7974 for (
unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
7976 if (
const Expr *Arg = Args[ArgIdx]) {
7984 checkAIXMemberAlignment((Arg->
getExprLoc()), Arg);
7988 IsScalableArg =
true;
7990 CheckArgAlignment(Arg->
getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
7999 if (
auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext)) {
8000 llvm::StringMap<bool> CallerFeatureMap;
8002 if (!CallerFeatureMap.contains(
"sme"))
8003 Diag(
Loc, diag::err_sme_call_in_non_sme_target);
8005 Diag(
Loc, diag::err_sme_call_in_non_sme_target);
8012 const auto *CallerFD = dyn_cast<FunctionDecl>(
CurContext);
8014 (IsScalableArg || IsScalableRet)) {
8015 bool IsCalleeStreaming =
8017 bool IsCalleeStreamingCompatible =
8021 if (!IsCalleeStreamingCompatible &&
8023 ((CallerFnType ==
ArmStreaming) ^ IsCalleeStreaming))) {
8025 Diag(
Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)
8028 Diag(
Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)
8039 bool CallerHasZAState =
false;
8040 bool CallerHasZT0State =
false;
8042 auto *
Attr = CallerFD->getAttr<ArmNewAttr>();
8044 CallerHasZAState =
true;
8046 CallerHasZT0State =
true;
8050 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8052 CallerHasZT0State |=
8054 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8060 Diag(
Loc, diag::err_sme_za_call_no_za_state);
8063 Diag(
Loc, diag::err_sme_zt0_call_no_zt0_state);
8067 Diag(
Loc, diag::err_sme_unimplemented_za_save_restore);
8068 Diag(
Loc, diag::note_sme_use_preserves_za);
8073 if (FDecl && FDecl->
hasAttr<AllocAlignAttr>()) {
8074 auto *AA = FDecl->
getAttr<AllocAlignAttr>();
8075 const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
8076 if (!Arg->isValueDependent()) {
8078 if (Arg->EvaluateAsInt(Align,
Context)) {
8079 const llvm::APSInt &I = Align.
Val.
getInt();
8080 if (!I.isPowerOf2())
8081 Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
8082 << Arg->getSourceRange();
8085 Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
8110 auto *Ctor = cast<CXXConstructorDecl>(FDecl);
8115 checkCall(FDecl, Proto,
nullptr, Args,
true,
8123 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
8124 isa<CXXMethodDecl>(FDecl);
8125 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
8126 IsMemberOperatorCall;
8132 Expr *ImplicitThis =
nullptr;
8137 ImplicitThis = Args[0];
8140 }
else if (IsMemberFunction && !FDecl->
isStatic() &&
8143 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
8155 cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());
8157 CheckArgAlignment(TheCall->
getRParenLoc(), FDecl,
"'this'", ThisType,
8175 CheckAbsoluteValueFunction(TheCall, FDecl);
8176 CheckMaxUnsignedZero(TheCall, FDecl);
8177 CheckInfNaNFunction(TheCall, FDecl);
8188 case Builtin::BIstrlcpy:
8189 case Builtin::BIstrlcat:
8190 CheckStrlcpycatArguments(TheCall, FnInfo);
8192 case Builtin::BIstrncat:
8193 CheckStrncatArguments(TheCall, FnInfo);
8195 case Builtin::BIfree:
8196 CheckFreeArguments(TheCall);
8199 CheckMemaccessArguments(TheCall, CMId, FnInfo);
8208 if (
const auto *
V = dyn_cast<VarDecl>(NDecl))
8209 Ty =
V->getType().getNonReferenceType();
8210 else if (
const auto *F = dyn_cast<FieldDecl>(NDecl))
8211 Ty = F->getType().getNonReferenceType();
8250 if (!llvm::isValidAtomicOrderingCABI(Ordering))
8253 auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
8255 case AtomicExpr::AO__c11_atomic_init:
8256 case AtomicExpr::AO__opencl_atomic_init:
8257 llvm_unreachable(
"There is no ordering argument for an init");
8259 case AtomicExpr::AO__c11_atomic_load:
8260 case AtomicExpr::AO__opencl_atomic_load:
8261 case AtomicExpr::AO__hip_atomic_load:
8262 case AtomicExpr::AO__atomic_load_n:
8263 case AtomicExpr::AO__atomic_load:
8264 case AtomicExpr::AO__scoped_atomic_load_n:
8265 case AtomicExpr::AO__scoped_atomic_load:
8266 return OrderingCABI != llvm::AtomicOrderingCABI::release &&
8267 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8269 case AtomicExpr::AO__c11_atomic_store:
8270 case AtomicExpr::AO__opencl_atomic_store:
8271 case AtomicExpr::AO__hip_atomic_store:
8272 case AtomicExpr::AO__atomic_store:
8273 case AtomicExpr::AO__atomic_store_n:
8274 case AtomicExpr::AO__scoped_atomic_store:
8275 case AtomicExpr::AO__scoped_atomic_store_n:
8276 return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
8277 OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
8278 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8287 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
8331 const unsigned NumForm = GNUCmpXchg + 1;
8332 const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
8333 const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
8341 static_assert(
sizeof(NumArgs)/
sizeof(NumArgs[0]) == NumForm
8342 &&
sizeof(NumVals)/
sizeof(NumVals[0]) == NumForm,
8343 "need to update code for modified forms");
8344 static_assert(AtomicExpr::AO__atomic_add_fetch == 0 &&
8345 AtomicExpr::AO__atomic_xor_fetch + 1 ==
8346 AtomicExpr::AO__c11_atomic_compare_exchange_strong,
8347 "need to update code for modified C11 atomics");
8348 bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&
8349 Op <= AtomicExpr::AO__opencl_atomic_store;
8350 bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
8351 Op <= AtomicExpr::AO__hip_atomic_store;
8352 bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&
8353 Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;
8354 bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
8355 Op <= AtomicExpr::AO__c11_atomic_store) ||
8357 bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
8358 Op == AtomicExpr::AO__atomic_store_n ||
8359 Op == AtomicExpr::AO__atomic_exchange_n ||
8360 Op == AtomicExpr::AO__atomic_compare_exchange_n ||
8361 Op == AtomicExpr::AO__scoped_atomic_load_n ||
8362 Op == AtomicExpr::AO__scoped_atomic_store_n ||
8363 Op == AtomicExpr::AO__scoped_atomic_exchange_n ||
8364 Op == AtomicExpr::AO__scoped_atomic_compare_exchange_n;
8368 enum ArithOpExtraValueType {
8373 unsigned ArithAllows = AOEVT_None;
8376 case AtomicExpr::AO__c11_atomic_init:
8377 case AtomicExpr::AO__opencl_atomic_init:
8381 case AtomicExpr::AO__c11_atomic_load:
8382 case AtomicExpr::AO__opencl_atomic_load:
8383 case AtomicExpr::AO__hip_atomic_load:
8384 case AtomicExpr::AO__atomic_load_n:
8385 case AtomicExpr::AO__scoped_atomic_load_n:
8389 case AtomicExpr::AO__atomic_load:
8390 case AtomicExpr::AO__scoped_atomic_load:
8394 case AtomicExpr::AO__c11_atomic_store:
8395 case AtomicExpr::AO__opencl_atomic_store:
8396 case AtomicExpr::AO__hip_atomic_store:
8397 case AtomicExpr::AO__atomic_store:
8398 case AtomicExpr::AO__atomic_store_n:
8399 case AtomicExpr::AO__scoped_atomic_store:
8400 case AtomicExpr::AO__scoped_atomic_store_n:
8403 case AtomicExpr::AO__atomic_fetch_add:
8404 case AtomicExpr::AO__atomic_fetch_sub:
8405 case AtomicExpr::AO__atomic_add_fetch:
8406 case AtomicExpr::AO__atomic_sub_fetch:
8407 case AtomicExpr::AO__scoped_atomic_fetch_add:
8408 case AtomicExpr::AO__scoped_atomic_fetch_sub:
8409 case AtomicExpr::AO__scoped_atomic_add_fetch:
8410 case AtomicExpr::AO__scoped_atomic_sub_fetch:
8411 case AtomicExpr::AO__c11_atomic_fetch_add:
8412 case AtomicExpr::AO__c11_atomic_fetch_sub:
8413 case AtomicExpr::AO__opencl_atomic_fetch_add:
8414 case AtomicExpr::AO__opencl_atomic_fetch_sub:
8415 case AtomicExpr::AO__hip_atomic_fetch_add:
8416 case AtomicExpr::AO__hip_atomic_fetch_sub:
8417 ArithAllows = AOEVT_Pointer | AOEVT_FP;
8420 case AtomicExpr::AO__atomic_fetch_max:
8421 case AtomicExpr::AO__atomic_fetch_min:
8422 case AtomicExpr::AO__atomic_max_fetch:
8423 case AtomicExpr::AO__atomic_min_fetch:
8424 case AtomicExpr::AO__scoped_atomic_fetch_max:
8425 case AtomicExpr::AO__scoped_atomic_fetch_min:
8426 case AtomicExpr::AO__scoped_atomic_max_fetch:
8427 case AtomicExpr::AO__scoped_atomic_min_fetch:
8428 case AtomicExpr::AO__c11_atomic_fetch_max:
8429 case AtomicExpr::AO__c11_atomic_fetch_min:
8430 case AtomicExpr::AO__opencl_atomic_fetch_max:
8431 case AtomicExpr::AO__opencl_atomic_fetch_min:
8432 case AtomicExpr::AO__hip_atomic_fetch_max:
8433 case AtomicExpr::AO__hip_atomic_fetch_min:
8434 ArithAllows = AOEVT_FP;
8437 case AtomicExpr::AO__c11_atomic_fetch_and:
8438 case AtomicExpr::AO__c11_atomic_fetch_or:
8439 case AtomicExpr::AO__c11_atomic_fetch_xor:
8440 case AtomicExpr::AO__hip_atomic_fetch_and:
8441 case AtomicExpr::AO__hip_atomic_fetch_or:
8442 case AtomicExpr::AO__hip_atomic_fetch_xor:
8443 case AtomicExpr::AO__c11_atomic_fetch_nand:
8444 case AtomicExpr::AO__opencl_atomic_fetch_and:
8445 case AtomicExpr::AO__opencl_atomic_fetch_or:
8446 case AtomicExpr::AO__opencl_atomic_fetch_xor:
8447 case AtomicExpr::AO__atomic_fetch_and:
8448 case AtomicExpr::AO__atomic_fetch_or:
8449 case AtomicExpr::AO__atomic_fetch_xor:
8450 case AtomicExpr::AO__atomic_fetch_nand:
8451 case AtomicExpr::AO__atomic_and_fetch:
8452 case AtomicExpr::AO__atomic_or_fetch:
8453 case AtomicExpr::AO__atomic_xor_fetch:
8454 case AtomicExpr::AO__atomic_nand_fetch:
8455 case AtomicExpr::AO__scoped_atomic_fetch_and:
8456 case AtomicExpr::AO__scoped_atomic_fetch_or:
8457 case AtomicExpr::AO__scoped_atomic_fetch_xor:
8458 case AtomicExpr::AO__scoped_atomic_fetch_nand:
8459 case AtomicExpr::AO__scoped_atomic_and_fetch:
8460 case AtomicExpr::AO__scoped_atomic_or_fetch:
8461 case AtomicExpr::AO__scoped_atomic_xor_fetch:
8462 case AtomicExpr::AO__scoped_atomic_nand_fetch:
8466 case AtomicExpr::AO__c11_atomic_exchange:
8467 case AtomicExpr::AO__hip_atomic_exchange:
8468 case AtomicExpr::AO__opencl_atomic_exchange:
8469 case AtomicExpr::AO__atomic_exchange_n:
8470 case AtomicExpr::AO__scoped_atomic_exchange_n:
8474 case AtomicExpr::AO__atomic_exchange:
8475 case AtomicExpr::AO__scoped_atomic_exchange:
8479 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
8480 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
8481 case AtomicExpr::AO__hip_atomic_compare_exchange_strong:
8482 case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
8483 case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
8484 case AtomicExpr::AO__hip_atomic_compare_exchange_weak:
8488 case AtomicExpr::AO__atomic_compare_exchange:
8489 case AtomicExpr::AO__atomic_compare_exchange_n:
8490 case AtomicExpr::AO__scoped_atomic_compare_exchange:
8491 case AtomicExpr::AO__scoped_atomic_compare_exchange_n:
8496 unsigned AdjustedNumArgs = NumArgs[Form];
8497 if ((IsOpenCL || IsHIP || IsScoped) &&
8498 Op != AtomicExpr::AO__opencl_atomic_init)
8501 if (Args.size() < AdjustedNumArgs) {
8502 Diag(CallRange.
getEnd(), diag::err_typecheck_call_too_few_args)
8503 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8506 }
else if (Args.size() > AdjustedNumArgs) {
8507 Diag(Args[AdjustedNumArgs]->getBeginLoc(),
8508 diag::err_typecheck_call_too_many_args)
8509 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8515 Expr *Ptr = Args[0];
8520 Ptr = ConvertedPtr.
get();
8523 Diag(ExprRange.
getBegin(), diag::err_atomic_builtin_must_be_pointer)
8533 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic)
8539 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_atomic)
8545 }
else if (Form != Load && Form != LoadCopy) {
8547 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_pointer)
8554 if (Form == Arithmetic) {
8557 auto IsAllowedValueType = [&](
QualType ValType,
8558 unsigned AllowedType) ->
bool {
8562 return AllowedType & AOEVT_Pointer;
8568 &llvm::APFloat::x87DoubleExtended())
8572 if (!IsAllowedValueType(ValType, ArithAllows)) {
8573 auto DID = ArithAllows & AOEVT_FP
8574 ? (ArithAllows & AOEVT_Pointer
8575 ? diag::err_atomic_op_needs_atomic_int_ptr_or_fp
8576 : diag::err_atomic_op_needs_atomic_int_or_fp)
8577 : diag::err_atomic_op_needs_atomic_int;
8584 diag::err_incomplete_type)) {
8590 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
8601 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_trivial_copy)
8617 Diag(ExprRange.
getBegin(), diag::err_arc_atomic_ownership)
8629 if (Form ==
Copy || Form == LoadCopy || Form == GNUXchg ||
8632 else if (Form == C11CmpXchg || Form == GNUCmpXchg)
8638 bool IsPassedByAddress =
false;
8639 if (!IsC11 && !IsHIP && !IsN) {
8641 IsPassedByAddress =
true;
8646 APIOrderedArgs.push_back(Args[0]);
8650 APIOrderedArgs.push_back(Args[1]);
8656 APIOrderedArgs.push_back(Args[2]);
8657 APIOrderedArgs.push_back(Args[1]);
8660 APIOrderedArgs.push_back(Args[2]);
8661 APIOrderedArgs.push_back(Args[3]);
8662 APIOrderedArgs.push_back(Args[1]);
8665 APIOrderedArgs.push_back(Args[2]);
8666 APIOrderedArgs.push_back(Args[4]);
8667 APIOrderedArgs.push_back(Args[1]);
8668 APIOrderedArgs.push_back(Args[3]);
8671 APIOrderedArgs.push_back(Args[2]);
8672 APIOrderedArgs.push_back(Args[4]);
8673 APIOrderedArgs.push_back(Args[5]);
8674 APIOrderedArgs.push_back(Args[1]);
8675 APIOrderedArgs.push_back(Args[3]);
8679 APIOrderedArgs.append(Args.begin(), Args.end());
8686 for (
unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
8688 if (i < NumVals[Form] + 1) {
8701 assert(Form != Load);
8704 else if (Form ==
Init || Form == Arithmetic)
8706 else if (Form ==
Copy || Form == Xchg) {
8707 if (IsPassedByAddress) {
8714 Expr *ValArg = APIOrderedArgs[i];
8721 AS = PtrTy->getPointeeType().getAddressSpace();
8730 if (IsPassedByAddress)
8750 APIOrderedArgs[i] = Arg.
get();
8755 SubExprs.push_back(Ptr);
8759 SubExprs.push_back(APIOrderedArgs[1]);
8762 SubExprs.push_back(APIOrderedArgs[1]);
8768 SubExprs.push_back(APIOrderedArgs[2]);
8769 SubExprs.push_back(APIOrderedArgs[1]);
8773 SubExprs.push_back(APIOrderedArgs[3]);
8774 SubExprs.push_back(APIOrderedArgs[1]);
8775 SubExprs.push_back(APIOrderedArgs[2]);
8778 SubExprs.push_back(APIOrderedArgs[3]);
8779 SubExprs.push_back(APIOrderedArgs[1]);
8780 SubExprs.push_back(APIOrderedArgs[4]);
8781 SubExprs.push_back(APIOrderedArgs[2]);
8784 SubExprs.push_back(APIOrderedArgs[4]);
8785 SubExprs.push_back(APIOrderedArgs[1]);
8786 SubExprs.push_back(APIOrderedArgs[5]);
8787 SubExprs.push_back(APIOrderedArgs[2]);
8788 SubExprs.push_back(APIOrderedArgs[3]);
8793 if (SubExprs.size() >= 2 && Form !=
Init) {
8794 std::optional<llvm::APSInt>
Success =
8795 SubExprs[1]->getIntegerConstantExpr(
Context);
8797 Diag(SubExprs[1]->getBeginLoc(),
8798 diag::warn_atomic_op_has_invalid_memory_order)
8799 << (Form == C11CmpXchg || Form == GNUCmpXchg)
8800 << SubExprs[1]->getSourceRange();
8802 if (SubExprs.size() >= 5) {
8803 if (std::optional<llvm::APSInt> Failure =
8804 SubExprs[3]->getIntegerConstantExpr(
Context)) {
8805 if (!llvm::is_contained(
8806 {llvm::AtomicOrderingCABI::relaxed,
8807 llvm::AtomicOrderingCABI::consume,
8808 llvm::AtomicOrderingCABI::acquire,
8809 llvm::AtomicOrderingCABI::seq_cst},
8810 (llvm::AtomicOrderingCABI)Failure->getSExtValue())) {
8811 Diag(SubExprs[3]->getBeginLoc(),
8812 diag::warn_atomic_op_has_invalid_memory_order)
8813 << 2 << SubExprs[3]->getSourceRange();
8820 auto *
Scope = Args[Args.size() - 1];
8821 if (std::optional<llvm::APSInt>
Result =
8823 if (!ScopeModel->isValid(
Result->getZExtValue()))
8824 Diag(
Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
8825 <<
Scope->getSourceRange();
8827 SubExprs.push_back(
Scope);
8833 if ((Op == AtomicExpr::AO__c11_atomic_load ||
8834 Op == AtomicExpr::AO__c11_atomic_store ||
8835 Op == AtomicExpr::AO__opencl_atomic_load ||
8836 Op == AtomicExpr::AO__hip_atomic_load ||
8837 Op == AtomicExpr::AO__opencl_atomic_store ||
8838 Op == AtomicExpr::AO__hip_atomic_store) &&
8841 << ((Op == AtomicExpr::AO__c11_atomic_load ||
8842 Op == AtomicExpr::AO__opencl_atomic_load ||
8843 Op == AtomicExpr::AO__hip_atomic_load)
8848 Diag(Ptr->
getExprLoc(), diag::err_atomic_builtin_bit_int_prohibit);
8864 assert(Fn &&
"builtin call without direct callee!");
8879bool Sema::BuiltinWasmRefNullExtern(
CallExpr *TheCall) {
8888bool Sema::BuiltinWasmRefNullFunc(
CallExpr *TheCall) {
8923 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
8925 <<
Callee->getSourceRange();
8938 FirstArg = FirstArgResult.
get();
8939 TheCall->
setArg(0, FirstArg);
8951 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
8986#define BUILTIN_ROW(x) \
8987 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
8988 Builtin::BI##x##_8, Builtin::BI##x##_16 }
8990 static const unsigned BuiltinIndices[][5] = {
9016 case 1: SizeIndex = 0;
break;
9017 case 2: SizeIndex = 1;
break;
9018 case 4: SizeIndex = 2;
break;
9019 case 8: SizeIndex = 3;
break;
9020 case 16: SizeIndex = 4;
break;
9032 unsigned BuiltinIndex, NumFixed = 1;
9033 bool WarnAboutSemanticsChange =
false;
9034 switch (BuiltinID) {
9035 default: llvm_unreachable(
"Unknown overloaded atomic builtin!");
9036 case Builtin::BI__sync_fetch_and_add:
9037 case Builtin::BI__sync_fetch_and_add_1:
9038 case Builtin::BI__sync_fetch_and_add_2:
9039 case Builtin::BI__sync_fetch_and_add_4:
9040 case Builtin::BI__sync_fetch_and_add_8:
9041 case Builtin::BI__sync_fetch_and_add_16:
9045 case Builtin::BI__sync_fetch_and_sub:
9046 case Builtin::BI__sync_fetch_and_sub_1:
9047 case Builtin::BI__sync_fetch_and_sub_2:
9048 case Builtin::BI__sync_fetch_and_sub_4:
9049 case Builtin::BI__sync_fetch_and_sub_8:
9050 case Builtin::BI__sync_fetch_and_sub_16:
9054 case Builtin::BI__sync_fetch_and_or:
9055 case Builtin::BI__sync_fetch_and_or_1:
9056 case Builtin::BI__sync_fetch_and_or_2:
9057 case Builtin::BI__sync_fetch_and_or_4:
9058 case Builtin::BI__sync_fetch_and_or_8:
9059 case Builtin::BI__sync_fetch_and_or_16:
9063 case Builtin::BI__sync_fetch_and_and:
9064 case Builtin::BI__sync_fetch_and_and_1:
9065 case Builtin::BI__sync_fetch_and_and_2:
9066 case Builtin::BI__sync_fetch_and_and_4:
9067 case Builtin::BI__sync_fetch_and_and_8:
9068 case Builtin::BI__sync_fetch_and_and_16:
9072 case Builtin::BI__sync_fetch_and_xor:
9073 case Builtin::BI__sync_fetch_and_xor_1:
9074 case Builtin::BI__sync_fetch_and_xor_2:
9075 case Builtin::BI__sync_fetch_and_xor_4:
9076 case Builtin::BI__sync_fetch_and_xor_8:
9077 case Builtin::BI__sync_fetch_and_xor_16:
9081 case Builtin::BI__sync_fetch_and_nand:
9082 case Builtin::BI__sync_fetch_and_nand_1:
9083 case Builtin::BI__sync_fetch_and_nand_2:
9084 case Builtin::BI__sync_fetch_and_nand_4:
9085 case Builtin::BI__sync_fetch_and_nand_8:
9086 case Builtin::BI__sync_fetch_and_nand_16:
9088 WarnAboutSemanticsChange =
true;
9091 case Builtin::BI__sync_add_and_fetch:
9092 case Builtin::BI__sync_add_and_fetch_1:
9093 case Builtin::BI__sync_add_and_fetch_2:
9094 case Builtin::BI__sync_add_and_fetch_4:
9095 case Builtin::BI__sync_add_and_fetch_8:
9096 case Builtin::BI__sync_add_and_fetch_16:
9100 case Builtin::BI__sync_sub_and_fetch:
9101 case Builtin::BI__sync_sub_and_fetch_1:
9102 case Builtin::BI__sync_sub_and_fetch_2:
9103 case Builtin::BI__sync_sub_and_fetch_4:
9104 case Builtin::BI__sync_sub_and_fetch_8:
9105 case Builtin::BI__sync_sub_and_fetch_16:
9109 case Builtin::BI__sync_and_and_fetch:
9110 case Builtin::BI__sync_and_and_fetch_1:
9111 case Builtin::BI__sync_and_and_fetch_2:
9112 case Builtin::BI__sync_and_and_fetch_4:
9113 case Builtin::BI__sync_and_and_fetch_8:
9114 case Builtin::BI__sync_and_and_fetch_16:
9118 case Builtin::BI__sync_or_and_fetch:
9119 case Builtin::BI__sync_or_and_fetch_1:
9120 case Builtin::BI__sync_or_and_fetch_2:
9121 case Builtin::BI__sync_or_and_fetch_4:
9122 case Builtin::BI__sync_or_and_fetch_8:
9123 case Builtin::BI__sync_or_and_fetch_16:
9127 case Builtin::BI__sync_xor_and_fetch:
9128 case Builtin::BI__sync_xor_and_fetch_1:
9129 case Builtin::BI__sync_xor_and_fetch_2:
9130 case Builtin::BI__sync_xor_and_fetch_4:
9131 case Builtin::BI__sync_xor_and_fetch_8:
9132 case Builtin::BI__sync_xor_and_fetch_16:
9136 case Builtin::BI__sync_nand_and_fetch:
9137 case Builtin::BI__sync_nand_and_fetch_1:
9138 case Builtin::BI__sync_nand_and_fetch_2:
9139 case Builtin::BI__sync_nand_and_fetch_4:
9140 case Builtin::BI__sync_nand_and_fetch_8:
9141 case Builtin::BI__sync_nand_and_fetch_16:
9143 WarnAboutSemanticsChange =
true;
9146 case Builtin::BI__sync_val_compare_and_swap:
9147 case Builtin::BI__sync_val_compare_and_swap_1:
9148 case Builtin::BI__sync_val_compare_and_swap_2:
9149 case Builtin::BI__sync_val_compare_and_swap_4:
9150 case Builtin::BI__sync_val_compare_and_swap_8:
9151 case Builtin::BI__sync_val_compare_and_swap_16:
9156 case Builtin::BI__sync_bool_compare_and_swap:
9157 case Builtin::BI__sync_bool_compare_and_swap_1:
9158 case Builtin::BI__sync_bool_compare_and_swap_2:
9159 case Builtin::BI__sync_bool_compare_and_swap_4:
9160 case Builtin::BI__sync_bool_compare_and_swap_8:
9161 case Builtin::BI__sync_bool_compare_and_swap_16:
9167 case Builtin::BI__sync_lock_test_and_set:
9168 case Builtin::BI__sync_lock_test_and_set_1:
9169 case Builtin::BI__sync_lock_test_and_set_2:
9170 case Builtin::BI__sync_lock_test_and_set_4:
9171 case Builtin::BI__sync_lock_test_and_set_8:
9172 case Builtin::BI__sync_lock_test_and_set_16:
9176 case Builtin::BI__sync_lock_release:
9177 case Builtin::BI__sync_lock_release_1:
9178 case Builtin::BI__sync_lock_release_2:
9179 case Builtin::BI__sync_lock_release_4:
9180 case Builtin::BI__sync_lock_release_8:
9181 case Builtin::BI__sync_lock_release_16:
9187 case Builtin::BI__sync_swap:
9188 case Builtin::BI__sync_swap_1:
9189 case Builtin::BI__sync_swap_2:
9190 case Builtin::BI__sync_swap_4:
9191 case Builtin::BI__sync_swap_8:
9192 case Builtin::BI__sync_swap_16:
9200 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
9201 << 0 << 1 + NumFixed << TheCall->
getNumArgs() << 0
9202 <<
Callee->getSourceRange();
9206 Diag(TheCall->
getEndLoc(), diag::warn_atomic_implicit_seq_cst)
9207 <<
Callee->getSourceRange();
9209 if (WarnAboutSemanticsChange) {
9210 Diag(TheCall->
getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
9211 <<
Callee->getSourceRange();
9216 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
9219 if (NewBuiltinID == BuiltinID)
9220 NewBuiltinDecl = FDecl;
9226 assert(Res.getFoundDecl());
9227 NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
9228 if (!NewBuiltinDecl)
9235 for (
unsigned i = 0; i != NumFixed; ++i) {
9266 CK_BuiltinFnToFnPtr);
9278 if (BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {
9279 Diag(FirstArg->
getExprLoc(), diag::err_atomic_builtin_ext_int_size);
9283 return TheCallResult;
9298 assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||
9299 BuiltinID == Builtin::BI__builtin_nontemporal_load) &&
9300 "Unexpected nontemporal load/store builtin!");
9301 bool isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;
9302 unsigned numArgs = isStore ? 2 : 1;
9312 Expr *PointerArg = TheCall->
getArg(numArgs - 1);
9318 PointerArg = PointerArgResult.
get();
9319 TheCall->
setArg(numArgs - 1, PointerArg);
9323 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
9336 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
9343 return TheCallResult;
9355 return TheCallResult;
9362 auto *
Literal = dyn_cast<StringLiteral>(Arg);
9364 if (
auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
9365 Literal = ObjcLiteral->getString();
9369 if (!Literal || (!
Literal->isOrdinary() && !
Literal->isUTF8())) {
9387 bool IsX64 = TT.getArch() == llvm::Triple::x86_64;
9388 bool IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||
9389 TT.getArch() == llvm::Triple::aarch64_32);
9390 bool IsWindows = TT.isOSWindows();
9391 bool IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;
9392 if (IsX64 || IsAArch64) {
9400 diag::err_ms_va_start_used_in_sysv_function);
9409 diag::err_va_start_used_in_wrong_abi_function)
9424 bool IsVariadic =
false;
9427 if (
auto *
Block = dyn_cast<BlockDecl>(Caller)) {
9428 IsVariadic =
Block->isVariadic();
9429 Params =
Block->parameters();
9430 }
else if (
auto *FD = dyn_cast<FunctionDecl>(Caller)) {
9433 }
else if (
auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {
9434 IsVariadic = MD->isVariadic();
9436 Params = MD->parameters();
9437 }
else if (isa<CapturedDecl>(Caller)) {
9453 *LastParam = Params.empty() ? nullptr : Params.back();
9461bool Sema::BuiltinVAStart(
unsigned BuiltinID,
CallExpr *TheCall) {
9486 bool SecondArgIsLastNamedArgument =
false;
9488 if (std::optional<llvm::APSInt> Val =
9497 bool IsCRegister =
false;
9499 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
9500 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
9501 SecondArgIsLastNamedArgument = PV == LastParam;
9503 Type = PV->getType();
9504 ParamLoc = PV->getLocation();
9510 if (!SecondArgIsLastNamedArgument)
9512 diag::warn_second_arg_of_va_start_not_last_named_param);
9517 if (!Context.isPromotableIntegerType(Type))
9519 if (!Type->isEnumeralType())
9521 const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
9523 Context.typesAreCompatible(ED->getPromotionType(), Type));
9525 unsigned Reason = 0;
9527 else if (IsCRegister) Reason = 2;
9528 Diag(Arg->
getBeginLoc(), diag::warn_va_start_type_is_undefined) << Reason;
9529 Diag(ParamLoc, diag::note_parameter_type) <<
Type;
9536 auto IsSuitablyTypedFormatArgument = [
this](
const Expr *Arg) ->
bool {
9556 if (
Call->getNumArgs() < 3)
9558 diag::err_typecheck_call_too_few_args_at_least)
9559 << 0 << 3 <<
Call->getNumArgs()
9572 const Expr *Arg1 =
Call->getArg(1)->IgnoreParens();
9575 const Expr *Arg2 =
Call->getArg(2)->IgnoreParens();
9580 if (!Arg1Ty->
isPointerType() || !IsSuitablyTypedFormatArgument(Arg1))
9582 << Arg1->
getType() << ConstCharPtrTy << 1
9585 << 2 << Arg1->
getType() << ConstCharPtrTy;
9590 << Arg2->
getType() << SizeTy << 1
9593 << 3 << Arg2->
getType() << SizeTy;
9600bool Sema::BuiltinUnorderedCompare(
CallExpr *TheCall,
unsigned BuiltinID) {
9604 if (BuiltinID == Builtin::BI__builtin_isunordered &&
9632 diag::err_typecheck_call_invalid_ordered_compare)
9643bool Sema::BuiltinFPClassification(
CallExpr *TheCall,
unsigned NumArgs,
9644 unsigned BuiltinID) {
9649 if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
9650 BuiltinID == Builtin::BI__builtin_isinf ||
9651 BuiltinID == Builtin::BI__builtin_isinf_sign))
9655 if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
9656 BuiltinID == Builtin::BI__builtin_isunordered))
9660 bool IsFPClass = NumArgs == 2;
9663 unsigned FPArgNo = IsFPClass ? 0 : NumArgs - 1;
9667 for (
unsigned i = 0; i < FPArgNo; ++i) {
9692 TheCall->
setArg(FPArgNo, OrigArg);
9706 diag::err_typecheck_call_invalid_unary_fp)
9712 if (BuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
9718 if (!VectorResultTy.
isNull())
9719 ResultTy = VectorResultTy;
9729bool Sema::BuiltinComplex(
CallExpr *TheCall) {
9733 bool Dependent =
false;
9734 for (
unsigned I = 0; I != 2; ++I) {
9745 return Diag(Arg->
getBeginLoc(), diag::err_typecheck_call_requires_real_fp)
9764 diag::err_typecheck_call_different_arg_types)
9790bool Sema::BuiltinVSX(
CallExpr *TheCall) {
9791 unsigned ExpectedNumArgs = 3;
9798 diag::err_vsx_builtin_nonconstant_argument)
9810 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
9818 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
9837 diag::err_typecheck_call_too_few_args_at_least)
9845 unsigned numElements = 0;
9860 unsigned numResElements = TheCall->
getNumArgs() - 2;
9869 diag::err_vec_builtin_incompatible_vector)
9876 diag::err_vec_builtin_incompatible_vector)
9881 }
else if (numElements != numResElements) {
9888 for (
unsigned i = 2; i < TheCall->
getNumArgs(); i++) {
9893 std::optional<llvm::APSInt>
Result;
9896 diag::err_shufflevector_nonconstant_argument)
9903 if (
Result->getActiveBits() > 64 ||
9904 Result->getZExtValue() >= numElements * 2)
9906 diag::err_shufflevector_argument_too_large)
9912 for (
unsigned i = 0, e = TheCall->
getNumArgs(); i != e; i++) {
9913 exprs.push_back(TheCall->
getArg(i));
9914 TheCall->
setArg(i,
nullptr);
9933 diag::err_convertvector_non_vector)
9936 return ExprError(
Diag(BuiltinLoc, diag::err_builtin_non_vector_type)
9938 <<
"__builtin_convertvector");
9943 if (SrcElts != DstElts)
9945 diag::err_convertvector_incompatible_vector)
9950 BuiltinLoc, RParenLoc);
9956bool Sema::BuiltinPrefetch(
CallExpr *TheCall) {
9961 diag::err_typecheck_call_too_many_args_at_most)
9962 << 0 << 3 << NumArgs << 0
9967 for (
unsigned i = 1; i != NumArgs; ++i)
9968 if (BuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
9975bool Sema::BuiltinArithmeticFence(
CallExpr *TheCall) {
9977 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
9987 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
10000bool Sema::BuiltinAssume(
CallExpr *TheCall) {
10007 << cast<FunctionDecl>(TheCall->
getCalleeDecl())->getIdentifier();
10015bool Sema::BuiltinAllocaWithAlign(
CallExpr *TheCall) {
10021 if (
const auto *UE =
10023 if (UE->getKind() == UETT_AlignOf ||
10024 UE->getKind() == UETT_PreferredAlignOf)
10030 if (!
Result.isPowerOf2())
10031 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10038 if (
Result > std::numeric_limits<int32_t>::max())
10040 << std::numeric_limits<int32_t>::max() << Arg->
getSourceRange();
10048bool Sema::BuiltinAssumeAligned(
CallExpr *TheCall) {
10061 TheCall->
setArg(0, FirstArgResult.
get());
10070 if (BuiltinConstantArg(TheCall, 1,
Result))
10073 if (!
Result.isPowerOf2())
10074 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10086 TheCall->
setArg(2, ThirdArg);
10092bool Sema::BuiltinOSLogFormat(
CallExpr *TheCall) {
10093 unsigned BuiltinID =
10094 cast<FunctionDecl>(TheCall->
getCalleeDecl())->getBuiltinID();
10095 bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
10098 unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
10099 if (NumArgs < NumRequiredArgs) {
10100 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args)
10101 << 0 << NumRequiredArgs << NumArgs
10104 if (NumArgs >= NumRequiredArgs + 0x100) {
10106 diag::err_typecheck_call_too_many_args_at_most)
10107 << 0 << (NumRequiredArgs + 0xff) << NumArgs
10118 if (Arg.isInvalid())
10120 TheCall->
setArg(i, Arg.get());
10125 unsigned FormatIdx = i;
10135 unsigned FirstDataArg = i;
10136 while (i < NumArgs) {
10154 llvm::SmallBitVector CheckedVarArgs(NumArgs,
false);
10156 bool Success = CheckFormatArguments(
10174bool Sema::BuiltinConstantArg(
CallExpr *TheCall,
int ArgNum,
10182 std::optional<llvm::APSInt> R;
10184 return Diag(TheCall->
getBeginLoc(), diag::err_constant_integer_arg_type)
10192bool Sema::BuiltinConstantArgRange(
CallExpr *TheCall,
int ArgNum,
int Low,
10193 int High,
bool RangeIsError) {
10204 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10207 if (
Result.getSExtValue() < Low ||
Result.getSExtValue() > High) {
10209 return Diag(TheCall->
getBeginLoc(), diag::err_argument_invalid_range)
10215 PDiag(diag::warn_argument_invalid_range)
10225bool Sema::BuiltinConstantArgMultiple(
CallExpr *TheCall,
int ArgNum,
10235 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10238 if (
Result.getSExtValue() % Num != 0)
10247bool Sema::BuiltinConstantArgPower2(
CallExpr *TheCall,
int ArgNum) {
10256 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10264 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_power_of_2)
10269 if (
Value.isNegative())
10280 if ((
Value & 0xFF) != 0)
10293bool Sema::BuiltinConstantArgShiftedByte(
CallExpr *TheCall,
int ArgNum,
10294 unsigned ArgBits) {
10303 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10308 Result.setIsUnsigned(
true);
10313 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_shifted_byte)
10322bool Sema::BuiltinConstantArgShiftedByteOrXXFF(
CallExpr *TheCall,
int ArgNum,
10323 unsigned ArgBits) {
10332 if (BuiltinConstantArg(TheCall, ArgNum,
Result))
10337 Result.setIsUnsigned(
true);
10345 diag::err_argument_not_shifted_byte_or_xxff)
10350bool Sema::BuiltinARMMemoryTaggingCall(
unsigned BuiltinID,
CallExpr *TheCall) {
10351 if (BuiltinID == AArch64::BI__builtin_arm_irg) {
10362 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10371 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10375 TheCall->
setType(FirstArgType);
10379 if (BuiltinID == AArch64::BI__builtin_arm_addg) {
10389 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10394 TheCall->
setType(FirstArgType);
10397 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
10400 if (BuiltinID == AArch64::BI__builtin_arm_gmi) {
10411 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10416 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10422 if (BuiltinID == AArch64::BI__builtin_arm_ldg ||
10423 BuiltinID == AArch64::BI__builtin_arm_stg) {
10433 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10438 if (BuiltinID == AArch64::BI__builtin_arm_ldg)
10439 TheCall->
setType(FirstArgType);
10443 if (BuiltinID == AArch64::BI__builtin_arm_subp) {
10456 auto isNull = [&] (
Expr *E) ->
bool {
10462 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10466 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10477 return Diag(TheCall->
getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
10485 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_any2arg_pointer)
10499 assert(
false &&
"Unhandled ARM MTE intrinsic");
10505bool Sema::BuiltinARMSpecialReg(
unsigned BuiltinID,
CallExpr *TheCall,
10506 int ArgNum,
unsigned ExpectedFieldNum,
10508 bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
10509 BuiltinID == ARM::BI__builtin_arm_wsr64 ||
10510 BuiltinID == ARM::BI__builtin_arm_rsr ||
10511 BuiltinID == ARM::BI__builtin_arm_rsrp ||
10512 BuiltinID == ARM::BI__builtin_arm_wsr ||
10513 BuiltinID == ARM::BI__builtin_arm_wsrp;
10514 bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
10515 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
10516 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10517 BuiltinID == AArch64::BI__builtin_arm_wsr128 ||
10518 BuiltinID == AArch64::BI__builtin_arm_rsr ||
10519 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
10520 BuiltinID == AArch64::BI__builtin_arm_wsr ||
10521 BuiltinID == AArch64::BI__builtin_arm_wsrp;
10522 assert((IsARMBuiltin || IsAArch64Builtin) &&
"Unexpected ARM builtin.");
10531 return Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
10537 Reg.split(Fields,
":");
10539 if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))
10540 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10547 if (Fields.size() > 1) {
10548 bool FiveFields = Fields.size() == 5;
10550 bool ValidString =
true;
10551 if (IsARMBuiltin) {
10552 ValidString &= Fields[0].starts_with_insensitive(
"cp") ||
10553 Fields[0].starts_with_insensitive(
"p");
10555 Fields[0] = Fields[0].drop_front(
10556 Fields[0].starts_with_insensitive(
"cp") ? 2 : 1);
10558 ValidString &= Fields[2].starts_with_insensitive(
"c");
10560 Fields[2] = Fields[2].drop_front(1);
10563 ValidString &= Fields[3].starts_with_insensitive(
"c");
10565 Fields[3] = Fields[3].drop_front(1);
10571 Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});
10573 Ranges.append({15, 7, 15});
10575 for (
unsigned i=0; i<Fields.size(); ++i) {
10577 ValidString &= !Fields[i].getAsInteger(10, IntField);
10578 ValidString &= (IntField >= 0 && IntField <= Ranges[i]);
10582 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10584 }
else if (IsAArch64Builtin && Fields.size() == 1) {
10592 if (BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10593 BuiltinID == AArch64::BI__builtin_arm_wsr128)
10598 auto MaxLimit = llvm::StringSwitch<std::optional<unsigned>>(Reg)
10599 .CaseLower(
"spsel", 15)
10600 .CaseLower(
"daifclr", 15)
10601 .CaseLower(
"daifset", 15)
10602 .CaseLower(
"pan", 15)
10603 .CaseLower(
"uao", 15)
10604 .CaseLower(
"dit", 15)
10605 .CaseLower(
"ssbs", 15)
10606 .CaseLower(
"tco", 15)
10607 .CaseLower(
"allint", 1)
10608 .CaseLower(
"pm", 1)
10609 .Default(std::nullopt);
10629 return BuiltinConstantArgRange(TheCall, 1, 0, *MaxLimit);
10639bool Sema::BuiltinPPCMMACall(
CallExpr *TheCall,
unsigned BuiltinID,
10640 const char *TypeStr) {
10642 assert((TypeStr[0] !=
'\0') &&
10643 "Invalid types in PPC MMA builtin declaration");
10646 unsigned ArgNum = 0;
10653 while (*TypeStr !=
'\0') {
10677 diag::err_typecheck_convert_incompatible)
10683 if (Mask != 0 && BuiltinConstantArgRange(TheCall, ArgNum, 0, Mask,
true))
10693 while (*TypeStr !=
'\0') {
10706bool Sema::BuiltinLongjmp(
CallExpr *TheCall) {
10708 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_unsupported)
10715 if (BuiltinConstantArg(TheCall, 1,
Result))
10719 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
10727bool Sema::BuiltinSetjmp(
CallExpr *TheCall) {
10729 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_setjmp_unsupported)
10736class UncoveredArgHandler {
10737 enum {
Unknown = -1, AllCovered = -2 };
10739 signed FirstUncoveredArg =
Unknown;
10743 UncoveredArgHandler() =
default;
10745 bool hasUncoveredArg()
const {
10746 return (FirstUncoveredArg >= 0);
10749 unsigned getUncoveredArg()
const {
10750 assert(hasUncoveredArg() &&
"no uncovered argument");
10751 return FirstUncoveredArg;
10754 void setAllCovered() {
10757 DiagnosticExprs.clear();
10758 FirstUncoveredArg = AllCovered;
10761 void Update(
signed NewFirstUncoveredArg,
const Expr *StrExpr) {
10762 assert(NewFirstUncoveredArg >= 0 &&
"Outside range");
10765 if (FirstUncoveredArg == AllCovered)
10770 if (NewFirstUncoveredArg == FirstUncoveredArg)
10771 DiagnosticExprs.push_back(StrExpr);
10772 else if (NewFirstUncoveredArg > FirstUncoveredArg) {
10773 DiagnosticExprs.clear();
10774 DiagnosticExprs.push_back(StrExpr);
10775 FirstUncoveredArg = NewFirstUncoveredArg;
10779 void Diagnose(
Sema &S,
bool IsFunctionCall,
const Expr *ArgExpr);
10782enum StringLiteralCheckType {
10784 SLCT_UncheckedLiteral,
10785 SLCT_CheckedLiteral
10792 bool AddendIsRight) {
10793 unsigned BitWidth = Offset.getBitWidth();
10794 unsigned AddendBitWidth = Addend.getBitWidth();
10796 if (Addend.isUnsigned()) {
10797 Addend = Addend.zext(++AddendBitWidth);
10798 Addend.setIsSigned(
true);
10801 if (AddendBitWidth > BitWidth) {
10802 Offset = Offset.sext(AddendBitWidth);
10803 BitWidth = AddendBitWidth;
10804 }
else if (BitWidth > AddendBitWidth) {
10805 Addend = Addend.sext(BitWidth);
10809 llvm::APSInt ResOffset = Offset;
10810 if (BinOpKind == BO_Add)
10811 ResOffset = Offset.sadd_ov(Addend, Ov);
10813 assert(AddendIsRight && BinOpKind == BO_Sub &&
10814 "operator must be add or sub with addend on the right");
10815 ResOffset = Offset.ssub_ov(Addend, Ov);
10821 assert(BitWidth <= std::numeric_limits<unsigned>::max() / 2 &&
10822 "index (intermediate) result too big");
10823 Offset = Offset.sext(2 * BitWidth);
10824 sumOffsets(Offset, Addend, BinOpKind, AddendIsRight);
10828 Offset = ResOffset;
10836class FormatStringLiteral {
10841 FormatStringLiteral(
const StringLiteral *fexpr, int64_t Offset = 0)
10842 : FExpr(fexpr), Offset(Offset) {}
10844 StringRef getString()
const {
10845 return FExpr->
getString().drop_front(Offset);
10848 unsigned getByteLength()
const {
10849 return FExpr->
getByteLength() - getCharByteWidth() * Offset;
10852 unsigned getLength()
const {
return FExpr->
getLength() - Offset; }
10859 bool isAscii()
const {
return FExpr->
isOrdinary(); }
10860 bool isWide()
const {
return FExpr->
isWide(); }
10861 bool isUTF8()
const {
return FExpr->
isUTF8(); }
10862 bool isUTF16()
const {
return FExpr->
isUTF16(); }
10863 bool isUTF32()
const {
return FExpr->
isUTF32(); }
10864 bool isPascal()
const {
return FExpr->
isPascal(); }
10869 unsigned *StartTokenByteOffset =
nullptr)
const {
10871 StartToken, StartTokenByteOffset);
10884 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
10888 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
10889 bool IgnoreStringsWithoutSpecifiers);
10898static StringLiteralCheckType
10903 llvm::SmallBitVector &CheckedVarArgs,
10904 UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset,
10905 bool IgnoreStringsWithoutSpecifiers =
false) {
10907 return SLCT_NotALiteral;
10909 assert(Offset.isSigned() &&
"invalid offset");
10912 return SLCT_NotALiteral;
10921 return SLCT_UncheckedLiteral;
10924 case Stmt::InitListExprClass:
10928 Type, CallType,
false,
10929 CheckedVarArgs, UncoveredArg, Offset,
10930 IgnoreStringsWithoutSpecifiers);
10932 return SLCT_NotALiteral;
10933 case Stmt::BinaryConditionalOperatorClass:
10934 case Stmt::ConditionalOperatorClass: {
10938 cast<AbstractConditionalOperator>(E);
10943 bool CheckLeft =
true, CheckRight =
true;
10946 if (
C->getCond()->EvaluateAsBooleanCondition(
10949 CheckRight =
false;
10958 StringLiteralCheckType Left;
10960 Left = SLCT_UncheckedLiteral;
10963 firstDataArg,
Type, CallType, InFunctionCall,
10964 CheckedVarArgs, UncoveredArg, Offset,
10965 IgnoreStringsWithoutSpecifiers);
10966 if (Left == SLCT_NotALiteral || !CheckRight) {
10972 S,
C->getFalseExpr(), Args, APK, format_idx, firstDataArg,
Type,
10973 CallType, InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
10974 IgnoreStringsWithoutSpecifiers);
10976 return (CheckLeft && Left < Right) ? Left : Right;
10979 case Stmt::ImplicitCastExprClass:
10980 E = cast<ImplicitCastExpr>(E)->getSubExpr();
10983 case Stmt::OpaqueValueExprClass:
10984 if (
const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
10988 return SLCT_NotALiteral;
10990 case Stmt::PredefinedExprClass:
10994 return SLCT_UncheckedLiteral;
10996 case Stmt::DeclRefExprClass: {
11002 bool isConstant =
false;
11006 isConstant = AT->getElementType().isConstant(S.
Context);
11008 isConstant =
T.isConstant(S.
Context) &&
11013 isConstant =
T.isConstant(S.
Context);
11017 if (
const Expr *
Init = VD->getAnyInitializer()) {
11020 if (InitList->isStringLiteralInit())
11021 Init = InitList->getInit(0)->IgnoreParenImpCasts();
11024 S,
Init, Args, APK, format_idx, firstDataArg,
Type, CallType,
11025 false, CheckedVarArgs, UncoveredArg, Offset);
11066 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
11067 if (
const auto *D = dyn_cast<Decl>(PV->getDeclContext())) {
11069 bool IsCXXMember =
false;
11070 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D))
11071 IsCXXMember = MD->isInstance();
11073 bool IsVariadic =
false;
11075 IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();
11076 else if (
const auto *BD = dyn_cast<BlockDecl>(D))
11077 IsVariadic = BD->isVariadic();
11078 else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D))
11079 IsVariadic = OMD->isVariadic();
11086 if (PV->getFunctionScopeIndex() == CallerFSI.
FormatIdx &&
11099 return SLCT_UncheckedLiteral;
11108 return SLCT_NotALiteral;
11111 case Stmt::CallExprClass:
11112 case Stmt::CXXMemberCallExprClass: {
11113 const CallExpr *CE = cast<CallExpr>(E);
11115 bool IsFirst =
true;
11116 StringLiteralCheckType CommonResult;
11117 for (
const auto *FA : ND->specific_attrs<FormatArgAttr>()) {
11118 const Expr *Arg = CE->
getArg(FA->getFormatIdx().getASTIndex());
11120 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11121 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11122 IgnoreStringsWithoutSpecifiers);
11129 return CommonResult;
11131 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
11133 if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
11134 BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString) {
11137 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11138 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11139 IgnoreStringsWithoutSpecifiers);
11145 Type, CallType,
false,
11146 CheckedVarArgs, UncoveredArg, Offset,
11147 IgnoreStringsWithoutSpecifiers);
11148 return SLCT_NotALiteral;
11150 case Stmt::ObjCMessageExprClass: {
11151 const auto *ME = cast<ObjCMessageExpr>(E);
11152 if (
const auto *MD = ME->getMethodDecl()) {
11153 if (
const auto *FA = MD->getAttr<FormatArgAttr>()) {
11162 if (MD->isInstanceMethod() && (IFace = MD->getClassInterface()) &&
11164 MD->getSelector().isKeywordSelector(
11165 {
"localizedStringForKey",
"value",
"table"})) {
11166 IgnoreStringsWithoutSpecifiers =
true;
11169 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
11171 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11172 InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,
11173 IgnoreStringsWithoutSpecifiers);
11177 return SLCT_NotALiteral;
11179 case Stmt::ObjCStringLiteralClass:
11180 case Stmt::StringLiteralClass: {
11186 StrE = cast<StringLiteral>(E);
11189 if (Offset.isNegative() || Offset > StrE->
getLength()) {
11192 return SLCT_NotALiteral;
11194 FormatStringLiteral FStr(StrE, Offset.sextOrTrunc(64).getSExtValue());
11196 InFunctionCall, CallType, CheckedVarArgs, UncoveredArg,
11197 IgnoreStringsWithoutSpecifiers);
11198 return SLCT_CheckedLiteral;
11201 return SLCT_NotALiteral;
11203 case Stmt::BinaryOperatorClass: {
11217 if (LIsInt != RIsInt) {
11221 if (BinOpKind == BO_Add) {
11234 return SLCT_NotALiteral;
11236 case Stmt::UnaryOperatorClass: {
11238 auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->
getSubExpr());
11239 if (UnaOp->
getOpcode() == UO_AddrOf && ASE) {
11241 if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.
Context,
11246 E = ASE->getBase();
11251 return SLCT_NotALiteral;
11255 return SLCT_NotALiteral;
11266 const auto *LVE =
Result.Val.getLValueBase().dyn_cast<
const Expr *>();
11267 if (isa_and_nonnull<StringLiteral>(LVE))
11274 return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
11280 .Cases(
"kprintf",
"cmn_err",
"vcmn_err",
"zcmn_err",
FST_Kprintf)
11290bool Sema::CheckFormatArguments(
const FormatAttr *Format,
11294 llvm::SmallBitVector &CheckedVarArgs) {
11295 FormatStringInfo FSI;
11298 return CheckFormatArguments(Args, FSI.ArgPassingKind, FSI.FormatIdx,
11300 CallType,
Loc,
Range, CheckedVarArgs);
11306 unsigned format_idx,
unsigned firstDataArg,
11307 FormatStringType
Type,
11310 llvm::SmallBitVector &CheckedVarArgs) {
11312 if (format_idx >= Args.size()) {
11317 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
11331 UncoveredArgHandler UncoveredArg;
11333 *
this, OrigFormatExpr, Args, APK, format_idx, firstDataArg,
Type,
11335 true, CheckedVarArgs, UncoveredArg,
11336 llvm::APSInt(64,
false) = 0);
11339 if (UncoveredArg.hasUncoveredArg()) {
11340 unsigned ArgIdx = UncoveredArg.getUncoveredArg() + firstDataArg;
11341 assert(ArgIdx < Args.size() &&
"ArgIdx outside bounds");
11342 UncoveredArg.Diagnose(*
this,
true, Args[ArgIdx]);
11345 if (CT != SLCT_NotALiteral)
11347 return CT == SLCT_CheckedLiteral;
11364 if (Args.size() == firstDataArg) {
11365 Diag(FormatLoc, diag::warn_format_nonliteral_noargs)
11373 Diag(FormatLoc, diag::note_format_security_fixit)
11377 Diag(FormatLoc, diag::note_format_security_fixit)
11382 Diag(FormatLoc, diag::warn_format_nonliteral)
11393 const FormatStringLiteral *FExpr;
11394 const Expr *OrigFormatExpr;
11396 const unsigned FirstDataArg;
11397 const unsigned NumDataArgs;
11401 unsigned FormatIdx;
11402 llvm::SmallBitVector CoveredArgs;
11403 bool usesPositionalArgs =
false;
11404 bool atFirstArg =
true;
11405 bool inFunctionCall;
11407 llvm::SmallBitVector &CheckedVarArgs;
11408 UncoveredArgHandler &UncoveredArg;
11411 CheckFormatHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11412 const Expr *origFormatExpr,
11414 unsigned numDataArgs,
const char *beg,
11418 llvm::SmallBitVector &CheckedVarArgs,
11419 UncoveredArgHandler &UncoveredArg)
11420 : S(
s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(
type),
11421 FirstDataArg(firstDataArg), NumDataArgs(numDataArgs), Beg(beg),
11422 ArgPassingKind(APK), Args(Args), FormatIdx(formatIdx),
11423 inFunctionCall(inFunctionCall), CallType(callType),
11424 CheckedVarArgs(CheckedVarArgs), UncoveredArg(UncoveredArg) {
11425 CoveredArgs.resize(numDataArgs);
11426 CoveredArgs.reset();
11429 void DoneProcessing();
11431 void HandleIncompleteSpecifier(
const char *startSpecifier,
11432 unsigned specifierLen)
override;
11434 void HandleInvalidLengthModifier(
11437 const char *startSpecifier,
unsigned specifierLen,
11440 void HandleNonStandardLengthModifier(
11442 const char *startSpecifier,
unsigned specifierLen);
11444 void HandleNonStandardConversionSpecifier(
11446 const char *startSpecifier,
unsigned specifierLen);
11448 void HandlePosition(
const char *startPos,
unsigned posLen)
override;
11450 void HandleInvalidPosition(
const char *startSpecifier,
11451 unsigned specifierLen,
11454 void HandleZeroPosition(
const char *startPos,
unsigned posLen)
override;
11456 void HandleNullChar(
const char *nullCharacter)
override;
11458 template <
typename Range>
11460 EmitFormatDiagnostic(
Sema &S,
bool inFunctionCall,
const Expr *ArgumentExpr,
11462 bool IsStringLocation,
Range StringRange,
11467 const char *startSpec,
11468 unsigned specifierLen,
11469 const char *csStart,
unsigned csLen);
11472 const char *startSpec,
11473 unsigned specifierLen);
11477 unsigned specifierLen);
11480 const Expr *getDataArg(
unsigned i)
const;
11484 const char *startSpecifier,
unsigned specifierLen,
11485 unsigned argIndex);
11487 template <
typename Range>
11489 bool IsStringLocation,
Range StringRange,
11495SourceRange CheckFormatHandler::getFormatStringRange() {
11500getSpecifierRange(
const char *startSpecifier,
unsigned specifierLen) {
11502 SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
11505 End = End.getLocWithOffset(1);
11510SourceLocation CheckFormatHandler::getLocationOfByte(
const char *x) {
11515void CheckFormatHandler::HandleIncompleteSpecifier(
const char *startSpecifier,
11516 unsigned specifierLen){
11517 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_incomplete_specifier),
11518 getLocationOfByte(startSpecifier),
11520 getSpecifierRange(startSpecifier, specifierLen));
11523void CheckFormatHandler::HandleInvalidLengthModifier(
11526 const char *startSpecifier,
unsigned specifierLen,
unsigned DiagID) {
11527 using namespace analyze_format_string;
11529 const LengthModifier &LM = FS.getLengthModifier();
11530 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11533 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11535 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11536 getLocationOfByte(LM.getStart()),
11538 getSpecifierRange(startSpecifier, specifierLen));
11540 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11541 << FixedLM->toString()
11546 if (DiagID == diag::warn_format_nonsensical_length)
11549 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11550 getLocationOfByte(LM.getStart()),
11552 getSpecifierRange(startSpecifier, specifierLen),
11557void CheckFormatHandler::HandleNonStandardLengthModifier(
11559 const char *startSpecifier,
unsigned specifierLen) {
11560 using namespace analyze_format_string;
11562 const LengthModifier &LM = FS.getLengthModifier();
11563 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11566 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11568 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11569 << LM.toString() << 0,
11570 getLocationOfByte(LM.getStart()),
11572 getSpecifierRange(startSpecifier, specifierLen));
11574 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11575 << FixedLM->toString()
11579 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11580 << LM.toString() << 0,
11581 getLocationOfByte(LM.getStart()),
11583 getSpecifierRange(startSpecifier, specifierLen));
11587void CheckFormatHandler::HandleNonStandardConversionSpecifier(
11589 const char *startSpecifier,
unsigned specifierLen) {
11590 using namespace analyze_format_string;
11595 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11599 getSpecifierRange(startSpecifier, specifierLen));
11602 S.
Diag(getLocationOfByte(CS.
getStart()), diag::note_format_fix_specifier)
11603 << FixedCS->toString()
11606 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11610 getSpecifierRange(startSpecifier, specifierLen));
11614void CheckFormatHandler::HandlePosition(
const char *startPos,
11616 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard_positional_arg),
11617 getLocationOfByte(startPos),
11619 getSpecifierRange(startPos, posLen));
11622void CheckFormatHandler::HandleInvalidPosition(
11623 const char *startSpecifier,
unsigned specifierLen,
11625 EmitFormatDiagnostic(
11626 S.
PDiag(diag::warn_format_invalid_positional_specifier) << (
unsigned)p,
11627 getLocationOfByte(startSpecifier),
true,
11628 getSpecifierRange(startSpecifier, specifierLen));
11631void CheckFormatHandler::HandleZeroPosition(
const char *startPos,
11633 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_zero_positional_specifier),
11634 getLocationOfByte(startPos),
11636 getSpecifierRange(startPos, posLen));
11639void CheckFormatHandler::HandleNullChar(
const char *nullCharacter) {
11640 if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
11642 EmitFormatDiagnostic(
11643 S.
PDiag(diag::warn_printf_format_string_contains_null_char),
11644 getLocationOfByte(nullCharacter),
true,
11645 getFormatStringRange());
11651const Expr *CheckFormatHandler::getDataArg(
unsigned i)
const {
11652 return Args[FirstDataArg + i];
11655void CheckFormatHandler::DoneProcessing() {
11660 CoveredArgs.flip();
11661 signed notCoveredArg = CoveredArgs.find_first();
11662 if (notCoveredArg >= 0) {
11663 assert((
unsigned)notCoveredArg < NumDataArgs);
11664 UncoveredArg.Update(notCoveredArg, OrigFormatExpr);
11666 UncoveredArg.setAllCovered();
11671void UncoveredArgHandler::Diagnose(
Sema &S,
bool IsFunctionCall,
11672 const Expr *ArgExpr) {
11673 assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
11685 for (
auto E : DiagnosticExprs)
11688 CheckFormatHandler::EmitFormatDiagnostic(
11689 S, IsFunctionCall, DiagnosticExprs[0],
11695CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex,
11697 const char *startSpec,
11698 unsigned specifierLen,
11699 const char *csStart,
11701 bool keepGoing =
true;
11702 if (argIndex < NumDataArgs) {
11705 CoveredArgs.set(argIndex);
11721 std::string CodePointStr;
11722 if (!llvm::sys::locale::isPrint(*csStart)) {
11723 llvm::UTF32 CodePoint;
11724 const llvm::UTF8 **B =
reinterpret_cast<const llvm::UTF8 **
>(&csStart);
11725 const llvm::UTF8 *E =
11726 reinterpret_cast<const llvm::UTF8 *
>(csStart + csLen);
11727 llvm::ConversionResult
Result =
11728 llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
11730 if (
Result != llvm::conversionOK) {
11731 unsigned char FirstChar = *csStart;
11732 CodePoint = (llvm::UTF32)FirstChar;
11735 llvm::raw_string_ostream OS(CodePointStr);
11736 if (CodePoint < 256)
11737 OS <<
"\\x" << llvm::format(
"%02x", CodePoint);
11738 else if (CodePoint <= 0xFFFF)
11739 OS <<
"\\u" << llvm::format(
"%04x", CodePoint);
11741 OS <<
"\\U" << llvm::format(
"%08x", CodePoint);
11746 EmitFormatDiagnostic(
11747 S.
PDiag(diag::warn_format_invalid_conversion) << Specifier,
Loc,
11748 true, getSpecifierRange(startSpec, specifierLen));
11755 const char *startSpec,
11756 unsigned specifierLen) {
11757 EmitFormatDiagnostic(
11758 S.
PDiag(diag::warn_format_mix_positional_nonpositional_args),
11759 Loc,
true, getSpecifierRange(startSpec, specifierLen));
11763CheckFormatHandler::CheckNumArgs(
11766 const char *startSpecifier,
unsigned specifierLen,
unsigned argIndex) {
11768 if (argIndex >= NumDataArgs) {
11770 ? (S.
PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
11771 << (argIndex+1) << NumDataArgs)
11772 : S.
PDiag(diag::warn_printf_insufficient_data_args);
11773 EmitFormatDiagnostic(
11774 PDiag, getLocationOfByte(CS.
getStart()),
true,
11775 getSpecifierRange(startSpecifier, specifierLen));
11779 UncoveredArg.setAllCovered();
11785template<
typename Range>
11788 bool IsStringLocation,
11791 EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
11792 Loc, IsStringLocation, StringRange, FixIt);
11822template <
typename Range>
11823void CheckFormatHandler::EmitFormatDiagnostic(
11824 Sema &S,
bool InFunctionCall,
const Expr *ArgumentExpr,
11827 if (InFunctionCall) {
11836 S.
Diag(IsStringLocation ?
Loc : StringRange.getBegin(),
11837 diag::note_format_string_defined);
11839 Note << StringRange;
11848class CheckPrintfHandler :
public CheckFormatHandler {
11850 CheckPrintfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11851 const Expr *origFormatExpr,
11853 unsigned numDataArgs,
bool isObjC,
const char *beg,
11857 llvm::SmallBitVector &CheckedVarArgs,
11858 UncoveredArgHandler &UncoveredArg)
11859 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
11860 numDataArgs, beg, APK, Args, formatIdx,
11861 inFunctionCall, CallType, CheckedVarArgs,
11867 bool allowsObjCArg()
const {
11872 bool HandleInvalidPrintfConversionSpecifier(
11874 const char *startSpecifier,
11875 unsigned specifierLen)
override;
11877 void handleInvalidMaskType(StringRef MaskType)
override;
11880 const char *startSpecifier,
unsigned specifierLen,
11883 const char *StartSpecifier,
11884 unsigned SpecifierLen,
11888 const char *startSpecifier,
unsigned specifierLen);
11892 const char *startSpecifier,
unsigned specifierLen);
11895 const char *startSpecifier,
unsigned specifierLen);
11899 const char *startSpecifier,
unsigned specifierLen);
11903 void HandleEmptyObjCModifierFlag(
const char *startFlag,
11904 unsigned flagLen)
override;
11906 void HandleInvalidObjCModifierFlag(
const char *startFlag,
11907 unsigned flagLen)
override;
11909 void HandleObjCFlagsWithNonObjCConversion(
const char *flagsStart,
11910 const char *flagsEnd,
11911 const char *conversionPosition)
11917bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
11919 const char *startSpecifier,
11920 unsigned specifierLen) {
11922 FS.getConversionSpecifier();
11924 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
11926 startSpecifier, specifierLen,
11930void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
11931 S.
Diag(getLocationOfByte(MaskType.data()), diag::err_invalid_mask_type_size);
11934bool CheckPrintfHandler::HandleAmount(
11936 const char *startSpecifier,
unsigned specifierLen) {
11940 if (argIndex >= NumDataArgs) {
11941 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_missing_arg)
11943 getLocationOfByte(Amt.
getStart()),
11945 getSpecifierRange(startSpecifier, specifierLen));
11955 CoveredArgs.set(argIndex);
11956 const Expr *Arg = getDataArg(argIndex);
11966 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_wrong_type)
11969 getLocationOfByte(Amt.
getStart()),
11971 getSpecifierRange(startSpecifier, specifierLen));
11981void CheckPrintfHandler::HandleInvalidAmount(
11985 const char *startSpecifier,
11986 unsigned specifierLen) {
11988 FS.getConversionSpecifier();
11996 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_optional_amount)
11998 getLocationOfByte(Amt.
getStart()),
12000 getSpecifierRange(startSpecifier, specifierLen),
12006 const char *startSpecifier,
12007 unsigned specifierLen) {
12010 FS.getConversionSpecifier();
12011 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_flag)
12015 getSpecifierRange(startSpecifier, specifierLen),
12020void CheckPrintfHandler::HandleIgnoredFlag(
12024 const char *startSpecifier,
12025 unsigned specifierLen) {
12027 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_ignored_flag)
12031 getSpecifierRange(startSpecifier, specifierLen),
12033 getSpecifierRange(ignoredFlag.
getPosition(), 1)));
12036void CheckPrintfHandler::HandleEmptyObjCModifierFlag(
const char *startFlag,
12037 unsigned flagLen) {
12039 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_empty_objc_flag),
12040 getLocationOfByte(startFlag),
12042 getSpecifierRange(startFlag, flagLen));
12045void CheckPrintfHandler::HandleInvalidObjCModifierFlag(
const char *startFlag,
12046 unsigned flagLen) {
12048 auto Range = getSpecifierRange(startFlag, flagLen);
12049 StringRef flag(startFlag, flagLen);
12050 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_invalid_objc_flag) << flag,
12051 getLocationOfByte(startFlag),
12056void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
12057 const char *flagsStart,
const char *flagsEnd,
const char *conversionPosition) {
12059 auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
12060 auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
12061 EmitFormatDiagnostic(S.
PDiag(diag) << StringRef(conversionPosition, 1),
12062 getLocationOfByte(conversionPosition),
12070template<
typename MemberKind>
12091 if (MemberKind *FK = dyn_cast<MemberKind>(
decl))
12092 Results.insert(FK);
12104 MethodSet Results =
12105 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", *
this, E->
getType());
12106 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12108 if ((*MI)->getMinRequiredArguments() == 0)
12116bool CheckPrintfHandler::checkForCStrMembers(
12120 MethodSet Results =
12121 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", S, E->
getType());
12123 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12139bool CheckPrintfHandler::HandlePrintfSpecifier(
12142 using namespace analyze_format_string;
12143 using namespace analyze_printf;
12145 const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
12147 if (FS.consumesDataArgument()) {
12149 atFirstArg =
false;
12150 usesPositionalArgs = FS.usesPositionalArg();
12152 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12153 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12154 startSpecifier, specifierLen);
12161 if (!HandleAmount(FS.getFieldWidth(), 0,
12162 startSpecifier, specifierLen)) {
12166 if (!HandleAmount(FS.getPrecision(), 1,
12167 startSpecifier, specifierLen)) {
12171 if (!CS.consumesDataArgument()) {
12178 unsigned argIndex = FS.getArgIndex();
12179 if (argIndex < NumDataArgs) {
12183 CoveredArgs.set(argIndex);
12187 if (CS.getKind() == ConversionSpecifier::FreeBSDbArg ||
12188 CS.getKind() == ConversionSpecifier::FreeBSDDArg) {
12190 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex + 1))
12194 CoveredArgs.set(argIndex + 1);
12197 const Expr *Ex = getDataArg(argIndex);
12199 (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
12202 EmitFormatDiagnostic(
12203 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12207 getSpecifierRange(startSpecifier, specifierLen));
12210 Ex = getDataArg(argIndex + 1);
12213 EmitFormatDiagnostic(
12214 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12218 getSpecifierRange(startSpecifier, specifierLen));
12225 if (!allowsObjCArg() && CS.isObjCArg()) {
12226 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12231 if (FSType !=
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::PArg) {
12232 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12237 if (FSType ==
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {
12238 EmitFormatDiagnostic(S.
PDiag(diag::warn_os_log_format_narg),
12239 getLocationOfByte(CS.getStart()),
12241 getSpecifierRange(startSpecifier, specifierLen));
12248 (CS.getKind() == ConversionSpecifier::PArg ||
12249 CS.getKind() == ConversionSpecifier::sArg ||
12250 CS.getKind() == ConversionSpecifier::ObjCObjArg)) {
12251 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12257 if (FS.isPublic().isSet()) {
12258 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12260 getLocationOfByte(FS.isPublic().getPosition()),
12262 getSpecifierRange(startSpecifier, specifierLen));
12264 if (FS.isPrivate().isSet()) {
12265 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12267 getLocationOfByte(FS.isPrivate().getPosition()),
12269 getSpecifierRange(startSpecifier, specifierLen));
12273 const llvm::Triple &Triple =
Target.getTriple();
12274 if (CS.getKind() == ConversionSpecifier::nArg &&
12275 (Triple.isAndroid() || Triple.isOSFuchsia())) {
12276 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_narg_not_supported),
12277 getLocationOfByte(CS.getStart()),
12279 getSpecifierRange(startSpecifier, specifierLen));
12283 if (!FS.hasValidFieldWidth()) {
12284 HandleInvalidAmount(FS, FS.getFieldWidth(), 0,
12285 startSpecifier, specifierLen);
12289 if (!FS.hasValidPrecision()) {
12290 HandleInvalidAmount(FS, FS.getPrecision(), 1,
12291 startSpecifier, specifierLen);
12295 if (CS.getKind() == ConversionSpecifier::PArg &&
12296 FS.getPrecision().getHowSpecified() == OptionalAmount::NotSpecified) {
12297 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_no_precision),
12298 getLocationOfByte(startSpecifier),
12300 getSpecifierRange(startSpecifier, specifierLen));
12304 if (!FS.hasValidThousandsGroupingPrefix())
12305 HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen);
12306 if (!FS.hasValidLeadingZeros())
12307 HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
12308 if (!FS.hasValidPlusPrefix())
12309 HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
12310 if (!FS.hasValidSpacePrefix())
12311 HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
12312 if (!FS.hasValidAlternativeForm())
12313 HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
12314 if (!FS.hasValidLeftJustified())
12315 HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
12318 if (FS.hasSpacePrefix() && FS.hasPlusPrefix())
12319 HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
12320 startSpecifier, specifierLen);
12321 if (FS.hasLeadingZeros() && FS.isLeftJustified())
12322 HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
12323 startSpecifier, specifierLen);
12328 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12329 diag::warn_format_nonsensical_length);
12330 else if (!FS.hasStandardLengthModifier())
12331 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12332 else if (!FS.hasStandardLengthConversionCombination())
12333 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12334 diag::warn_format_non_standard_conversion_spec);
12336 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12337 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12343 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12346 const Expr *Arg = getDataArg(argIndex);
12350 return checkFormatExpr(FS, startSpecifier, specifierLen, Arg);
12362 case Stmt::ArraySubscriptExprClass:
12363 case Stmt::CallExprClass:
12364 case Stmt::CharacterLiteralClass:
12365 case Stmt::CXXBoolLiteralExprClass:
12366 case Stmt::DeclRefExprClass:
12367 case Stmt::FloatingLiteralClass:
12368 case Stmt::IntegerLiteralClass:
12369 case Stmt::MemberExprClass:
12370 case Stmt::ObjCArrayLiteralClass:
12371 case Stmt::ObjCBoolLiteralExprClass:
12372 case Stmt::ObjCBoxedExprClass:
12373 case Stmt::ObjCDictionaryLiteralClass:
12374 case Stmt::ObjCEncodeExprClass:
12375 case Stmt::ObjCIvarRefExprClass:
12376 case Stmt::ObjCMessageExprClass:
12377 case Stmt::ObjCPropertyRefExprClass:
12378 case Stmt::ObjCStringLiteralClass:
12379 case Stmt::ObjCSubscriptRefExprClass:
12380 case Stmt::ParenExprClass:
12381 case Stmt::StringLiteralClass:
12382 case Stmt::UnaryOperatorClass:
12389static std::pair<QualType, StringRef>
12396 StringRef Name = UserTy->getDecl()->getName();
12397 QualType CastTy = llvm::StringSwitch<QualType>(Name)
12401 .Case(
"SInt32", Context.
IntTy)
12406 return std::make_pair(CastTy, Name);
12408 TyTy = UserTy->desugar();
12412 if (
const ParenExpr *PE = dyn_cast<ParenExpr>(E))
12414 PE->getSubExpr()->getType(),
12423 StringRef TrueName, FalseName;
12425 std::tie(TrueTy, TrueName) =
12427 CO->getTrueExpr()->getType(),
12428 CO->getTrueExpr());
12429 std::tie(FalseTy, FalseName) =
12431 CO->getFalseExpr()->getType(),
12432 CO->getFalseExpr());
12434 if (TrueTy == FalseTy)
12435 return std::make_pair(TrueTy, TrueName);
12436 else if (TrueTy.
isNull())
12437 return std::make_pair(FalseTy, FalseName);
12438 else if (FalseTy.
isNull())
12439 return std::make_pair(TrueTy, TrueName);
12442 return std::make_pair(
QualType(), StringRef());
12461 From = VecTy->getElementType();
12463 To = VecTy->getElementType();
12475 diag::warn_format_conversion_argument_type_mismatch_signedness,
Loc)
12484 const char *StartSpecifier,
12485 unsigned SpecifierLen,
12487 using namespace analyze_format_string;
12488 using namespace analyze_printf;
12497 while (
const TypeOfExprType *TET = dyn_cast<TypeOfExprType>(ExprTy)) {
12498 ExprTy = TET->getUnderlyingExpr()->getType();
12510 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::cArg &&
12513 getSpecifierRange(StartSpecifier, SpecifierLen);
12515 llvm::raw_svector_ostream os(FSString);
12517 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_bool_as_character)
12525 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::PArg &&
12528 getSpecifierRange(StartSpecifier, SpecifierLen);
12529 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_with_objc_pointer),
12534 ArgType::MatchKind ImplicitMatch = ArgType::NoMatch;
12536 ArgType::MatchKind OrigMatch = Match;
12539 if (Match == ArgType::Match)
12543 assert(Match != ArgType::NoMatchPromotionTypeConfusion);
12552 E = ICE->getSubExpr();
12562 if (OrigMatch == ArgType::NoMatchSignedness &&
12563 ImplicitMatch != ArgType::NoMatchSignedness)
12570 if (ImplicitMatch == ArgType::Match)
12581 FS.getLengthModifier().getKind() != LengthModifier::AsChar)
12588 if (Match == ArgType::MatchPromotion)
12589 Match = ArgType::NoMatch;
12592 if (Match == ArgType::MatchPromotion) {
12596 ImplicitMatch != ArgType::NoMatchPromotionTypeConfusion &&
12597 ImplicitMatch != ArgType::NoMatchTypeConfusion)
12599 Match = ArgType::NoMatch;
12601 if (ImplicitMatch == ArgType::NoMatchPedantic ||
12602 ImplicitMatch == ArgType::NoMatchTypeConfusion)
12603 Match = ImplicitMatch;
12604 assert(Match != ArgType::MatchPromotion);
12607 bool IsEnum =
false;
12608 bool IsScopedEnum =
false;
12611 IntendedTy = EnumTy->getDecl()->getIntegerType();
12612 if (EnumTy->isUnscopedEnumerationType()) {
12613 ExprTy = IntendedTy;
12618 IsScopedEnum =
true;
12625 if (isObjCContext() &&
12626 FS.getConversionSpecifier().getKind() == ConversionSpecifier::CArg) {
12636 const llvm::APInt &
V = IL->getValue();
12646 if (TD->getUnderlyingType() == IntendedTy)
12654 bool ShouldNotPrintDirectly =
false; StringRef CastTyName;
12662 if (!IsScopedEnum &&
12663 (CastTyName ==
"NSInteger" || CastTyName ==
"NSUInteger") &&
12666 Match = ArgType::NoMatchPedantic;
12667 IntendedTy = CastTy;
12668 ShouldNotPrintDirectly =
true;
12673 PrintfSpecifier fixedFS = FS;
12680 llvm::raw_svector_ostream os(buf);
12681 fixedFS.toString(os);
12683 CharSourceRange SpecRange = getSpecifierRange(StartSpecifier, SpecifierLen);
12685 if (IntendedTy == ExprTy && !ShouldNotPrintDirectly && !IsScopedEnum) {
12688 case ArgType::Match:
12689 case ArgType::MatchPromotion:
12690 case ArgType::NoMatchPromotionTypeConfusion:
12691 case ArgType::NoMatchSignedness:
12692 llvm_unreachable(
"expected non-matching");
12693 case ArgType::NoMatchPedantic:
12694 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12696 case ArgType::NoMatchTypeConfusion:
12697 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12699 case ArgType::NoMatch:
12700 Diag = diag::warn_format_conversion_argument_type_mismatch;
12721 llvm::raw_svector_ostream CastFix(CastBuf);
12722 CastFix << (S.
LangOpts.CPlusPlus ?
"static_cast<" :
"(");
12724 CastFix << (S.
LangOpts.CPlusPlus ?
">" :
")");
12730 if ((IntendedMatch != ArgType::Match) || ShouldNotPrintDirectly)
12733 if (
const CStyleCastExpr *CCast = dyn_cast<CStyleCastExpr>(E)) {
12735 SourceRange CastRange(CCast->getLParenLoc(), CCast->getRParenLoc());
12757 if (ShouldNotPrintDirectly && !IsScopedEnum) {
12763 Name = TypedefTy->getDecl()->getName();
12766 unsigned Diag = Match == ArgType::NoMatchPedantic
12767 ? diag::warn_format_argument_needs_cast_pedantic
12768 : diag::warn_format_argument_needs_cast;
12769 EmitFormatDiagnostic(S.
PDiag(
Diag) << Name << IntendedTy << IsEnum
12780 ? diag::warn_format_conversion_argument_type_mismatch_pedantic
12781 : diag::warn_format_conversion_argument_type_mismatch;
12783 EmitFormatDiagnostic(
12795 bool EmitTypeMismatch =
false;
12801 case ArgType::Match:
12802 case ArgType::MatchPromotion:
12803 case ArgType::NoMatchPromotionTypeConfusion:
12804 case ArgType::NoMatchSignedness:
12805 llvm_unreachable(
"expected non-matching");
12806 case ArgType::NoMatchPedantic:
12807 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
12809 case ArgType::NoMatchTypeConfusion:
12810 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
12812 case ArgType::NoMatch:
12813 Diag = diag::warn_format_conversion_argument_type_mismatch;
12817 EmitFormatDiagnostic(
12826 EmitTypeMismatch =
true;
12828 EmitFormatDiagnostic(
12829 S.
PDiag(diag::warn_non_pod_vararg_with_format_string)
12830 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12834 checkForCStrMembers(AT, E);
12840 EmitTypeMismatch =
true;
12842 EmitFormatDiagnostic(
12843 S.
PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
12844 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
12852 << isa<InitListExpr>(E) << ExprTy << CallType
12857 if (EmitTypeMismatch) {
12863 EmitFormatDiagnostic(
12864 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12870 assert(FirstDataArg + FS.getArgIndex() < CheckedVarArgs.size() &&
12871 "format string specifier index out of range");
12872 CheckedVarArgs[FirstDataArg + FS.getArgIndex()] =
true;
12882class CheckScanfHandler :
public CheckFormatHandler {
12884 CheckScanfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
12886 unsigned firstDataArg,
unsigned numDataArgs,
12890 llvm::SmallBitVector &CheckedVarArgs,
12891 UncoveredArgHandler &UncoveredArg)
12892 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
12893 numDataArgs, beg, APK, Args, formatIdx,
12894 inFunctionCall, CallType, CheckedVarArgs,
12898 const char *startSpecifier,
12899 unsigned specifierLen)
override;
12901 bool HandleInvalidScanfConversionSpecifier(
12903 const char *startSpecifier,
12904 unsigned specifierLen)
override;
12906 void HandleIncompleteScanList(
const char *start,
const char *end)
override;
12911void CheckScanfHandler::HandleIncompleteScanList(
const char *start,
12913 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_scanlist_incomplete),
12914 getLocationOfByte(end),
true,
12915 getSpecifierRange(start, end - start));
12918bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
12920 const char *startSpecifier,
12921 unsigned specifierLen) {
12923 FS.getConversionSpecifier();
12925 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
12927 startSpecifier, specifierLen,
12931bool CheckScanfHandler::HandleScanfSpecifier(
12933 const char *startSpecifier,
12934 unsigned specifierLen) {
12935 using namespace analyze_scanf;
12936 using namespace analyze_format_string;
12938 const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
12942 if (FS.consumesDataArgument()) {
12944 atFirstArg =
false;
12945 usesPositionalArgs = FS.usesPositionalArg();
12947 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12948 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12949 startSpecifier, specifierLen);
12955 const OptionalAmount &Amt = FS.getFieldWidth();
12956 if (Amt.getHowSpecified() == OptionalAmount::Constant) {
12957 if (Amt.getConstantAmount() == 0) {
12959 Amt.getConstantLength());
12960 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_nonzero_width),
12961 getLocationOfByte(Amt.getStart()),
12967 if (!FS.consumesDataArgument()) {
12974 unsigned argIndex = FS.getArgIndex();
12975 if (argIndex < NumDataArgs) {
12979 CoveredArgs.set(argIndex);
12985 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12986 diag::warn_format_nonsensical_length);
12987 else if (!FS.hasStandardLengthModifier())
12988 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12989 else if (!FS.hasStandardLengthConversionCombination())
12990 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12991 diag::warn_format_non_standard_conversion_spec);
12993 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12994 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
13000 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
13004 const Expr *Ex = getDataArg(argIndex);
13021 ScanfSpecifier fixedFS = FS;
13026 Pedantic ? diag::warn_format_conversion_argument_type_mismatch_pedantic
13027 : diag::warn_format_conversion_argument_type_mismatch;
13032 llvm::raw_svector_ostream os(buf);
13033 fixedFS.toString(os);
13035 EmitFormatDiagnostic(
13040 getSpecifierRange(startSpecifier, specifierLen),
13042 getSpecifierRange(startSpecifier, specifierLen), os.str()));
13049 getSpecifierRange(startSpecifier, specifierLen));
13056 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
13060 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
13061 bool IgnoreStringsWithoutSpecifiers) {
13063 if (!FExpr->isAscii() && !FExpr->isUTF8()) {
13064 CheckFormatHandler::EmitFormatDiagnostic(
13065 S, inFunctionCall, Args[format_idx],
13066 S.
PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
13072 StringRef StrRef = FExpr->getString();
13073 const char *Str = StrRef.data();
13077 assert(
T &&
"String literal not of constant array type!");
13078 size_t TypeSize =
T->getZExtSize();
13079 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13080 const unsigned numDataArgs = Args.size() - firstDataArg;
13082 if (IgnoreStringsWithoutSpecifiers &&
13089 if (TypeSize <= StrRef.size() && !StrRef.substr(0, TypeSize).contains(
'\0')) {
13090 CheckFormatHandler::EmitFormatDiagnostic(
13091 S, inFunctionCall, Args[format_idx],
13092 S.
PDiag(diag::warn_printf_format_string_not_null_terminated),
13093 FExpr->getBeginLoc(),
13099 if (StrLen == 0 && numDataArgs > 0) {
13100 CheckFormatHandler::EmitFormatDiagnostic(
13101 S, inFunctionCall, Args[format_idx],
13102 S.
PDiag(diag::warn_empty_format_string), FExpr->getBeginLoc(),
13110 CheckPrintfHandler H(
13111 S, FExpr, OrigFormatExpr,
Type, firstDataArg, numDataArgs,
13113 Args, format_idx, inFunctionCall, CallType, CheckedVarArgs,
13119 H.DoneProcessing();
13121 CheckScanfHandler H(S, FExpr, OrigFormatExpr,
Type, firstDataArg,
13122 numDataArgs, Str, APK, Args, format_idx, inFunctionCall,
13123 CallType, CheckedVarArgs, UncoveredArg);
13127 H.DoneProcessing();
13134 const char *Str = StrRef.data();
13137 assert(
T &&
"String literal not of constant array type!");
13138 size_t TypeSize =
T->getZExtSize();
13139 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13150 switch (AbsFunction) {
13154 case Builtin::BI__builtin_abs:
13155 return Builtin::BI__builtin_labs;
13156 case Builtin::BI__builtin_labs:
13157 return Builtin::BI__builtin_llabs;
13158 case Builtin::BI__builtin_llabs:
13161 case Builtin::BI__builtin_fabsf:
13162 return Builtin::BI__builtin_fabs;
13163 case Builtin::BI__builtin_fabs:
13164 return Builtin::BI__builtin_fabsl;
13165 case Builtin::BI__builtin_fabsl:
13168 case Builtin::BI__builtin_cabsf:
13169 return Builtin::BI__builtin_cabs;
13170 case Builtin::BI__builtin_cabs:
13171 return Builtin::BI__builtin_cabsl;
13172 case Builtin::BI__builtin_cabsl:
13175 case Builtin::BIabs:
13176 return Builtin::BIlabs;
13177 case Builtin::BIlabs:
13178 return Builtin::BIllabs;
13179 case Builtin::BIllabs:
13182 case Builtin::BIfabsf:
13183 return Builtin::BIfabs;
13184 case Builtin::BIfabs:
13185 return Builtin::BIfabsl;
13186 case Builtin::BIfabsl:
13189 case Builtin::BIcabsf:
13190 return Builtin::BIcabs;
13191 case Builtin::BIcabs:
13192 return Builtin::BIcabsl;
13193 case Builtin::BIcabsl:
13200 unsigned AbsType) {
13222 unsigned AbsFunctionKind) {
13223 unsigned BestKind = 0;
13225 for (
unsigned Kind = AbsFunctionKind; Kind != 0;
13231 else if (Context.
hasSameType(ParamType, ArgType)) {
13254 llvm_unreachable(
"Type not integer, floating, or complex");
13261 switch (ValueKind) {
13266 case Builtin::BI__builtin_fabsf:
13267 case Builtin::BI__builtin_fabs:
13268 case Builtin::BI__builtin_fabsl:
13269 case Builtin::BI__builtin_cabsf:
13270 case Builtin::BI__builtin_cabs:
13271 case Builtin::BI__builtin_cabsl:
13272 return Builtin::BI__builtin_abs;
13273 case Builtin::BIfabsf:
13274 case Builtin::BIfabs:
13275 case Builtin::BIfabsl:
13276 case Builtin::BIcabsf:
13277 case Builtin::BIcabs:
13278 case Builtin::BIcabsl:
13279 return Builtin::BIabs;
13285 case Builtin::BI__builtin_abs:
13286 case Builtin::BI__builtin_labs:
13287 case Builtin::BI__builtin_llabs:
13288 case Builtin::BI__builtin_cabsf:
13289 case Builtin::BI__builtin_cabs:
13290 case Builtin::BI__builtin_cabsl:
13291 return Builtin::BI__builtin_fabsf;
13292 case Builtin::BIabs:
13293 case Builtin::BIlabs:
13294 case Builtin::BIllabs:
13295 case Builtin::BIcabsf:
13296 case Builtin::BIcabs:
13297 case Builtin::BIcabsl:
13298 return Builtin::BIfabsf;
13304 case Builtin::BI__builtin_abs:
13305 case Builtin::BI__builtin_labs:
13306 case Builtin::BI__builtin_llabs:
13307 case Builtin::BI__builtin_fabsf:
13308 case Builtin::BI__builtin_fabs:
13309 case Builtin::BI__builtin_fabsl:
13310 return Builtin::BI__builtin_cabsf;
13311 case Builtin::BIabs:
13312 case Builtin::BIlabs:
13313 case Builtin::BIllabs:
13314 case Builtin::BIfabsf:
13315 case Builtin::BIfabs:
13316 case Builtin::BIfabsl:
13317 return Builtin::BIcabsf;
13320 llvm_unreachable(
"Unable to convert function");
13331 case Builtin::BI__builtin_abs:
13332 case Builtin::BI__builtin_fabs:
13333 case Builtin::BI__builtin_fabsf:
13334 case Builtin::BI__builtin_fabsl:
13335 case Builtin::BI__builtin_labs:
13336 case Builtin::BI__builtin_llabs:
13337 case Builtin::BI__builtin_cabs:
13338 case Builtin::BI__builtin_cabsf:
13339 case Builtin::BI__builtin_cabsl:
13340 case Builtin::BIabs:
13341 case Builtin::BIlabs:
13342 case Builtin::BIllabs:
13343 case Builtin::BIfabs:
13344 case Builtin::BIfabsf:
13345 case Builtin::BIfabsl:
13346 case Builtin::BIcabs:
13347 case Builtin::BIcabsf:
13348 case Builtin::BIcabsl:
13351 llvm_unreachable(
"Unknown Builtin type");
13357 unsigned AbsKind,
QualType ArgType) {
13358 bool EmitHeaderHint =
true;
13359 const char *HeaderName =
nullptr;
13360 StringRef FunctionName;
13362 FunctionName =
"std::abs";
13364 HeaderName =
"cstdlib";
13366 HeaderName =
"cmath";
13368 llvm_unreachable(
"Invalid Type");
13377 for (
const auto *I : R) {
13380 FDecl = dyn_cast<FunctionDecl>(UsingD->getTargetDecl());
13382 FDecl = dyn_cast<FunctionDecl>(I);
13397 EmitHeaderHint =
false;
13415 EmitHeaderHint =
false;
13419 }
else if (!R.
empty()) {
13425 S.
Diag(
Loc, diag::note_replace_abs_function)
13431 if (!EmitHeaderHint)
13434 S.
Diag(
Loc, diag::note_include_header_or_declare) << HeaderName
13438template <std::
size_t StrLen>
13440 const char (&Str)[StrLen]) {
13455 (
Call->getBuiltinCallee() == Builtin::BI__builtin_nanf)) &&
13456 FPO.getNoHonorNaNs())
13457 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13458 << 1 << 0 <<
Call->getSourceRange();
13462 FPO.getNoHonorInfs())
13463 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13464 << 0 << 0 <<
Call->getSourceRange();
13468void Sema::CheckAbsoluteValueFunction(
const CallExpr *
Call,
13470 if (
Call->getNumArgs() != 1)
13475 if (AbsKind == 0 && !IsStdAbs)
13478 QualType ArgType =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13484 StringRef FunctionName =
13486 Diag(
Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
13487 Diag(
Call->getExprLoc(), diag::note_remove_abs)
13496 unsigned DiagType = 0;
13502 Diag(
Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;
13516 if (ArgValueKind == ParamValueKind) {
13521 Diag(
Call->getExprLoc(), diag::warn_abs_too_small)
13522 << FDecl << ArgType << ParamType;
13524 if (NewAbsKind == 0)
13528 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13537 if (NewAbsKind == 0)
13540 Diag(
Call->getExprLoc(), diag::warn_wrong_absolute_value_type)
13541 << FDecl << ParamValueKind << ArgValueKind;
13544 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13550 if (!
Call || !FDecl)
return;
13554 if (
Call->getExprLoc().isMacroID())
return;
13557 if (
Call->getNumArgs() != 2)
return;
13560 if (!ArgList)
return;
13561 if (ArgList->size() != 1)
return;
13564 const auto& TA = ArgList->
get(0);
13566 QualType ArgType = TA.getAsType();
13570 auto IsLiteralZeroArg = [](
const Expr* E) ->
bool {
13571 const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
13572 if (!MTE)
return false;
13573 const auto *Num = dyn_cast<IntegerLiteral>(MTE->getSubExpr());
13574 if (!Num)
return false;
13575 if (Num->getValue() != 0)
return false;
13579 const Expr *FirstArg =
Call->getArg(0);
13580 const Expr *SecondArg =
Call->getArg(1);
13581 const bool IsFirstArgZero = IsLiteralZeroArg(FirstArg);
13582 const bool IsSecondArgZero = IsLiteralZeroArg(SecondArg);
13585 if (IsFirstArgZero == IsSecondArgZero)
return;
13590 SourceRange ZeroRange = IsFirstArgZero ? FirstRange : SecondRange;
13592 Diag(
Call->getExprLoc(), diag::warn_max_unsigned_zero)
13593 << IsFirstArgZero <<
Call->getCallee()->getSourceRange() << ZeroRange;
13597 if (IsFirstArgZero) {
13605 Diag(
Call->getExprLoc(), diag::note_remove_max_call)
13625 if (!Size->isComparisonOp() && !Size->isLogicalOp())
13629 S.
Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison)
13630 << SizeRange << FnName;
13631 S.
Diag(FnLoc, diag::note_memsize_comparison_paren)
13636 S.
Diag(SizeRange.
getBegin(), diag::note_memsize_comparison_cast_silence)
13647 bool &IsContained) {
13650 IsContained =
false;
13663 for (
auto *FD : RD->
fields()) {
13667 IsContained =
true;
13668 return ContainedRD;
13676 if (
const auto *Unary = dyn_cast<UnaryExprOrTypeTraitExpr>(E))
13677 if (Unary->getKind() == UETT_SizeOf)
13686 if (!
SizeOf->isArgumentType())
13687 return SizeOf->getArgumentExpr()->IgnoreParenImpCasts();
13694 return SizeOf->getTypeOfArgument();
13700struct SearchNonTrivialToInitializeField
13705 SearchNonTrivialToInitializeField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13709 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13710 asDerived().visitArray(PDIK, AT, SL);
13714 Super::visitWithKind(PDIK, FT, SL);
13729 visit(getContext().getBaseElementType(AT), SL);
13734 SearchNonTrivialToInitializeField(E, S).visitStruct(RT,
SourceLocation());
13743struct SearchNonTrivialToCopyField
13747 SearchNonTrivialToCopyField(
const Expr *E,
Sema &S) : E(E), S(S) {}
13751 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
13752 asDerived().visitArray(PCK, AT, SL);
13756 Super::visitWithKind(PCK, FT, SL);
13771 visit(getContext().getBaseElementType(AT), SL);
13779 SearchNonTrivialToCopyField(E, S).visitStruct(RT,
SourceLocation());
13794 if (
const auto *BO = dyn_cast<BinaryOperator>(SizeofExpr)) {
13795 if (BO->getOpcode() != BO_Mul && BO->getOpcode() != BO_Add)
13819 return SM.getFileID(CallLoc) !=
SM.getFileID(ArgLoc);
13821 return SM.getFileID(
SM.getImmediateMacroCallerLoc(CallLoc)) !=
13822 SM.getFileID(
SM.getImmediateMacroCallerLoc(ArgLoc));
13828 if (BId != Builtin::BImemset && BId != Builtin::BIbzero)
13831 const Expr *SizeArg =
13832 Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
13834 auto isLiteralZero = [](
const Expr *E) {
13835 return (isa<IntegerLiteral>(E) &&
13836 cast<IntegerLiteral>(E)->getValue() == 0) ||
13837 (isa<CharacterLiteral>(E) &&
13838 cast<CharacterLiteral>(E)->getValue() == 0);
13844 if (isLiteralZero(SizeArg) &&
13851 if (BId == Builtin::BIbzero ||
13854 S.
Diag(DiagLoc, diag::warn_suspicious_bzero_size);
13855 S.
Diag(DiagLoc, diag::note_suspicious_bzero_size_silence);
13856 }
else if (!isLiteralZero(
Call->getArg(1)->IgnoreImpCasts())) {
13857 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 0;
13858 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 0;
13866 if (BId == Builtin::BImemset &&
13870 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 1;
13871 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 1;
13883void Sema::CheckMemaccessArguments(
const CallExpr *
Call,
13890 unsigned ExpectedNumArgs =
13891 (BId == Builtin::BIstrndup || BId == Builtin::BIbzero ? 2 : 3);
13892 if (
Call->getNumArgs() < ExpectedNumArgs)
13895 unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
13896 BId == Builtin::BIstrndup ? 1 : 2);
13898 (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
13899 const Expr *LenExpr =
Call->getArg(LenArg)->IgnoreParenImpCasts();
13902 Call->getBeginLoc(),
Call->getRParenLoc()))
13911 llvm::FoldingSetNodeID SizeOfArgID;
13916 QualType FirstArgTy =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13920 for (
unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {
13921 const Expr *Dest =
Call->getArg(ArgIdx)->IgnoreParenImpCasts();
13943 if (SizeOfArgID == llvm::FoldingSetNodeID())
13945 llvm::FoldingSetNodeID DestID;
13947 if (DestID == SizeOfArgID) {
13950 unsigned ActionIdx = 0;
13951 StringRef ReadableName = FnName->
getName();
13953 if (
const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
13954 if (UnaryOp->getOpcode() == UO_AddrOf)
13968 if (
SM.isMacroArgExpansion(SL)) {
13970 SL =
SM.getSpellingLoc(SL);
13978 PDiag(diag::warn_sizeof_pointer_expr_memaccess)
13985 PDiag(diag::warn_sizeof_pointer_expr_memaccess_note)
14000 PDiag(diag::warn_sizeof_pointer_type_memaccess)
14001 << FnName << SizeOfArgTy << ArgIdx
14008 PointeeTy = DestTy;
14019 unsigned OperationType = 0;
14020 const bool IsCmp = BId == Builtin::BImemcmp || BId == Builtin::BIbcmp;
14023 if (ArgIdx != 0 || IsCmp) {
14024 if (BId == Builtin::BImemcpy)
14026 else if(BId == Builtin::BImemmove)
14033 PDiag(diag::warn_dyn_class_memaccess)
14034 << (IsCmp ? ArgIdx + 2 : ArgIdx) << FnName
14035 << IsContained << ContainedRD << OperationType
14036 <<
Call->getCallee()->getSourceRange());
14038 BId != Builtin::BImemset)
14041 PDiag(diag::warn_arc_object_memaccess)
14042 << ArgIdx << FnName << PointeeTy
14043 <<
Call->getCallee()->getSourceRange());
14045 if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
14046 RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
14048 PDiag(diag::warn_cstruct_memaccess)
14049 << ArgIdx << FnName << PointeeTy << 0);
14050 SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *
this);
14051 }
else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
14052 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
14054 PDiag(diag::warn_cstruct_memaccess)
14055 << ArgIdx << FnName << PointeeTy << 1);
14056 SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *
this);
14065 PDiag(diag::note_bad_memaccess_silence)
14085 if (isa<IntegerLiteral>(RHS))
14087 else if (isa<IntegerLiteral>(LHS))
14101 if (CAT->getZExtSize() <= 1)
14111void Sema::CheckStrlcpycatArguments(
const CallExpr *
Call,
14115 unsigned NumArgs =
Call->getNumArgs();
14116 if ((NumArgs != 3) && (NumArgs != 4))
14121 const Expr *CompareWithSrc =
nullptr;
14124 Call->getBeginLoc(),
Call->getRParenLoc()))
14129 CompareWithSrc = Ex;
14132 if (
const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
14133 if (SizeCall->getBuiltinCallee() == Builtin::BIstrlen &&
14134 SizeCall->getNumArgs() == 1)
14139 if (!CompareWithSrc)
14146 const DeclRefExpr *SrcArgDRE = dyn_cast<DeclRefExpr>(SrcArg);
14150 const DeclRefExpr *CompareWithSrcDRE = dyn_cast<DeclRefExpr>(CompareWithSrc);
14151 if (!CompareWithSrcDRE ||
14155 const Expr *OriginalSizeArg =
Call->getArg(2);
14156 Diag(CompareWithSrcDRE->
getBeginLoc(), diag::warn_strlcpycat_wrong_size)
14163 const Expr *DstArg =
Call->getArg(0)->IgnoreParenImpCasts();
14168 llvm::raw_svector_ostream
OS(sizeString);
14173 Diag(OriginalSizeArg->
getBeginLoc(), diag::note_strlcpycat_wrong_size)
14180 if (
const DeclRefExpr *D1 = dyn_cast_or_null<DeclRefExpr>(E1))
14181 if (
const DeclRefExpr *D2 = dyn_cast_or_null<DeclRefExpr>(E2))
14182 return D1->getDecl() == D2->getDecl();
14187 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
14191 return CE->getArg(0)->IgnoreParenCasts();
14199void Sema::CheckStrncatArguments(
const CallExpr *CE,
14214 unsigned PatternType = 0;
14222 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(LenArg)) {
14223 if (BE->getOpcode() == BO_Sub) {
14236 if (PatternType == 0)
14245 if (
SM.isMacroArgExpansion(SL)) {
14246 SL =
SM.getSpellingLoc(SL);
14255 if (!isKnownSizeArray) {
14256 if (PatternType == 1)
14257 Diag(SL, diag::warn_strncat_wrong_size) << SR;
14259 Diag(SL, diag::warn_strncat_src_size) << SR;
14263 if (PatternType == 1)
14264 Diag(SL, diag::warn_strncat_large_size) << SR;
14266 Diag(SL, diag::warn_strncat_src_size) << SR;
14269 llvm::raw_svector_ostream
OS(sizeString);
14277 Diag(SL, diag::note_strncat_wrong_size)
14282void CheckFreeArgumentsOnLvalue(
Sema &S,
const std::string &CalleeName,
14284 if (isa<FieldDecl, FunctionDecl, VarDecl>(D)) {
14286 << CalleeName << 0 << cast<NamedDecl>(D);
14291void CheckFreeArgumentsAddressof(
Sema &S,
const std::string &CalleeName,
14293 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->
getSubExpr())) {
14294 const Decl *D = Lvalue->getDecl();
14295 if (isa<DeclaratorDecl>(D))
14296 if (!dyn_cast<DeclaratorDecl>(D)->getType()->isReferenceType())
14297 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
14300 if (
const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->
getSubExpr()))
14301 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
14302 Lvalue->getMemberDecl());
14305void CheckFreeArgumentsPlus(
Sema &S,
const std::string &CalleeName,
14307 const auto *Lambda = dyn_cast<LambdaExpr>(
14312 S.
Diag(Lambda->getBeginLoc(), diag::warn_free_nonheap_object)
14313 << CalleeName << 2 ;
14316void CheckFreeArgumentsStackArray(
Sema &S,
const std::string &CalleeName,
14318 const auto *Var = dyn_cast<VarDecl>(Lvalue->
getDecl());
14319 if (Var ==
nullptr)
14323 << CalleeName << 0 << Var;
14326void CheckFreeArgumentsCast(
Sema &S,
const std::string &CalleeName,
14329 llvm::raw_svector_ostream OS(SizeString);
14332 if (Kind == clang::CK_BitCast &&
14333 !
Cast->getSubExpr()->getType()->isFunctionPointerType())
14335 if (Kind == clang::CK_IntegralToPointer &&
14336 !isa<IntegerLiteral>(
14337 Cast->getSubExpr()->IgnoreParenImpCasts()->IgnoreParens()))
14340 switch (
Cast->getCastKind()) {
14341 case clang::CK_BitCast:
14342 case clang::CK_IntegralToPointer:
14343 case clang::CK_FunctionToPointerDecay:
14352 S.
Diag(
Cast->getBeginLoc(), diag::warn_free_nonheap_object)
14353 << CalleeName << 0 << OS.str();
14358void Sema::CheckFreeArguments(
const CallExpr *E) {
14359 const std::string CalleeName =
14360 cast<FunctionDecl>(E->
getCalleeDecl())->getQualifiedNameAsString();
14364 if (
const auto *UnaryExpr = dyn_cast<UnaryOperator>(Arg))
14366 case UnaryOperator::Opcode::UO_AddrOf:
14367 return CheckFreeArgumentsAddressof(*
this, CalleeName, UnaryExpr);
14368 case UnaryOperator::Opcode::UO_Plus:
14369 return CheckFreeArgumentsPlus(*
this, CalleeName, UnaryExpr);
14374 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
14376 return CheckFreeArgumentsStackArray(*
this, CalleeName, Lvalue);
14378 if (
const auto *
Label = dyn_cast<AddrLabelExpr>(Arg)) {
14379 Diag(
Label->getBeginLoc(), diag::warn_free_nonheap_object)
14380 << CalleeName << 0 <<
Label->getLabel()->getIdentifier();
14384 if (isa<BlockExpr>(Arg)) {
14386 << CalleeName << 1 ;
14391 if (
const auto *Cast = dyn_cast<CastExpr>(E->
getArg(0)))
14392 return CheckFreeArgumentsCast(*
this, CalleeName, Cast);
14396Sema::CheckReturnValExpr(
Expr *RetValExp,
QualType lhsType,
14402 if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) ||
14405 Diag(ReturnLoc, diag::warn_null_ret)
14415 if (Op == OO_New || Op == OO_Array_New) {
14420 Diag(ReturnLoc, diag::warn_operator_new_returns_null)
14426 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
14432 CheckPPCMMAType(RetValExp->
getType(), ReturnLoc);
14445 auto getCastAndLiteral = [&FPLiteral, &FPCast](
Expr *L,
Expr *R) {
14446 FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
14448 return FPLiteral && FPCast;
14451 if (getCastAndLiteral(LHS, RHS) || getCastAndLiteral(RHS, LHS)) {
14457 llvm::APFloat TargetC = FPLiteral->
getValue();
14459 llvm::APFloat::rmNearestTiesToEven, &Lossy);
14463 Diag(
Loc, diag::warn_float_compare_literal)
14464 << (Opcode == BO_EQ) <<
QualType(SourceTy, 0)
14477 if (
auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
14478 if (
auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
14479 if (DRL->getDecl() == DRR->getDecl())
14487 if (
FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
14488 if (FLL->isExact())
14491 if (
FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
14492 if (FLR->isExact())
14496 if (
CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
14497 if (CL->getBuiltinCallee())
14500 if (
CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
14501 if (CR->getBuiltinCallee())
14505 Diag(
Loc, diag::warn_floatingpoint_eq)
14526 IntRange(
unsigned Width,
bool NonNegative)
14527 : Width(Width), NonNegative(NonNegative) {}
14530 unsigned valueBits()
const {
14531 return NonNegative ? Width : Width - 1;
14535 static IntRange forBoolType() {
14536 return IntRange(1,
true);
14541 return forValueOfCanonicalType(
C,
14549 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14550 T = VT->getElementType().getTypePtr();
14552 T = CT->getElementType().getTypePtr();
14553 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14554 T = AT->getValueType().getTypePtr();
14556 if (!
C.getLangOpts().CPlusPlus) {
14558 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14559 T = ET->getDecl()->getIntegerType().getDesugaredType(
C).getTypePtr();
14560 }
else if (
const EnumType *ET = dyn_cast<EnumType>(
T)) {
14565 if (
Enum->isFixed()) {
14566 return IntRange(
C.getIntWidth(
QualType(
T, 0)),
14567 !ET->isSignedIntegerOrEnumerationType());
14570 unsigned NumPositive =
Enum->getNumPositiveBits();
14571 unsigned NumNegative =
Enum->getNumNegativeBits();
14573 if (NumNegative == 0)
14574 return IntRange(NumPositive,
true);
14576 return IntRange(std::max(NumPositive + 1, NumNegative),
14580 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14581 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14597 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14598 T = VT->getElementType().getTypePtr();
14600 T = CT->getElementType().getTypePtr();
14601 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14602 T = AT->getValueType().getTypePtr();
14603 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14604 T =
C.getCanonicalType(ET->getDecl()->getIntegerType()).getTypePtr();
14606 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14607 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14616 static IntRange join(IntRange L, IntRange R) {
14617 bool Unsigned = L.NonNegative && R.NonNegative;
14618 return IntRange(std::max(L.valueBits(), R.valueBits()) + !
Unsigned,
14619 L.NonNegative && R.NonNegative);
14623 static IntRange bit_and(IntRange L, IntRange R) {
14624 unsigned Bits = std::max(L.Width, R.Width);
14625 bool NonNegative =
false;
14626 if (L.NonNegative) {
14627 Bits = std::min(Bits, L.Width);
14628 NonNegative =
true;
14630 if (R.NonNegative) {
14631 Bits = std::min(Bits, R.Width);
14632 NonNegative =
true;
14634 return IntRange(Bits, NonNegative);
14638 static IntRange sum(IntRange L, IntRange R) {
14639 bool Unsigned = L.NonNegative && R.NonNegative;
14640 return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !
Unsigned,
14645 static IntRange difference(IntRange L, IntRange R) {
14649 bool CanWiden = !L.NonNegative || !R.NonNegative;
14650 bool Unsigned = L.NonNegative && R.Width == 0;
14651 return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
14657 static IntRange product(IntRange L, IntRange R) {
14661 bool CanWiden = !L.NonNegative && !R.NonNegative;
14662 bool Unsigned = L.NonNegative && R.NonNegative;
14663 return IntRange(L.valueBits() + R.valueBits() + CanWiden + !
Unsigned,
14668 static IntRange rem(IntRange L, IntRange R) {
14672 return IntRange(std::min(L.valueBits(), R.valueBits()) + !
Unsigned,
14680 unsigned MaxWidth) {
14681 if (value.isSigned() && value.isNegative())
14682 return IntRange(value.getSignificantBits(),
false);
14684 if (value.getBitWidth() > MaxWidth)
14685 value = value.trunc(MaxWidth);
14689 return IntRange(value.getActiveBits(),
true);
14693 unsigned MaxWidth) {
14694 if (result.
isInt())
14701 R = IntRange::join(R, El);
14709 return IntRange::join(R, I);
14724 Ty = AtomicRHS->getValueType();
14737 bool InConstantContext,
bool Approximate) {
14748 if (
const auto *CE = dyn_cast<ImplicitCastExpr>(E)) {
14749 if (CE->getCastKind() == CK_NoOp || CE->getCastKind() == CK_LValueToRValue)
14750 return GetExprRange(
C, CE->getSubExpr(), MaxWidth, InConstantContext,
14753 IntRange OutputTypeRange = IntRange::forValueOfType(
C,
GetExprType(CE));
14755 bool isIntegerCast = CE->getCastKind() == CK_IntegralCast ||
14756 CE->getCastKind() == CK_BooleanToSignedIntegral;
14759 if (!isIntegerCast)
14760 return OutputTypeRange;
14763 std::min(MaxWidth, OutputTypeRange.Width),
14764 InConstantContext, Approximate);
14767 if (SubRange.Width >= OutputTypeRange.Width)
14768 return OutputTypeRange;
14772 return IntRange(SubRange.Width,
14773 SubRange.NonNegative || OutputTypeRange.NonNegative);
14776 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
14779 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult,
C))
14781 CondResult ? CO->getTrueExpr() : CO->getFalseExpr(),
14782 MaxWidth, InConstantContext, Approximate);
14787 Expr *E = CO->getTrueExpr();
14789 ? IntRange{0,
true}
14790 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14791 E = CO->getFalseExpr();
14793 ? IntRange{0,
true}
14794 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
14795 return IntRange::join(L, R);
14798 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
14799 IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
14801 switch (BO->getOpcode()) {
14803 llvm_unreachable(
"builtin <=> should have class type");
14814 return IntRange::forBoolType();
14832 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14843 Combine = IntRange::bit_and;
14851 = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
14852 if (I->getValue() == 1) {
14853 IntRange R = IntRange::forValueOfType(
C,
GetExprType(E));
14854 return IntRange(R.Width,
true);
14864 case BO_ShrAssign: {
14865 IntRange L =
GetExprRange(
C, BO->getLHS(), MaxWidth, InConstantContext,
14870 if (std::optional<llvm::APSInt> shift =
14871 BO->getRHS()->getIntegerConstantExpr(
C)) {
14872 if (shift->isNonNegative()) {
14873 if (shift->uge(L.Width))
14874 L.Width = (L.NonNegative ? 0 : 1);
14876 L.Width -= shift->getZExtValue();
14885 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
14890 Combine = IntRange::sum;
14894 if (BO->getLHS()->getType()->isPointerType())
14897 Combine = IntRange::difference;
14902 Combine = IntRange::product;
14910 IntRange L =
GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext,
14914 if (std::optional<llvm::APSInt> divisor =
14915 BO->getRHS()->getIntegerConstantExpr(
C)) {
14916 unsigned log2 = divisor->logBase2();
14917 if (
log2 >= L.Width)
14918 L.Width = (L.NonNegative ? 0 : 1);
14920 L.Width = std::min(L.Width -
log2, MaxWidth);
14927 IntRange R =
GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext,
14929 return IntRange(L.Width, L.NonNegative && R.NonNegative);
14933 Combine = IntRange::rem;
14945 unsigned opWidth =
C.getIntWidth(
T);
14947 GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext, Approximate);
14949 GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext, Approximate);
14950 IntRange
C = Combine(L, R);
14952 C.Width = std::min(
C.Width, MaxWidth);
14956 if (
const auto *UO = dyn_cast<UnaryOperator>(E)) {
14957 switch (UO->getOpcode()) {
14960 return IntRange::forBoolType();
14968 return GetExprRange(
C, UO->getSubExpr(), MaxWidth, InConstantContext,
14973 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
14974 return GetExprRange(
C, OVE->getSourceExpr(), MaxWidth, InConstantContext,
14978 return IntRange(BitField->getBitWidthValue(
C),
14979 BitField->getType()->isUnsignedIntegerOrEnumerationType());
14985 bool InConstantContext,
bool Approximate) {
14994 const llvm::fltSemantics &Src,
14995 const llvm::fltSemantics &Tgt) {
14996 llvm::APFloat truncated = value;
14999 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
15000 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
15002 return truncated.bitwiseIsEqual(value);
15011 const llvm::fltSemantics &Src,
15012 const llvm::fltSemantics &Tgt) {
15029 bool IsListInit =
false);
15035 if (isa<EnumConstantDecl>(DR->getDecl()))
15045 return MacroName !=
"YES" && MacroName !=
"NO" &&
15046 MacroName !=
"true" && MacroName !=
"false";
15069struct PromotedRange {
15071 llvm::APSInt PromotedMin;
15073 llvm::APSInt PromotedMax;
15075 PromotedRange(IntRange R,
unsigned BitWidth,
bool Unsigned) {
15077 PromotedMin = PromotedMax = llvm::APSInt(BitWidth,
Unsigned);
15078 else if (R.Width >= BitWidth && !
Unsigned) {
15082 PromotedMin = llvm::APSInt::getMinValue(BitWidth,
Unsigned);
15083 PromotedMax = llvm::APSInt::getMaxValue(BitWidth,
Unsigned);
15085 PromotedMin = llvm::APSInt::getMinValue(R.Width, R.NonNegative)
15086 .extOrTrunc(BitWidth);
15087 PromotedMin.setIsUnsigned(
Unsigned);
15089 PromotedMax = llvm::APSInt::getMaxValue(R.Width, R.NonNegative)
15090 .extOrTrunc(BitWidth);
15091 PromotedMax.setIsUnsigned(
Unsigned);
15096 bool isContiguous()
const {
return PromotedMin <= PromotedMax; }
15106 InRangeFlag = 0x40,
15109 Min =
LE | InRangeFlag,
15111 Max =
GE | InRangeFlag,
15114 OnlyValue =
LE |
GE |
EQ | InRangeFlag,
15119 assert(
Value.getBitWidth() == PromotedMin.getBitWidth() &&
15120 Value.isUnsigned() == PromotedMin.isUnsigned());
15121 if (!isContiguous()) {
15122 assert(
Value.isUnsigned() &&
"discontiguous range for signed compare");
15123 if (
Value.isMinValue())
return Min;
15124 if (
Value.isMaxValue())
return Max;
15130 switch (llvm::APSInt::compareValues(
Value, PromotedMin)) {
15131 case -1:
return Less;
15132 case 0:
return PromotedMin == PromotedMax ? OnlyValue :
Min;
15134 switch (llvm::APSInt::compareValues(
Value, PromotedMax)) {
15136 case 0:
return Max;
15141 llvm_unreachable(
"impossible compare result");
15144 static std::optional<StringRef>
15146 if (Op == BO_Cmp) {
15148 if (ConstantOnRHS) std::swap(LTFlag, GTFlag);
15150 if (R & EQ)
return StringRef(
"'std::strong_ordering::equal'");
15151 if (R & LTFlag)
return StringRef(
"'std::strong_ordering::less'");
15152 if (R & GTFlag)
return StringRef(
"'std::strong_ordering::greater'");
15153 return std::nullopt;
15160 }
else if (Op == BO_NE) {
15164 if ((Op == BO_LT || Op == BO_GE) ^ ConstantOnRHS) {
15171 if (Op == BO_GE || Op == BO_LE)
15172 std::swap(TrueFlag, FalseFlag);
15175 return StringRef(
"true");
15177 return StringRef(
"false");
15178 return std::nullopt;
15186 if (ICE->getCastKind() != CK_IntegralCast &&
15187 ICE->getCastKind() != CK_NoOp)
15189 E = ICE->getSubExpr();
15198 enum ConstantValueKind {
15203 if (
auto *BL = dyn_cast<CXXBoolLiteralExpr>(Constant))
15204 return BL->getValue() ? ConstantValueKind::LiteralTrue
15205 : ConstantValueKind::LiteralFalse;
15206 return ConstantValueKind::Miscellaneous;
15211 const llvm::APSInt &
Value,
15212 bool RhsConstant) {
15237 OtherT = AT->getValueType();
15238 IntRange OtherTypeRange = IntRange::forValueOfType(S.
Context, OtherT);
15242 bool IsObjCSignedCharBool = S.
getLangOpts().ObjC &&
15248 bool OtherIsBooleanDespiteType =
15250 if (OtherIsBooleanDespiteType || IsObjCSignedCharBool)
15251 OtherTypeRange = OtherValueRange = IntRange::forBoolType();
15255 PromotedRange OtherPromotedValueRange(OtherValueRange,
Value.getBitWidth(),
15256 Value.isUnsigned());
15257 auto Cmp = OtherPromotedValueRange.compare(
Value);
15258 auto Result = PromotedRange::constantValue(E->
getOpcode(), Cmp, RhsConstant);
15264 bool TautologicalTypeCompare =
false;
15266 PromotedRange OtherPromotedTypeRange(OtherTypeRange,
Value.getBitWidth(),
15267 Value.isUnsigned());
15268 auto TypeCmp = OtherPromotedTypeRange.compare(
Value);
15271 TautologicalTypeCompare =
true;
15279 if (!TautologicalTypeCompare && OtherValueRange.Width == 0)
15288 bool InRange = Cmp & PromotedRange::InRangeFlag;
15294 if (
Other->refersToBitField() && InRange &&
Value == 0 &&
15295 Other->getType()->isUnsignedIntegerOrEnumerationType())
15296 TautologicalTypeCompare =
true;
15301 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
15302 ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
15306 llvm::raw_svector_ostream OS(PrettySourceValue);
15308 OS <<
'\'' << *ED <<
"' (" <<
Value <<
")";
15309 }
else if (
auto *BL = dyn_cast<ObjCBoolLiteralExpr>(
15311 OS << (BL->getValue() ?
"YES" :
"NO");
15316 if (!TautologicalTypeCompare) {
15318 << RhsConstant << OtherValueRange.Width << OtherValueRange.NonNegative
15324 if (IsObjCSignedCharBool) {
15326 S.
PDiag(diag::warn_tautological_compare_objc_bool)
15327 << OS.str() << *
Result);
15334 if (!InRange ||
Other->isKnownToHaveBooleanValue()) {
15338 S.
PDiag(!InRange ? diag::warn_out_of_range_compare
15339 : diag::warn_tautological_bool_compare)
15341 << OtherIsBooleanDespiteType << *
Result
15348 ? diag::warn_unsigned_enum_always_true_comparison
15349 : IsCharTy ? diag::warn_unsigned_char_always_true_comparison
15350 : diag::warn_unsigned_always_true_comparison)
15351 : diag::warn_tautological_constant_compare;
15388 std::optional<llvm::APSInt> RHSValue =
15390 std::optional<llvm::APSInt> LHSValue =
15394 if (RHSValue && LHSValue)
15398 if ((
bool)RHSValue ^ (
bool)LHSValue) {
15400 const bool RhsConstant = (
bool)RHSValue;
15401 Expr *Const = RhsConstant ? RHS : LHS;
15403 const llvm::APSInt &
Value = RhsConstant ? *RHSValue : *LHSValue;
15426 if (
const auto *TET = dyn_cast<TypeOfExprType>(LHS->
getType()))
15428 if (
const auto *TET = dyn_cast<TypeOfExprType>(RHS->
getType()))
15434 Expr *signedOperand, *unsignedOperand;
15437 "unsigned comparison between two signed integer expressions?");
15438 signedOperand = LHS;
15439 unsignedOperand = RHS;
15441 signedOperand = RHS;
15442 unsignedOperand = LHS;
15448 IntRange signedRange =
15458 if (signedRange.NonNegative)
15467 IntRange unsignedRange =
15473 assert(unsignedRange.NonNegative &&
"unsigned range includes negative?");
15475 if (unsignedRange.Width < comparisonWidth)
15480 S.
PDiag(diag::warn_mixed_sign_comparison)
15508 S.
Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield)
15509 << BitfieldEnumDecl;
15516 Init->isValueDependent() ||
15517 Init->isTypeDependent())
15520 Expr *OriginalInit =
Init->IgnoreParenImpCasts();
15543 unsigned DiagID = 0;
15544 if (SignedEnum && !SignedBitfield) {
15545 DiagID = diag::warn_unsigned_bitfield_assigned_signed_enum;
15546 }
else if (SignedBitfield && !SignedEnum &&
15548 DiagID = diag::warn_signed_bitfield_enum_conversion;
15552 S.
Diag(InitLoc, DiagID) << Bitfield << ED;
15557 << SignedEnum << TypeRange;
15568 if (BitsNeeded > FieldWidth) {
15570 S.
Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
15582 unsigned OriginalWidth =
Value.getBitWidth();
15588 bool OneAssignedToOneBitBitfield = FieldWidth == 1 &&
Value == 1;
15589 if (OneAssignedToOneBitBitfield && !S.
LangOpts.CPlusPlus) {
15596 if (!
Value.isSigned() ||
Value.isNegative())
15597 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(OriginalInit))
15598 if (UO->getOpcode() == UO_Minus || UO->getOpcode() == UO_Not)
15599 OriginalWidth =
Value.getSignificantBits();
15601 if (OriginalWidth <= FieldWidth)
15605 llvm::APSInt TruncatedValue =
Value.trunc(FieldWidth);
15609 TruncatedValue = TruncatedValue.extend(OriginalWidth);
15610 if (llvm::APSInt::isSameValue(
Value, TruncatedValue))
15614 std::string PrettyTrunc =
toString(TruncatedValue, 10);
15616 S.
Diag(InitLoc, OneAssignedToOneBitBitfield
15617 ? diag::warn_impcast_single_bit_bitield_precision_constant
15618 : diag::warn_impcast_bitfield_precision_constant)
15619 << PrettyValue << PrettyTrunc << OriginalInit->
getType()
15620 <<
Init->getSourceRange();
15652 bool pruneControlFlow =
false) {
15653 if (pruneControlFlow) {
15667 unsigned diag,
bool pruneControlFlow =
false) {
15679 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
15680 Ignored = OVE->getSourceExpr();
15681 bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
15682 isa<BinaryOperator>(Ignored) ||
15683 isa<CXXOperatorCallExpr>(Ignored);
15700 if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
15703 const bool IsLiteral =
15704 isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
15706 llvm::APFloat
Value(0.0);
15713 S.
Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
15718 diag::warn_impcast_float_integer, PruneWarnings);
15721 bool isExact =
false;
15725 llvm::APFloat::opStatus
Result =
Value.convertToInteger(
15726 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
15734 unsigned precision = llvm::APFloat::semanticsPrecision(
Value.getSemantics());
15735 precision = (precision * 59 + 195) / 196;
15736 Value.toString(PrettySourceValue, precision);
15741 S.
Diag(CContext, diag::warn_impcast_constant_value_to_objc_bool)
15742 << PrettySourceValue);
15745 if (
Result == llvm::APFloat::opOK && isExact) {
15746 if (IsLiteral)
return;
15747 return DiagnoseImpCast(S, E,
T, CContext, diag::warn_impcast_float_integer,
15753 if (!IsBool &&
Result == llvm::APFloat::opInvalidOp)
15756 IsLiteral ? diag::warn_impcast_literal_float_to_integer_out_of_range
15757 : diag::warn_impcast_float_to_integer_out_of_range,
15760 unsigned DiagID = 0;
15763 DiagID = diag::warn_impcast_literal_float_to_integer;
15764 }
else if (IntegerValue == 0) {
15765 if (
Value.isZero()) {
15767 diag::warn_impcast_float_integer, PruneWarnings);
15770 DiagID = diag::warn_impcast_float_to_integer_zero;
15772 if (IntegerValue.isUnsigned()) {
15773 if (!IntegerValue.isMaxValue()) {
15775 diag::warn_impcast_float_integer, PruneWarnings);
15778 if (!IntegerValue.isMaxSignedValue() &&
15779 !IntegerValue.isMinSignedValue()) {
15781 diag::warn_impcast_float_integer, PruneWarnings);
15785 DiagID = diag::warn_impcast_float_to_integer;
15790 PrettyTargetValue =
Value.isZero() ?
"false" :
"true";
15792 IntegerValue.toString(PrettyTargetValue);
15794 if (PruneWarnings) {
15797 << E->
getType() <<
T.getUnqualifiedType()
15798 << PrettySourceValue << PrettyTargetValue
15802 << E->
getType() <<
T.getUnqualifiedType() << PrettySourceValue
15810 assert(isa<CompoundAssignOperator>(E) &&
15811 "Must be compound assignment operation");
15821 const auto *RBT = cast<CompoundAssignOperator>(E)
15822 ->getComputationResultType()
15829 if (ResultBT->isInteger())
15831 E->
getExprLoc(), diag::warn_impcast_float_integer);
15833 if (!ResultBT->isFloatingPoint())
15842 diag::warn_impcast_float_result_precision);
15847 if (!
Range.Width)
return "0";
15849 llvm::APSInt ValueInRange =
Value;
15850 ValueInRange.setIsSigned(!
Range.NonNegative);
15851 ValueInRange = ValueInRange.trunc(
Range.Width);
15852 return toString(ValueInRange, 10);
15856 if (!isa<ImplicitCastExpr>(Ex))
15861 const Type *Source =
15863 if (
Target->isDependentType())
15867 dyn_cast<BuiltinType>(ToBool ? Source :
Target);
15868 const Type *BoolCandidateType = ToBool ?
Target : Source;
15877 for (
unsigned i = 0; i < NumArgs; ++i) {
15882 bool IsSwapped = ((i > 0) &&
15884 IsSwapped |= ((i < (NumArgs - 1)) &&
15890 diag::warn_impcast_floating_point_to_bool);
15897 if (S.
Diags.
isIgnored(diag::warn_impcast_null_pointer_to_integer,
15902 if (isa<CallExpr>(E))
15907 bool IsGNUNullExpr = isa<GNUNullExpr>(NewE);
15909 if (!IsGNUNullExpr && !HasNullPtrType)
15929 if (MacroName ==
"NULL")
15937 S.
Diag(
Loc, diag::warn_impcast_null_pointer_to_integer)
15955 unsigned ElementKind) {
15957 if (
auto ICE = dyn_cast<ImplicitCastExpr>(Element)) {
15958 if (ICE->getCastKind() == CK_BitCast &&
15960 Element = ICE->getSubExpr();
15963 QualType ElementType = Element->getType();
15970 S.
Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element)
15971 << ElementType << ElementKind << TargetElementType
15972 << Element->getSourceRange();
15975 if (
auto ArrayLiteral = dyn_cast<ObjCArrayLiteral>(Element))
15977 else if (
auto DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(Element))
15989 if (!TargetObjCPtr)
15992 if (TargetObjCPtr->isUnspecialized() ||
15993 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl() !=
15998 if (TypeArgs.size() != 1)
16001 QualType TargetElementType = TypeArgs[0];
16002 for (
unsigned I = 0, N = ArrayLiteral->
getNumElements(); I != N; ++I) {
16018 if (!TargetObjCPtr)
16021 if (TargetObjCPtr->isUnspecialized() ||
16022 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl() !=
16027 if (TypeArgs.size() != 2)
16030 QualType TargetKeyType = TypeArgs[0];
16031 QualType TargetObjectType = TypeArgs[1];
16032 for (
unsigned I = 0, N = DictionaryLiteral->
getNumElements(); I != N; ++I) {
16047 const char FirstLiteralCharacter =
16049 if (FirstLiteralCharacter ==
'0')
16056 const char FirstContextCharacter =
16058 if (FirstContextCharacter ==
'{')
16066 const auto *IL = dyn_cast<IntegerLiteral>(E);
16068 if (
auto *UO = dyn_cast<UnaryOperator>(E)) {
16069 if (UO->getOpcode() == UO_Minus)
16070 return dyn_cast<IntegerLiteral>(UO->getSubExpr());
16081 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
16085 if (Opc == BO_Shl) {
16088 if (LHS && LHS->getValue() == 0)
16089 S.
Diag(ExprLoc, diag::warn_left_shift_always) << 0;
16091 RHS->getValue().isNonNegative() &&
16093 S.
Diag(ExprLoc, diag::warn_left_shift_always)
16094 << (
Result.Val.getInt() != 0);
16096 S.
Diag(ExprLoc, diag::warn_left_shift_in_bool_context) << E;
16100 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
16105 if ((LHS->getValue() == 0 || LHS->getValue() == 1) &&
16106 (RHS->getValue() == 0 || RHS->getValue() == 1))
16109 if (LHS->getValue() != 0 && RHS->getValue() != 0)
16110 S.
Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
16116 bool *ICContext =
nullptr,
16117 bool IsListInit =
false) {
16122 if (Source ==
Target)
return;
16123 if (
Target->isDependentType())
return;
16137 if (
Target->isSpecificBuiltinType(BuiltinType::Bool)) {
16138 if (isa<StringLiteral>(E))
16143 diag::warn_impcast_string_literal_to_bool);
16144 if (isa<ObjCStringLiteral>(E) || isa<ObjCArrayLiteral>(E) ||
16145 isa<ObjCDictionaryLiteral>(E) || isa<ObjCBoxedExpr>(E)) {
16149 diag::warn_impcast_objective_c_literal_to_bool);
16165 if (
Result.Val.getInt() != 1 &&
Result.Val.getInt() != 0) {
16168 S.
Diag(CC, diag::warn_impcast_constant_value_to_objc_bool)
16177 if (
auto *ArrayLiteral = dyn_cast<ObjCArrayLiteral>(E))
16179 else if (
auto *DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(E))
16183 if (isa<VectorType>(Source)) {
16184 if (
Target->isSveVLSBuiltinType() &&
16191 if (
Target->isRVVVLSBuiltinType() &&
16198 if (!isa<VectorType>(
Target)) {
16216 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
16217 Target = cast<VectorType>(
Target)->getElementType().getTypePtr();
16219 if (
auto VecTy = dyn_cast<VectorType>(
Target))
16220 Target = VecTy->getElementType().getTypePtr();
16223 if (isa<ComplexType>(Source)) {
16224 if (!isa<ComplexType>(
Target)) {
16230 ? diag::err_impcast_complex_scalar
16231 : diag::warn_impcast_complex_scalar);
16234 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
16235 Target = cast<ComplexType>(
Target)->getElementType().getTypePtr();
16238 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
16290 else if (Order < 0) {
16300 if (TargetBT && TargetBT->
isInteger()) {
16315 if (
Target->isBooleanType() && isa<CallExpr>(E)) {
16319 CallExpr *CEx = cast<CallExpr>(E);
16323 if (isa<ImplicitCastExpr>(LastA) &&
16327 diag::warn_impcast_floating_point_to_bool);
16336 if (
Target->isUnsaturatedFixedPointType()) {
16340 llvm::APFixedPoint
Value =
Result.Val.getFixedPoint();
16345 S.
PDiag(diag::warn_impcast_fixed_point_range)
16346 <<
Value.toString() <<
T
16352 }
else if (
Target->isIntegerType()) {
16357 llvm::APFixedPoint FXResult =
Result.Val.getFixedPoint();
16360 llvm::APSInt IntResult = FXResult.convertToInt(
16362 Target->isSignedIntegerOrEnumerationType(), &Overflowed);
16366 S.
PDiag(diag::warn_impcast_fixed_point_range)
16367 << FXResult.toString() <<
T
16374 }
else if (
Target->isUnsaturatedFixedPointType()) {
16382 llvm::APFixedPoint IntResult = llvm::APFixedPoint::getFromIntValue(
16387 S.
PDiag(diag::warn_impcast_fixed_point_range)
16406 unsigned int SourcePrecision =
SourceRange.Width;
16410 unsigned int TargetPrecision = llvm::APFloatBase::semanticsPrecision(
16413 if (SourcePrecision > 0 && TargetPrecision > 0 &&
16414 SourcePrecision > TargetPrecision) {
16416 if (std::optional<llvm::APSInt> SourceInt =
16421 llvm::APFloat TargetFloatValue(
16423 llvm::APFloat::opStatus ConversionStatus =
16424 TargetFloatValue.convertFromAPInt(
16426 llvm::APFloat::rmNearestTiesToEven);
16428 if (ConversionStatus != llvm::APFloat::opOK) {
16430 SourceInt->toString(PrettySourceValue, 10);
16432 TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
16436 S.
PDiag(diag::warn_impcast_integer_float_precision_constant)
16437 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16443 diag::warn_impcast_integer_float_precision);
16452 if (
Target->isBooleanType())
16460 if (
Target->isSpecificBuiltinType(BuiltinType::Bool))
16467 S.
Diag(CC, diag::warn_impcast_int_to_objc_signed_char_bool)
16471 IntRange SourceTypeRange =
16472 IntRange::forTargetOfCanonicalType(S.
Context, Source);
16475 IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.
Context,
Target);
16477 if (LikelySourceRange.Width > TargetRange.Width) {
16483 llvm::APSInt
Value(32);
16494 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16495 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16507 return DiagnoseImpCast(S, E,
T, CC, diag::warn_impcast_integer_precision);
16510 if (TargetRange.Width > SourceTypeRange.Width) {
16511 if (
auto *UO = dyn_cast<UnaryOperator>(E))
16512 if (UO->getOpcode() == UO_Minus)
16514 if (
Target->isUnsignedIntegerType())
16516 diag::warn_impcast_high_order_zero_bits);
16517 if (
Target->isSignedIntegerType())
16519 diag::warn_impcast_nonnegative_result);
16523 if (TargetRange.Width == LikelySourceRange.Width &&
16524 !TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16539 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16540 << PrettySourceValue << PrettyTargetValue << E->
getType()
16549 if ((!isa<EnumType>(
Target) || !isa<EnumType>(Source)) &&
16550 ((TargetRange.NonNegative && !LikelySourceRange.NonNegative) ||
16551 (!TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16552 LikelySourceRange.Width == TargetRange.Width))) {
16556 if (SourceBT && SourceBT->
isInteger() && TargetBT &&
16562 unsigned DiagID = diag::warn_impcast_integer_sign;
16570 DiagID = diag::warn_impcast_integer_sign_conditional;
16585 if (SourceEnum->getDecl()->hasNameForLinkage() &&
16586 TargetEnum->getDecl()->hasNameForLinkage() &&
16587 SourceEnum != TargetEnum) {
16592 diag::warn_impcast_different_enum_types);
16606 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(E))
16619 if (
auto *BCO = dyn_cast<BinaryConditionalOperator>(E))
16620 TrueExpr = BCO->getCommon();
16622 bool Suspicious =
false;
16631 if (!Suspicious)
return;
16634 if (!S.
Diags.
isIgnored(diag::warn_impcast_integer_sign_conditional, CC))
16641 Suspicious =
false;
16643 E->
getType(), CC, &Suspicious);
16646 E->
getType(), CC, &Suspicious);
16663struct AnalyzeImplicitConversionsWorkItem {
16673 Sema &S, AnalyzeImplicitConversionsWorkItem Item,
16675 Expr *OrigE = Item.E;
16684 bool IsListInit = Item.IsListInit ||
16685 (isa<InitListExpr>(OrigE) && S.
getLangOpts().CPlusPlus);
16690 Expr *SourceExpr = E;
16695 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(E))
16696 if (
auto *Src = OVE->getSourceExpr())
16699 if (
const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
16700 if (UO->getOpcode() == UO_Not &&
16701 UO->getSubExpr()->isKnownToHaveBooleanValue())
16702 S.
Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
16706 if (
const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
16707 if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
16708 BO->getLHS()->isKnownToHaveBooleanValue() &&
16709 BO->getRHS()->isKnownToHaveBooleanValue() &&
16710 BO->getLHS()->HasSideEffects(S.
Context) &&
16711 BO->getRHS()->HasSideEffects(S.
Context)) {
16722 if (SR.str() ==
"&" || SR.str() ==
"|") {
16724 S.
Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical)
16725 << (BO->getOpcode() == BO_And ?
"&" :
"|")
16728 BO->getOperatorLoc(),
16729 (BO->getOpcode() == BO_And ?
"&&" :
"||"));
16730 S.
Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
16736 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(SourceExpr)) {
16757 for (
auto *SE : POE->semantics())
16758 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(SE))
16759 WorkList.push_back({OVE->getSourceExpr(), CC, IsListInit});
16763 if (
auto *CE = dyn_cast<ExplicitCastExpr>(E)) {
16767 WorkList.push_back({E, CC, IsListInit});
16773 if (BO->isComparisonOp())
16777 if (BO->getOpcode() == BO_Assign)
16780 if (BO->isAssignmentOp())
16788 if (isa<StmtExpr>(E))
return;
16791 if (isa<UnaryExprOrTypeTraitExpr>(E))
return;
16796 bool IsLogicalAndOperator = BO && BO->
getOpcode() == BO_LAnd;
16798 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
16802 if (
auto *CSE = dyn_cast<CoroutineSuspendExpr>(E))
16803 if (ChildExpr == CSE->getOperand())
16809 if (IsLogicalAndOperator &&
16814 WorkList.push_back({ChildExpr, CC, IsListInit});
16819 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16823 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
16828 if (
U->getOpcode() == UO_LNot) {
16830 }
else if (
U->getOpcode() != UO_AddrOf) {
16831 if (
U->getSubExpr()->getType()->isAtomicType())
16832 S.
Diag(
U->getSubExpr()->getBeginLoc(),
16833 diag::warn_atomic_implicit_seq_cst);
16844 WorkList.push_back({OrigE, CC, IsListInit});
16845 while (!WorkList.empty())
16855 diag::err_opencl_enqueue_kernel_invalid_local_size_type);
16872 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
16875 }
else if (
const MemberExpr *M = dyn_cast<MemberExpr>(E)) {
16876 if (!M->getMemberDecl()->getType()->isReferenceType())
16878 }
else if (
const CallExpr *
Call = dyn_cast<CallExpr>(E)) {
16879 if (!
Call->getCallReturnType(SemaRef.
Context)->isReferenceType())
16881 FD =
Call->getDirectCallee();
16890 SemaRef.
Diag(FD->
getLocation(), diag::note_reference_is_return_value) << FD;
16904 if (
SM.isMacroBodyExpansion(
Loc))
16906 Loc =
SM.getImmediateMacroCallerLoc(
Loc);
16935 if (isa<CXXThisExpr>(E)) {
16936 unsigned DiagID = IsCompare ? diag::warn_this_null_compare
16937 : diag::warn_this_bool_conversion;
16942 bool IsAddressOf =
false;
16944 if (
auto *UO = dyn_cast<UnaryOperator>(E->
IgnoreParens())) {
16945 if (UO->getOpcode() != UO_AddrOf)
16947 IsAddressOf =
true;
16948 E = UO->getSubExpr();
16952 unsigned DiagID = IsCompare
16953 ? diag::warn_address_of_reference_null_compare
16954 : diag::warn_address_of_reference_bool_conversion;
16962 auto ComplainAboutNonnullParamOrCall = [&](
const Attr *NonnullAttr) {
16963 bool IsParam = isa<NonNullAttr>(NonnullAttr);
16965 llvm::raw_string_ostream S(Str);
16967 unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare
16968 : diag::warn_cast_nonnull_to_bool;
16971 Diag(NonnullAttr->getLocation(), diag::note_declared_nonnull) << IsParam;
16976 if (
auto *Callee =
Call->getDirectCallee()) {
16977 if (
const Attr *A = Callee->getAttr<ReturnsNonNullAttr>()) {
16978 ComplainAboutNonnullParamOrCall(A);
16987 if (
const auto *MCallExpr = dyn_cast<CXXMemberCallExpr>(E)) {
16988 if (
const auto *MRecordDecl = MCallExpr->getRecordDecl();
16989 MRecordDecl && MRecordDecl->isLambda()) {
16992 << MRecordDecl->getSourceRange() <<
Range << IsEqual;
17002 }
else if (
MemberExpr *M = dyn_cast<MemberExpr>(E)) {
17003 D = M->getMemberDecl();
17011 if (
const auto* PV = dyn_cast<ParmVarDecl>(D)) {
17014 if (
const Attr *A = PV->getAttr<NonNullAttr>()) {
17015 ComplainAboutNonnullParamOrCall(A);
17019 if (
const auto *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
17023 auto ParamIter = llvm::find(FD->
parameters(), PV);
17025 unsigned ParamNo = std::distance(FD->
param_begin(), ParamIter);
17029 ComplainAboutNonnullParamOrCall(
NonNull);
17034 if (ArgNo.getASTIndex() == ParamNo) {
17035 ComplainAboutNonnullParamOrCall(
NonNull);
17049 if (IsAddressOf && IsFunction) {
17054 if (!IsAddressOf && !IsFunction && !IsArray)
17059 llvm::raw_string_ostream S(Str);
17062 unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare
17063 : diag::warn_impcast_pointer_to_bool;
17070 DiagType = AddressOf;
17071 else if (IsFunction)
17072 DiagType = FunctionPointer;
17074 DiagType = ArrayPointer;
17076 llvm_unreachable(
"Could not determine diagnostic.");
17078 <<
Range << IsEqual;
17091 if (ReturnType.
isNull())
17136 CheckArrayAccess(E);
17145 ::CheckBoolLikeConversion(*
this, E, CC);
17150void Sema::CheckForIntOverflow (
const Expr *E) {
17155 const Expr *OriginalE = Exprs.pop_back_val();
17158 if (isa<BinaryOperator, UnaryOperator>(E)) {
17163 if (
const auto *InitList = dyn_cast<InitListExpr>(OriginalE))
17164 Exprs.append(InitList->inits().begin(), InitList->inits().end());
17165 else if (isa<ObjCBoxedExpr>(OriginalE))
17167 else if (
const auto *
Call = dyn_cast<CallExpr>(E))
17168 Exprs.append(
Call->arg_begin(),
Call->arg_end());
17169 else if (
const auto *Message = dyn_cast<ObjCMessageExpr>(E))
17170 Exprs.append(Message->arg_begin(), Message->arg_end());
17171 else if (
const auto *Construct = dyn_cast<CXXConstructExpr>(E))
17172 Exprs.append(Construct->arg_begin(), Construct->arg_end());
17173 else if (
const auto *Temporary = dyn_cast<CXXBindTemporaryExpr>(E))
17174 Exprs.push_back(Temporary->getSubExpr());
17175 else if (
const auto *Array = dyn_cast<ArraySubscriptExpr>(E))
17176 Exprs.push_back(Array->getIdx());
17177 else if (
const auto *Compound = dyn_cast<CompoundLiteralExpr>(E))
17178 Exprs.push_back(Compound->getInitializer());
17179 else if (
const auto *New = dyn_cast<CXXNewExpr>(E);
17180 New && New->isArray()) {
17181 if (
auto ArraySize = New->getArraySize())
17182 Exprs.push_back(*ArraySize);
17184 }
while (!Exprs.empty());
17199 class SequenceTree {
17203 LLVM_PREFERRED_TYPE(
bool)
17204 unsigned Merged : 1;
17212 friend class SequenceTree;
17216 explicit Seq(
unsigned N) : Index(N) {}
17219 Seq() : Index(0) {}
17222 SequenceTree() { Values.push_back(
Value(0)); }
17223 Seq root()
const {
return Seq(0); }
17230 return Seq(Values.size() - 1);
17234 void merge(
Seq S) {
17235 Values[S.Index].Merged =
true;
17241 bool isUnsequenced(
Seq Cur,
Seq Old) {
17242 unsigned C = representative(Cur.Index);
17243 unsigned Target = representative(Old.Index);
17247 C = Values[
C].Parent;
17254 unsigned representative(
unsigned K) {
17255 if (Values[K].Merged)
17257 return Values[K].Parent = representative(Values[K].
Parent);
17277 UK_ModAsSideEffect,
17279 UK_Count = UK_ModAsSideEffect + 1
17285 const Expr *UsageExpr =
nullptr;
17286 SequenceTree::Seq
Seq;
17292 Usage Uses[UK_Count];
17295 bool Diagnosed =
false;
17299 using UsageInfoMap = llvm::SmallDenseMap<Object, UsageInfo, 16>;
17307 UsageInfoMap UsageMap;
17310 SequenceTree::Seq Region;
17325 struct SequencedSubexpression {
17326 SequencedSubexpression(SequenceChecker &Self)
17327 : Self(Self), OldModAsSideEffect(Self.ModAsSideEffect) {
17328 Self.ModAsSideEffect = &ModAsSideEffect;
17331 ~SequencedSubexpression() {
17332 for (
const std::pair<Object, Usage> &M : llvm::reverse(ModAsSideEffect)) {
17336 UsageInfo &UI = Self.UsageMap[M.first];
17337 auto &SideEffectUsage = UI.Uses[UK_ModAsSideEffect];
17338 Self.addUsage(M.first, UI, SideEffectUsage.UsageExpr, UK_ModAsValue);
17339 SideEffectUsage = M.second;
17341 Self.ModAsSideEffect = OldModAsSideEffect;
17344 SequenceChecker &Self;
17353 class EvaluationTracker {
17355 EvaluationTracker(SequenceChecker &Self)
17356 : Self(Self), Prev(Self.EvalTracker) {
17357 Self.EvalTracker =
this;
17360 ~EvaluationTracker() {
17361 Self.EvalTracker = Prev;
17363 Prev->EvalOK &= EvalOK;
17366 bool evaluate(
const Expr *E,
bool &Result) {
17370 Result, Self.SemaRef.Context,
17371 Self.SemaRef.isConstantEvaluatedContext());
17376 SequenceChecker &Self;
17377 EvaluationTracker *Prev;
17378 bool EvalOK =
true;
17379 } *EvalTracker =
nullptr;
17383 Object getObject(
const Expr *E,
bool Mod)
const {
17385 if (
const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
17386 if (Mod && (UO->getOpcode() == UO_PreInc || UO->getOpcode() == UO_PreDec))
17387 return getObject(UO->getSubExpr(), Mod);
17388 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
17389 if (BO->getOpcode() == BO_Comma)
17390 return getObject(BO->getRHS(), Mod);
17391 if (Mod && BO->isAssignmentOp())
17392 return getObject(BO->getLHS(), Mod);
17393 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
17395 if (isa<CXXThisExpr>(ME->getBase()->IgnoreParenCasts()))
17396 return ME->getMemberDecl();
17397 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
17406 void addUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr, UsageKind UK) {
17408 Usage &
U = UI.Uses[UK];
17409 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq)) {
17413 if (UK == UK_ModAsSideEffect && ModAsSideEffect)
17414 ModAsSideEffect->push_back(std::make_pair(O,
U));
17416 U.UsageExpr = UsageExpr;
17426 void checkUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr,
17427 UsageKind OtherKind,
bool IsModMod) {
17431 const Usage &
U = UI.Uses[OtherKind];
17432 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq))
17435 const Expr *Mod =
U.UsageExpr;
17436 const Expr *ModOrUse = UsageExpr;
17437 if (OtherKind == UK_Use)
17438 std::swap(Mod, ModOrUse);
17442 SemaRef.
PDiag(IsModMod ? diag::warn_unsequenced_mod_mod
17443 : diag::warn_unsequenced_mod_use)
17445 UI.Diagnosed =
true;
17474 void notePreUse(Object O,
const Expr *UseExpr) {
17475 UsageInfo &UI = UsageMap[O];
17477 checkUsage(O, UI, UseExpr, UK_ModAsValue,
false);
17480 void notePostUse(Object O,
const Expr *UseExpr) {
17481 UsageInfo &UI = UsageMap[O];
17482 checkUsage(O, UI, UseExpr, UK_ModAsSideEffect,
17484 addUsage(O, UI, UseExpr, UK_Use);
17487 void notePreMod(Object O,
const Expr *ModExpr) {
17488 UsageInfo &UI = UsageMap[O];
17490 checkUsage(O, UI, ModExpr, UK_ModAsValue,
true);
17491 checkUsage(O, UI, ModExpr, UK_Use,
false);
17494 void notePostMod(Object O,
const Expr *ModExpr, UsageKind UK) {
17495 UsageInfo &UI = UsageMap[O];
17496 checkUsage(O, UI, ModExpr, UK_ModAsSideEffect,
17498 addUsage(O, UI, ModExpr, UK);
17502 SequenceChecker(
Sema &S,
const Expr *E,
17504 :
Base(S.Context), SemaRef(S), Region(
Tree.root()), WorkList(WorkList) {
17508 (void)this->WorkList;
17511 void VisitStmt(
const Stmt *S) {
17515 void VisitExpr(
const Expr *E) {
17517 Base::VisitStmt(E);
17521 for (
auto *Sub : CSE->
children()) {
17522 const Expr *ChildExpr = dyn_cast_or_null<Expr>(Sub);
17537 void VisitCastExpr(
const CastExpr *E) {
17549 void VisitSequencedExpressions(
const Expr *SequencedBefore,
17550 const Expr *SequencedAfter) {
17551 SequenceTree::Seq BeforeRegion =
Tree.allocate(Region);
17552 SequenceTree::Seq AfterRegion =
Tree.allocate(Region);
17553 SequenceTree::Seq OldRegion = Region;
17556 SequencedSubexpression SeqBefore(*
this);
17557 Region = BeforeRegion;
17558 Visit(SequencedBefore);
17561 Region = AfterRegion;
17562 Visit(SequencedAfter);
17564 Region = OldRegion;
17566 Tree.merge(BeforeRegion);
17567 Tree.merge(AfterRegion);
17575 VisitSequencedExpressions(ASE->
getLHS(), ASE->
getRHS());
17582 void VisitBinPtrMemD(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17583 void VisitBinPtrMemI(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17589 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17596 void VisitBinShl(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17597 void VisitBinShr(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
17602 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17614 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
17618 SequenceTree::Seq RHSRegion;
17619 SequenceTree::Seq LHSRegion;
17621 RHSRegion =
Tree.allocate(Region);
17622 LHSRegion =
Tree.allocate(Region);
17624 RHSRegion = Region;
17625 LHSRegion = Region;
17627 SequenceTree::Seq OldRegion = Region;
17643 SequencedSubexpression SeqBefore(*
this);
17644 Region = RHSRegion;
17648 Region = LHSRegion;
17651 if (O && isa<CompoundAssignOperator>(BO))
17652 notePostUse(O, BO);
17656 Region = LHSRegion;
17659 if (O && isa<CompoundAssignOperator>(BO))
17660 notePostUse(O, BO);
17662 Region = RHSRegion;
17670 Region = OldRegion;
17674 : UK_ModAsSideEffect);
17676 Tree.merge(RHSRegion);
17677 Tree.merge(LHSRegion);
17682 VisitBinAssign(CAO);
17685 void VisitUnaryPreInc(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17686 void VisitUnaryPreDec(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
17690 return VisitExpr(UO);
17698 : UK_ModAsSideEffect);
17701 void VisitUnaryPostInc(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17702 void VisitUnaryPostDec(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
17706 return VisitExpr(UO);
17710 notePostMod(O, UO, UK_ModAsSideEffect);
17719 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17720 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17721 SequenceTree::Seq OldRegion = Region;
17723 EvaluationTracker Eval(*
this);
17725 SequencedSubexpression Sequenced(*
this);
17726 Region = LHSRegion;
17733 bool EvalResult =
false;
17734 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17735 bool ShouldVisitRHS = !EvalOK || !EvalResult;
17736 if (ShouldVisitRHS) {
17737 Region = RHSRegion;
17741 Region = OldRegion;
17742 Tree.merge(LHSRegion);
17743 Tree.merge(RHSRegion);
17752 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
17753 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
17754 SequenceTree::Seq OldRegion = Region;
17756 EvaluationTracker Eval(*
this);
17758 SequencedSubexpression Sequenced(*
this);
17759 Region = LHSRegion;
17765 bool EvalResult =
false;
17766 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
17767 bool ShouldVisitRHS = !EvalOK || EvalResult;
17768 if (ShouldVisitRHS) {
17769 Region = RHSRegion;
17773 Region = OldRegion;
17774 Tree.merge(LHSRegion);
17775 Tree.merge(RHSRegion);
17783 SequenceTree::Seq ConditionRegion =
Tree.allocate(Region);
17799 SequenceTree::Seq TrueRegion =
Tree.allocate(Region);
17800 SequenceTree::Seq FalseRegion =
Tree.allocate(Region);
17801 SequenceTree::Seq OldRegion = Region;
17803 EvaluationTracker Eval(*
this);
17805 SequencedSubexpression Sequenced(*
this);
17806 Region = ConditionRegion;
17816 bool EvalResult =
false;
17817 bool EvalOK = Eval.evaluate(CO->
getCond(), EvalResult);
17818 bool ShouldVisitTrueExpr = !EvalOK || EvalResult;
17819 bool ShouldVisitFalseExpr = !EvalOK || !EvalResult;
17820 if (ShouldVisitTrueExpr) {
17821 Region = TrueRegion;
17824 if (ShouldVisitFalseExpr) {
17825 Region = FalseRegion;
17829 Region = OldRegion;
17830 Tree.merge(ConditionRegion);
17831 Tree.merge(TrueRegion);
17832 Tree.merge(FalseRegion);
17835 void VisitCallExpr(
const CallExpr *CE) {
17847 SequencedSubexpression Sequenced(*
this);
17852 SequenceTree::Seq CalleeRegion;
17853 SequenceTree::Seq OtherRegion;
17854 if (SemaRef.getLangOpts().CPlusPlus17) {
17855 CalleeRegion = Tree.allocate(Region);
17856 OtherRegion = Tree.allocate(Region);
17858 CalleeRegion = Region;
17859 OtherRegion = Region;
17861 SequenceTree::Seq OldRegion = Region;
17864 Region = CalleeRegion;
17866 SequencedSubexpression Sequenced(*this);
17867 Visit(CE->getCallee());
17869 Visit(CE->getCallee());
17873 Region = OtherRegion;
17877 Region = OldRegion;
17879 Tree.merge(CalleeRegion);
17880 Tree.merge(OtherRegion);
17898 return VisitCallExpr(CXXOCE);
17909 case OO_MinusEqual:
17911 case OO_SlashEqual:
17912 case OO_PercentEqual:
17913 case OO_CaretEqual:
17916 case OO_LessLessEqual:
17917 case OO_GreaterGreaterEqual:
17918 SequencingKind = RHSBeforeLHS;
17922 case OO_GreaterGreater:
17928 SequencingKind = LHSBeforeRHS;
17932 SequencingKind = LHSBeforeRest;
17936 SequencingKind = NoSequencing;
17940 if (SequencingKind == NoSequencing)
17941 return VisitCallExpr(CXXOCE);
17944 SequencedSubexpression Sequenced(*
this);
17947 assert(SemaRef.getLangOpts().CPlusPlus17 &&
17948 "Should only get there with C++17 and above!");
17949 assert((CXXOCE->getNumArgs() == 2 || CXXOCE->getOperator() == OO_Call) &&
17950 "Should only get there with an overloaded binary operator"
17951 " or an overloaded call operator!");
17953 if (SequencingKind == LHSBeforeRest) {
17954 assert(CXXOCE->getOperator() == OO_Call &&
17955 "We should only have an overloaded call operator here!");
17964 SequenceTree::Seq PostfixExprRegion = Tree.allocate(Region);
17965 SequenceTree::Seq ArgsRegion = Tree.allocate(Region);
17966 SequenceTree::Seq OldRegion = Region;
17968 assert(CXXOCE->getNumArgs() >= 1 &&
17969 "An overloaded call operator must have at least one argument"
17970 " for the postfix-expression!");
17971 const Expr *PostfixExpr = CXXOCE->getArgs()[0];
17972 llvm::ArrayRef<const Expr *> Args(CXXOCE->getArgs() + 1,
17973 CXXOCE->getNumArgs() - 1);
17977 Region = PostfixExprRegion;
17978 SequencedSubexpression Sequenced(*this);
17979 Visit(PostfixExpr);
17983 Region = ArgsRegion;
17984 for (const Expr *Arg : Args)
17987 Region = OldRegion;
17988 Tree.merge(PostfixExprRegion);
17989 Tree.merge(ArgsRegion);
17991 assert(CXXOCE->getNumArgs() == 2 &&
17992 "Should only have two arguments here!");
17993 assert((SequencingKind == LHSBeforeRHS ||
17994 SequencingKind == RHSBeforeLHS) &&
17995 "Unexpected sequencing kind!");
17999 const Expr *E1 = CXXOCE->getArg(0);
18000 const Expr *E2 = CXXOCE->getArg(1);
18001 if (SequencingKind == RHSBeforeLHS)
18004 return VisitSequencedExpressions(E1, E2);
18011 SequencedSubexpression Sequenced(*
this);
18014 return VisitExpr(CCE);
18017 SequenceExpressionsInOrder(
18023 return VisitExpr(ILE);
18026 SequenceExpressionsInOrder(ILE->
inits());
18038 SequenceTree::Seq
Parent = Region;
18039 for (
const Expr *E : ExpressionList) {
18043 Elts.push_back(Region);
18049 for (
unsigned I = 0; I < Elts.size(); ++I)
18050 Tree.merge(Elts[I]);
18054SequenceChecker::UsageInfo::UsageInfo() =
default;
18058void Sema::CheckUnsequencedOperations(
const Expr *E) {
18060 WorkList.push_back(E);
18061 while (!WorkList.empty()) {
18062 const Expr *Item = WorkList.pop_back_val();
18063 SequenceChecker(*
this, Item, WorkList);
18068 bool IsConstexpr) {
18070 IsConstexpr || isa<ConstantExpr>(E));
18071 CheckImplicitConversions(E, CheckLoc);
18073 CheckUnsequencedOperations(E);
18075 CheckForIntOverflow(E);
18089 if (
const auto *PointerTy = dyn_cast<PointerType>(PType)) {
18093 if (
const auto *ReferenceTy = dyn_cast<ReferenceType>(PType)) {
18097 if (
const auto *ParenTy = dyn_cast<ParenType>(PType)) {
18111 S.
Diag(
Loc, diag::err_array_star_in_function_definition);
18120 bool CheckParameterNames) {
18121 bool HasInvalidParm =
false;
18123 assert(Param &&
"null in a parameter list");
18132 if (!Param->isInvalidDecl() &&
18134 diag::err_typecheck_decl_incomplete_type) ||
18136 diag::err_abstract_type_in_decl,
18138 Param->setInvalidDecl();
18139 HasInvalidParm =
true;
18144 if (CheckParameterNames && Param->getIdentifier() ==
nullptr &&
18148 Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c23);
18156 QualType PType = Param->getOriginalType();
18164 if (!Param->isInvalidDecl()) {
18166 if (!ClassDecl->isInvalidDecl() &&
18167 !ClassDecl->hasIrrelevantDestructor() &&
18168 !ClassDecl->isDependentContext() &&
18169 ClassDecl->isParamDestroyedInCallee()) {
18181 if (
const auto *
Attr = Param->getAttr<PassObjectSizeAttr>())
18182 if (!Param->getType().isConstQualified())
18183 Diag(Param->getLocation(), diag::err_attribute_pointers_only)
18187 if (
LangOpts.CPlusPlus && !Param->isInvalidDecl()) {
18192 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC->
getParent()))
18193 CheckShadowInheritedFields(Param->getLocation(), Param->getDeclName(),
18198 if (!Param->isInvalidDecl() &&
18200 Param->setInvalidDecl();
18201 HasInvalidParm =
true;
18202 Diag(Param->getLocation(), diag::err_wasm_table_as_function_parameter);
18206 return HasInvalidParm;
18209std::optional<std::pair<
18218static std::pair<CharUnits, CharUnits>
18226 if (
Base->isVirtual()) {
18233 BaseAlignment = std::min(BaseAlignment, NonVirtualAlignment);
18240 DerivedType =
Base->getType();
18243 return std::make_pair(BaseAlignment, Offset);
18247static std::optional<std::pair<CharUnits, CharUnits>>
18253 return std::nullopt;
18258 return std::nullopt;
18262 CharUnits Offset = EltSize * IdxRes->getExtValue();
18265 return std::make_pair(
P->first,
P->second + Offset);
18271 return std::make_pair(
18272 P->first.alignmentAtOffset(
P->second).alignmentAtOffset(EltSize),
18278std::optional<std::pair<
18286 case Stmt::CStyleCastExprClass:
18287 case Stmt::CXXStaticCastExprClass:
18288 case Stmt::ImplicitCastExprClass: {
18289 auto *CE = cast<CastExpr>(E);
18290 const Expr *From = CE->getSubExpr();
18291 switch (CE->getCastKind()) {
18296 case CK_UncheckedDerivedToBase:
18297 case CK_DerivedToBase: {
18307 case Stmt::ArraySubscriptExprClass: {
18308 auto *ASE = cast<ArraySubscriptExpr>(E);
18312 case Stmt::DeclRefExprClass: {
18313 if (
auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
18316 if (!VD->getType()->isReferenceType()) {
18318 if (VD->hasDependentAlignment())
18327 case Stmt::MemberExprClass: {
18328 auto *ME = cast<MemberExpr>(E);
18329 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
18333 std::optional<std::pair<CharUnits, CharUnits>>
P;
18342 return std::make_pair(
P->first,
18345 case Stmt::UnaryOperatorClass: {
18346 auto *UO = cast<UnaryOperator>(E);
18355 case Stmt::BinaryOperatorClass: {
18356 auto *BO = cast<BinaryOperator>(E);
18367 return std::nullopt;
18372std::optional<std::pair<
18381 case Stmt::CStyleCastExprClass:
18382 case Stmt::CXXStaticCastExprClass:
18383 case Stmt::ImplicitCastExprClass: {
18384 auto *CE = cast<CastExpr>(E);
18385 const Expr *From = CE->getSubExpr();
18386 switch (CE->getCastKind()) {
18391 case CK_ArrayToPointerDecay:
18393 case CK_UncheckedDerivedToBase:
18394 case CK_DerivedToBase: {
18404 case Stmt::CXXThisExprClass: {
18409 case Stmt::UnaryOperatorClass: {
18410 auto *UO = cast<UnaryOperator>(E);
18415 case Stmt::BinaryOperatorClass: {
18416 auto *BO = cast<BinaryOperator>(E);
18424 if (Opcode == BO_Add && !RHS->getType()->isIntegralOrEnumerationType())
18425 std::swap(LHS, RHS);
18435 return std::nullopt;
18440 std::optional<std::pair<CharUnits, CharUnits>>
P =
18444 return P->first.alignmentAtOffset(
P->second);
18464 if (!DestPtr)
return;
18470 if (DestAlign.
isOne())
return;
18474 if (!SrcPtr)
return;
18485 if (SrcAlign >= DestAlign)
return;
18490 <<
static_cast<unsigned>(DestAlign.
getQuantity())
18494void Sema::CheckArrayAccess(
const Expr *BaseExpr,
const Expr *IndexExpr,
18496 bool AllowOnePastEnd,
bool IndexNegated) {
18505 const Type *EffectiveType =
18512 StrictFlexArraysLevel =
getLangOpts().getStrictFlexArraysLevel();
18514 const Type *BaseType =
18516 bool IsUnboundedArray =
18518 Context, StrictFlexArraysLevel,
18528 llvm::APSInt index =
Result.Val.getInt();
18529 if (IndexNegated) {
18530 index.setIsUnsigned(
false);
18534 if (IsUnboundedArray) {
18537 if (index.isUnsigned() || !index.isNegative()) {
18539 unsigned AddrBits = ASTC.getTargetInfo().getPointerWidth(
18541 if (index.getBitWidth() < AddrBits)
18542 index = index.zext(AddrBits);
18543 std::optional<CharUnits> ElemCharUnits =
18544 ASTC.getTypeSizeInCharsIfKnown(EffectiveType);
18547 if (!ElemCharUnits || ElemCharUnits->isZero())
18549 llvm::APInt ElemBytes(index.getBitWidth(), ElemCharUnits->getQuantity());
18554 if (index.getActiveBits() <= AddrBits) {
18556 llvm::APInt Product(index);
18558 Product = Product.umul_ov(ElemBytes, Overflow);
18559 if (!Overflow && Product.getActiveBits() <= AddrBits)
18565 llvm::APInt MaxElems = llvm::APInt::getMaxValue(AddrBits);
18566 MaxElems = MaxElems.zext(std::max(AddrBits + 1, ElemBytes.getBitWidth()));
18568 ElemBytes = ElemBytes.zextOrTrunc(MaxElems.getBitWidth());
18569 MaxElems = MaxElems.udiv(ElemBytes);
18572 ASE ? diag::warn_array_index_exceeds_max_addressable_bounds
18573 : diag::warn_ptr_arith_exceeds_max_addressable_bounds;
18579 <<
toString(index, 10,
true) << AddrBits
18580 << (
unsigned)ASTC.toBits(*ElemCharUnits)
18583 << (
unsigned)MaxElems.getLimitedValue(~0
U)
18588 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18590 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18592 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18593 ND = ME->getMemberDecl();
18597 PDiag(diag::note_array_declared_here) << ND);
18602 if (index.isUnsigned() || !index.isNegative()) {
18612 llvm::APInt size = ArrayTy->
getSize();
18614 if (BaseType != EffectiveType) {
18622 if (!ptrarith_typesize)
18625 if (ptrarith_typesize != array_typesize) {
18627 uint64_t ratio = array_typesize / ptrarith_typesize;
18631 if (ptrarith_typesize * ratio == array_typesize)
18632 size *= llvm::APInt(size.getBitWidth(), ratio);
18636 if (size.getBitWidth() > index.getBitWidth())
18637 index = index.zext(size.getBitWidth());
18638 else if (size.getBitWidth() < index.getBitWidth())
18639 size = size.zext(index.getBitWidth());
18645 if (AllowOnePastEnd ? index.ule(size) : index.ult(size))
18662 unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds
18663 : diag::warn_ptr_arith_exceeds_bounds;
18664 unsigned CastMsg = (!ASE || BaseType == EffectiveType) ? 0 : 1;
18672 unsigned DiagID = diag::warn_array_index_precedes_bounds;
18674 DiagID = diag::warn_ptr_arith_precedes_bounds;
18675 if (index.isNegative()) index = -index;
18685 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18687 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18689 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18690 ND = ME->getMemberDecl();
18694 PDiag(diag::note_array_declared_here) << ND);
18697void Sema::CheckArrayAccess(
const Expr *
expr) {
18698 int AllowOnePastEnd = 0;
18700 expr =
expr->IgnoreParenImpCasts();
18701 switch (
expr->getStmtClass()) {
18702 case Stmt::ArraySubscriptExprClass: {
18705 AllowOnePastEnd > 0);
18709 case Stmt::MemberExprClass: {
18710 expr = cast<MemberExpr>(
expr)->getBase();
18713 case Stmt::ArraySectionExprClass: {
18719 nullptr, AllowOnePastEnd > 0);
18722 case Stmt::UnaryOperatorClass: {
18738 case Stmt::ConditionalOperatorClass: {
18741 CheckArrayAccess(lhs);
18743 CheckArrayAccess(rhs);
18746 case Stmt::CXXOperatorCallExprClass: {
18747 const auto *OCE = cast<CXXOperatorCallExpr>(
expr);
18748 for (
const auto *Arg : OCE->arguments())
18749 CheckArrayAccess(Arg);
18759 Expr *RHS,
bool isProperty) {
18771 S.
Diag(
Loc, diag::warn_arc_literal_assign)
18773 << (isProperty ? 0 : 1)
18781 Expr *RHS,
bool isProperty) {
18784 if (
cast->getCastKind() == CK_ARCConsumeObject) {
18785 S.
Diag(
Loc, diag::warn_arc_retained_assign)
18787 << (isProperty ? 0 : 1)
18791 RHS =
cast->getSubExpr();
18862 if (
cast->getCastKind() == CK_ARCConsumeObject) {
18863 Diag(
Loc, diag::warn_arc_retained_property_assign)
18867 RHS =
cast->getSubExpr();
18890 bool StmtLineInvalid;
18893 if (StmtLineInvalid)
18896 bool BodyLineInvalid;
18899 if (BodyLineInvalid)
18903 if (StmtLine != BodyLine)
18918 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
18927 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
18931 const Stmt *PossibleBody) {
18937 if (
const ForStmt *FS = dyn_cast<ForStmt>(S)) {
18938 StmtLoc = FS->getRParenLoc();
18939 Body = FS->getBody();
18940 DiagID = diag::warn_empty_for_body;
18941 }
else if (
const WhileStmt *WS = dyn_cast<WhileStmt>(S)) {
18942 StmtLoc = WS->getRParenLoc();
18943 Body = WS->getBody();
18944 DiagID = diag::warn_empty_while_body;
18949 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
18972 bool ProbableTypo = isa<CompoundStmt>(PossibleBody);
18973 if (!ProbableTypo) {
18974 bool BodyColInvalid;
18977 if (BodyColInvalid)
18980 bool StmtColInvalid;
18983 if (StmtColInvalid)
18986 if (BodyCol > StmtCol)
18987 ProbableTypo =
true;
18990 if (ProbableTypo) {
18992 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19001 if (
Diags.
isIgnored(diag::warn_sizeof_pointer_expr_memaccess, OpLoc))
19013 if (
const auto *CE = dyn_cast<CallExpr>(RHSExpr);
19015 RHSExpr = CE->
getArg(0);
19016 else if (
const auto *CXXSCE = dyn_cast<CXXStaticCastExpr>(RHSExpr);
19017 CXXSCE && CXXSCE->isXValue())
19018 RHSExpr = CXXSCE->getSubExpr();
19022 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
19023 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
19026 if (LHSDeclRef && RHSDeclRef) {
19033 auto D =
Diag(OpLoc, diag::warn_self_move)
19049 const Expr *LHSBase = LHSExpr;
19050 const Expr *RHSBase = RHSExpr;
19051 const MemberExpr *LHSME = dyn_cast<MemberExpr>(LHSExpr);
19052 const MemberExpr *RHSME = dyn_cast<MemberExpr>(RHSExpr);
19053 if (!LHSME || !RHSME)
19056 while (LHSME && RHSME) {
19063 LHSME = dyn_cast<MemberExpr>(LHSBase);
19064 RHSME = dyn_cast<MemberExpr>(RHSBase);
19067 LHSDeclRef = dyn_cast<DeclRefExpr>(LHSBase);
19068 RHSDeclRef = dyn_cast<DeclRefExpr>(RHSBase);
19069 if (LHSDeclRef && RHSDeclRef) {
19076 Diag(OpLoc, diag::warn_self_move)
19082 if (isa<CXXThisExpr>(LHSBase) && isa<CXXThisExpr>(RHSBase))
19083 Diag(OpLoc, diag::warn_self_move)
19106 bool AreUnionMembers =
false) {
19107 [[maybe_unused]]
const Type *Field1Parent =
19109 [[maybe_unused]]
const Type *Field2Parent =
19114 "Can't evaluate layout compatibility between a struct field and a "
19117 (AreUnionMembers && Field1Parent->
isUnionType())) &&
19118 "AreUnionMembers should be 'true' for union fields (only).");
19131 if (Bits1 != Bits2)
19135 if (Field1->
hasAttr<clang::NoUniqueAddressAttr>() ||
19136 Field2->
hasAttr<clang::NoUniqueAddressAttr>())
19139 if (!AreUnionMembers &&
19151 if (
const CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(RD1)) {
19156 if (D1CXX->getNumBases() != D2CXX->
getNumBases())
19161 Base1 = D1CXX->bases_begin(),
19162 BaseEnd1 = D1CXX->bases_end(),
19165 ++Base1, ++Base2) {
19169 }
else if (
const CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(RD2)) {
19171 if (D2CXX->getNumBases() > 0)
19180 for ( ; Field1 != Field1End && Field2 != Field2End; ++Field1, ++Field2) {
19184 if (Field1 != Field1End || Field2 != Field2End)
19195 for (
auto *Field2 : RD2->
fields())
19196 UnmatchedFields.insert(Field2);
19198 for (
auto *Field1 : RD1->
fields()) {
19200 I = UnmatchedFields.begin(),
19201 E = UnmatchedFields.end();
19203 for ( ; I != E; ++I) {
19205 bool Result = UnmatchedFields.erase(*I);
19215 return UnmatchedFields.empty();
19241 if (
C.hasSameType(T1, T2))
19250 if (TC1 == Type::Enum) {
19252 cast<EnumType>(T1)->getDecl(),
19253 cast<EnumType>(T2)->getDecl());
19254 }
else if (TC1 == Type::Record) {
19259 cast<RecordType>(T1)->getDecl(),
19260 cast<RecordType>(T2)->getDecl());
19274 QualType BaseT =
Base->getType()->getCanonicalTypeUnqualified();
19305 const ValueDecl **VD, uint64_t *MagicValue,
19306 bool isConstantEvaluated) {
19314 case Stmt::UnaryOperatorClass: {
19323 case Stmt::DeclRefExprClass: {
19324 const DeclRefExpr *DRE = cast<DeclRefExpr>(TypeExpr);
19329 case Stmt::IntegerLiteralClass: {
19331 llvm::APInt MagicValueAPInt = IL->
getValue();
19332 if (MagicValueAPInt.getActiveBits() <= 64) {
19333 *MagicValue = MagicValueAPInt.getZExtValue();
19339 case Stmt::BinaryConditionalOperatorClass:
19340 case Stmt::ConditionalOperatorClass: {
19342 cast<AbstractConditionalOperator>(TypeExpr);
19345 isConstantEvaluated)) {
19355 case Stmt::BinaryOperatorClass: {
19358 TypeExpr = BO->
getRHS();
19388 const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
19391 bool isConstantEvaluated) {
19392 FoundWrongKind =
false;
19397 uint64_t MagicValue;
19399 if (!
FindTypeTagExpr(TypeExpr, Ctx, &VD, &MagicValue, isConstantEvaluated))
19403 if (TypeTagForDatatypeAttr *I = VD->
getAttr<TypeTagForDatatypeAttr>()) {
19404 if (I->getArgumentKind() != ArgumentKind) {
19405 FoundWrongKind =
true;
19408 TypeInfo.Type = I->getMatchingCType();
19409 TypeInfo.LayoutCompatible = I->getLayoutCompatible();
19410 TypeInfo.MustBeNull = I->getMustBeNull();
19421 MagicValues->find(std::make_pair(ArgumentKind, MagicValue));
19422 if (I == MagicValues->end())
19431 bool LayoutCompatible,
19433 if (!TypeTagForDatatypeMagicValues)
19434 TypeTagForDatatypeMagicValues.reset(
19435 new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);
19438 (*TypeTagForDatatypeMagicValues)[Magic] =
19454 return (T1Kind == BuiltinType::SChar && T2Kind == BuiltinType::Char_S) ||
19455 (T1Kind == BuiltinType::UChar && T2Kind == BuiltinType::Char_U) ||
19456 (T1Kind == BuiltinType::Char_U && T2Kind == BuiltinType::UChar) ||
19457 (T1Kind == BuiltinType::Char_S && T2Kind == BuiltinType::SChar);
19460void Sema::CheckArgumentWithTypeTag(
const ArgumentWithTypeTagAttr *
Attr,
19464 bool IsPointerAttr =
Attr->getIsPointer();
19467 unsigned TypeTagIdxAST =
Attr->getTypeTagIdx().getASTIndex();
19468 if (TypeTagIdxAST >= ExprArgs.size()) {
19469 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19470 << 0 <<
Attr->getTypeTagIdx().getSourceIndex();
19473 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
19474 bool FoundWrongKind;
19477 TypeTagForDatatypeMagicValues.get(), FoundWrongKind,
19479 if (FoundWrongKind)
19481 diag::warn_type_tag_for_datatype_wrong_kind)
19487 unsigned ArgumentIdxAST =
Attr->getArgumentIdx().getASTIndex();
19488 if (ArgumentIdxAST >= ExprArgs.size()) {
19489 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
19490 << 1 <<
Attr->getArgumentIdx().getSourceIndex();
19493 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
19494 if (IsPointerAttr) {
19496 if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgumentExpr))
19497 if (ICE->getType()->isVoidPointerType() &&
19498 ICE->getCastKind() == CK_BitCast)
19499 ArgumentExpr = ICE->getSubExpr();
19512 diag::warn_type_safety_null_pointer_required)
19524 bool mismatch =
false;
19547 Diag(ArgumentExpr->
getExprLoc(), diag::warn_type_safety_type_mismatch)
19548 << ArgumentType << ArgumentKind
19549 <<
TypeInfo.LayoutCompatible << RequiredType
19556 MisalignedMembers.emplace_back(E, RD, MD, Alignment);
19560 for (MisalignedMember &m : MisalignedMembers) {
19566 Diag(m.E->getBeginLoc(), diag::warn_taking_address_of_packed_member)
19569 MisalignedMembers.clear();
19576 if (isa<UnaryOperator>(E) &&
19577 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
19578 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
19579 if (isa<MemberExpr>(Op)) {
19580 auto *MA = llvm::find(MisalignedMembers, MisalignedMember(Op));
19581 if (MA != MisalignedMembers.end() &&
19586 MisalignedMembers.erase(MA);
19595 const auto *ME = dyn_cast<MemberExpr>(E);
19607 bool AnyIsPacked =
false;
19609 QualType BaseType = ME->getBase()->getType();
19619 auto *FD = dyn_cast<FieldDecl>(MD);
19625 AnyIsPacked || (RD->
hasAttr<PackedAttr>() || MD->
hasAttr<PackedAttr>());
19626 ReverseMemberChain.push_back(FD);
19629 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParens());
19631 assert(TopME &&
"We did not compute a topmost MemberExpr!");
19638 const auto *DRE = dyn_cast<DeclRefExpr>(TopBase);
19642 if (!DRE && !isa<CXXThisExpr>(TopBase))
19649 if (ExpectedAlignment.
isOne())
19654 for (
const FieldDecl *FD : llvm::reverse(ReverseMemberChain))
19659 ReverseMemberChain.back()->getParent()->getTypeForDecl());
19663 if (DRE && !TopME->
isArrow()) {
19666 CompleteObjectAlignment =
19671 if (Offset % ExpectedAlignment != 0 ||
19674 CompleteObjectAlignment < ExpectedAlignment) {
19685 for (
FieldDecl *FDI : ReverseMemberChain) {
19686 if (FDI->hasAttr<PackedAttr>() ||
19687 FDI->getParent()->hasAttr<PackedAttr>()) {
19689 Alignment = std::min(
19695 assert(FD &&
"We did not find a packed FieldDecl!");
19696 Action(E, FD->
getParent(), FD, Alignment);
19700void Sema::CheckAddressOfPackedMember(
Expr *rhs) {
19701 using namespace std::placeholders;
19704 rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*
this), _1,
19708bool Sema::PrepareBuiltinElementwiseMathOneArgCall(
CallExpr *TheCall) {
19726bool Sema::BuiltinElementwiseMath(
CallExpr *TheCall) {
19740 TheCall->
setType(VecTy0->getElementType());
19764 diag::err_typecheck_call_different_arg_types)
19775bool Sema::BuiltinElementwiseTernaryMath(
CallExpr *TheCall,
19776 bool CheckForFloatArgs) {
19781 for (
int I = 0; I < 3; ++I) {
19785 Args[I] = Converted.
get();
19788 if (CheckForFloatArgs) {
19789 int ArgOrdinal = 1;
19790 for (
Expr *Arg : Args) {
19792 Arg->
getType(), ArgOrdinal++))
19796 int ArgOrdinal = 1;
19797 for (
Expr *Arg : Args) {
19804 for (
int I = 1; I < 3; ++I) {
19805 if (Args[0]->getType().getCanonicalType() !=
19806 Args[I]->getType().getCanonicalType()) {
19807 return Diag(Args[0]->getBeginLoc(),
19808 diag::err_typecheck_call_different_arg_types)
19809 << Args[0]->getType() << Args[I]->getType();
19812 TheCall->
setArg(I, Args[I]);
19815 TheCall->
setType(Args[0]->getType());
19819bool Sema::PrepareBuiltinReduceMathOneArgCall(
CallExpr *TheCall) {
19831bool Sema::BuiltinNonDeterministicValue(
CallExpr *TheCall) {
19840 << 1 << 0 << TyArg;
19854 Expr *Matrix = MatrixArg.
get();
19859 << 1 << 1 << Matrix->
getType();
19866 MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
19869 TheCall->
setType(ResultType);
19872 TheCall->
setArg(0, Matrix);
19877static std::optional<unsigned>
19880 std::optional<llvm::APSInt>
Value =
19887 uint64_t Dim =
Value->getZExtValue();
19906 unsigned PtrArgIdx = 0;
19912 bool ArgError =
false;
19919 PtrExpr = PtrConv.
get();
19920 TheCall->
setArg(0, PtrExpr);
19931 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
19938 << PtrArgIdx + 1 << 2
19945 auto ApplyArgumentConversions = [
this](
Expr *E) {
19954 ExprResult RowsConv = ApplyArgumentConversions(RowsExpr);
19956 RowsExpr = RowsConv.
get();
19957 TheCall->
setArg(1, RowsExpr);
19959 RowsExpr =
nullptr;
19961 ExprResult ColumnsConv = ApplyArgumentConversions(ColumnsExpr);
19963 ColumnsExpr = ColumnsConv.
get();
19964 TheCall->
setArg(2, ColumnsExpr);
19966 ColumnsExpr =
nullptr;
19977 std::optional<unsigned> MaybeRows;
19981 std::optional<unsigned> MaybeColumns;
19986 ExprResult StrideConv = ApplyArgumentConversions(StrideExpr);
19989 StrideExpr = StrideConv.
get();
19990 TheCall->
setArg(3, StrideExpr);
19993 if (std::optional<llvm::APSInt>
Value =
19996 if (Stride < *MaybeRows) {
19998 diag::err_builtin_matrix_stride_too_small);
20004 if (ArgError || !MaybeRows || !MaybeColumns)
20017 unsigned PtrArgIdx = 1;
20022 bool ArgError =
false;
20028 MatrixExpr = MatrixConv.
get();
20029 TheCall->
setArg(0, MatrixExpr);
20039 << 1 << 1 << MatrixExpr->
getType();
20047 PtrExpr = PtrConv.
get();
20048 TheCall->
setArg(1, PtrExpr);
20059 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20064 Diag(PtrExpr->
getBeginLoc(), diag::err_builtin_matrix_store_to_const);
20071 diag::err_builtin_matrix_pointer_arg_mismatch)
20072 << ElementTy << MatrixTy->getElementType();
20087 StrideExpr = StrideConv.
get();
20088 TheCall->
setArg(2, StrideExpr);
20093 if (std::optional<llvm::APSInt>
Value =
20096 if (Stride < MatrixTy->getNumRows()) {
20098 diag::err_builtin_matrix_stride_too_small);
20115 const auto *ATy = dyn_cast<ArrayType>(ArgExpr->
getType());
20116 if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
20118 diag::err_wasm_builtin_arg_must_be_table_type)
20121 ElTy = ATy->getElementType();
20127 unsigned ArgIndex) {
20131 diag::err_wasm_builtin_arg_must_be_integer_type)
20139bool Sema::BuiltinWasmTableGet(
CallExpr *TheCall) {
20162bool Sema::BuiltinWasmTableSet(
CallExpr *TheCall) {
20180bool Sema::BuiltinWasmTableSize(
CallExpr *TheCall) {
20194bool Sema::BuiltinWasmTableGrow(
CallExpr *TheCall) {
20205 diag::err_wasm_builtin_arg_must_match_table_element_type)
20218bool Sema::BuiltinWasmTableFill(
CallExpr *TheCall) {
20232 diag::err_wasm_builtin_arg_must_match_table_element_type)
20245bool Sema::BuiltinWasmTableCopy(
CallExpr *TheCall) {
20260 diag::err_wasm_builtin_arg_must_match_table_element_type)
20264 for (
int I = 2; I <= 4; I++) {
20284 if (!Caller || !Caller->
hasAttr<EnforceTCBAttr>())
20289 llvm::StringSet<> CalleeTCBs;
20290 for (
const auto *A : Callee->specific_attrs<EnforceTCBAttr>())
20291 CalleeTCBs.insert(A->getTCBName());
20292 for (
const auto *A : Callee->specific_attrs<EnforceTCBLeafAttr>())
20293 CalleeTCBs.insert(A->getTCBName());
20297 for (
const auto *A : Caller->
specific_attrs<EnforceTCBAttr>()) {
20298 StringRef CallerTCB = A->getTCBName();
20299 if (CalleeTCBs.count(CallerTCB) == 0) {
20300 this->
Diag(CallExprLoc, diag::warn_tcb_enforcement_violation)
20301 << Callee << CallerTCB;
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
Provides definitions for the various language-specific address spaces.
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
static bool getTypeString(SmallStringEnc &Enc, const Decl *D, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
The XCore ABI includes a type information section that communicates symbol type information to the li...
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Target Target
Defines the clang::OpenCLOptions class.
Defines an enumeration for C++ overloaded operators.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool BuiltinReserveRWPipe(Sema &S, CallExpr *Call)
static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx, const ValueDecl **VD, uint64_t *MagicValue, bool isConstantEvaluated)
Given a type tag expression find the type tag itself.
static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth, bool InConstantContext, bool Approximate)
Pseudo-evaluate the given integer expression, estimating the range of values it might take.
static void CheckConditionalOperator(Sema &S, AbstractConditionalOperator *E, SourceLocation CC, QualType T)
static QualType getSizeOfArgType(const Expr *E)
If E is a sizeof expression, returns its argument type.
static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc)
static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, IdentifierInfo *FnName, SourceLocation FnLoc, SourceLocation RParenLoc)
Takes the expression passed to the size_t parameter of functions such as memcmp, strncat,...
static const CXXRecordDecl * getContainedDynamicClass(QualType T, bool &IsContained)
Determine whether the given type is or contains a dynamic class type (e.g., whether it has a vtable).
static ExprResult PointerAuthSignGenericData(Sema &S, CallExpr *Call)
static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext)
Diagnose an implicit cast from a floating point value to an integer value.
static void CheckFormatString(Sema &S, const FormatStringLiteral *FExpr, const Expr *OrigFormatExpr, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, bool inFunctionCall, Sema::VariadicCallType CallType, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, bool IgnoreStringsWithoutSpecifiers)
static ExprResult PointerAuthStrip(Sema &S, CallExpr *Call)
static void CheckImplicitConversion(Sema &S, Expr *E, QualType T, SourceLocation CC, bool *ICContext=nullptr, bool IsListInit=false)
static bool IsSameFloatAfterCast(const llvm::APFloat &value, const llvm::fltSemantics &Src, const llvm::fltSemantics &Tgt)
Checks whether the given value, which currently has the given source semantics, has the same value wh...
static StringLiteralCheckType checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, Sema::VariadicCallType CallType, bool InFunctionCall, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset, bool IgnoreStringsWithoutSpecifiers=false)
static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth)
static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool)
static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T, SourceLocation CContext, unsigned diag, bool pruneControlFlow=false)
Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg)
OpenCL C v2.0, s6.13.17.2 - Checks that the block parameters are all local void*, which is a requirem...
static bool isX86_32Builtin(unsigned BuiltinID)
static void AnalyzeComparison(Sema &S, BinaryOperator *E)
Implements -Wsign-compare.
static void sumOffsets(llvm::APSInt &Offset, llvm::APSInt Addend, BinaryOperatorKind BinOpKind, bool AddendIsRight)
static std::pair< QualType, StringRef > shouldNotPrintDirectly(const ASTContext &Context, QualType IntendedTy, const Expr *E)
static QualType GetExprType(const Expr *E)
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromLValue(const Expr *E, ASTContext &Ctx)
This helper function takes an lvalue expression and returns the alignment of a VarDecl and a constant...
static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall, SourceLocation CC)
static bool OpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17.6 - Check the argument to the get_kernel_work_group_size and get_kernel_prefe...
static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant)
static AbsoluteValueKind getAbsoluteValueKind(QualType T)
bool CheckNoDoubleVectors(Sema *S, CallExpr *TheCall)
static bool isKnownToHaveUnsignedValue(Expr *E)
static ExprResult BuiltinDumpStruct(Sema &S, CallExpr *TheCall)
static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout structs are layout-compatible.
bool CheckUnsignedIntRepresentation(Sema *S, CallExpr *TheCall)
bool CheckVectorElementCallArgs(Sema *S, CallExpr *TheCall)
static unsigned RFT(unsigned t, bool shift=false, bool ForceQuad=false)
static bool hasArmZAState(const FunctionDecl *FD)
static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntType)
Diagnose integer type and any valid implicit conversion to it.
static bool isValidOrderingForOp(int64_t Ordering, AtomicExpr::AtomicOp Op)
static bool BuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall, Scope::ScopeFlags NeededScopeFlags, unsigned DiagID)
static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E)
Analyze the given compound assignment for the possible losing of floating-point precision.
static bool doesExprLikelyComputeSize(const Expr *SizeofExpr)
Detect if SizeofExpr is likely to calculate the sizeof an object.
static bool isObjCSignedCharBool(Sema &S, QualType Ty)
static bool OpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID, CallExpr *Call)
static bool BuiltinPreserveAI(Sema &S, CallExpr *TheCall)
Check the number of arguments and set the result type to the argument type.
bool CheckFloatOrHalfRepresentations(Sema *S, CallExpr *TheCall)
static bool isValidBPFPreserveTypeInfoArg(Expr *Arg)
static bool CheckForReference(Sema &SemaRef, const Expr *E, const PartialDiagnostic &PD)
static bool checkMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static const UnaryExprOrTypeTraitExpr * getAsSizeOfExpr(const Expr *E)
static bool BuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID)
Check that the value argument for __builtin_is_aligned(value, alignment) and __builtin_aligned_{up,...
static bool BuiltinRWPipe(Sema &S, CallExpr *Call)
static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC)
Check conversion of given expression to boolean.
static bool checkPointerAuthValue(Sema &S, Expr *&Arg, PointerAuthOpKind OpKind)
static bool checkArgCountAtLeast(Sema &S, CallExpr *Call, unsigned MinArgCount)
Checks that a call expression's argument count is at least the desired number.
static void CheckMemaccessSize(Sema &S, unsigned BId, const CallExpr *Call)
Diagnose cases like 'memset(buf, sizeof(buf), 0)', which should have the last two arguments transpose...
static bool checkPointerAuthEnabled(Sema &S, Expr *E)
static std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range)
static const Expr * getStrlenExprArg(const Expr *E)
static void checkObjCDictionaryLiteral(Sema &S, QualType TargetType, ObjCDictionaryLiteral *DictionaryLiteral)
Check an Objective-C dictionary literal being converted to the given target type.
static void checkArmStreamingBuiltin(Sema &S, CallExpr *TheCall, const FunctionDecl *FD, ArmStreamingType BuiltinType)
static bool isConstantSizeArrayWithMoreThanOneElement(QualType Ty, ASTContext &Context)
static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall, const TargetInfo *AuxTI, unsigned BuiltinID)
BuiltinCpu{Supports|Is} - Handle __builtin_cpu_{supports|is}(char *).
static bool isBlockPointer(Expr *Arg)
static bool 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 void adornObjCBoolConversionDiagWithTernaryFixit(Sema &S, Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder)
static bool OpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different overload formats specified ...
static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall, Expr *BlockArg, unsigned NumNonVarArgs)
OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all 'local void*' parameter of passed blo...
static bool BuiltinCommitRWPipe(Sema &S, CallExpr *Call)
static bool IsSameCharType(QualType T1, QualType T2)
bool CheckAllArgsHaveFloatRepresentation(Sema *S, CallExpr *TheCall)
static OpenCLAccessAttr * getOpenCLArgAccess(const Decl *D)
Returns OpenCL access qual.
static bool CheckNonNullExpr(Sema &S, const Expr *Expr)
Checks if a the given expression evaluates to null.
static bool isArgumentExpandedFromMacro(SourceManager &SM, SourceLocation CallLoc, SourceLocation ArgLoc)
Check if the ArgLoc originated from a macro passed to the call at CallLoc.
static const IntegerLiteral * getIntegerLiteral(Expr *E)
static ArmStreamingType getArmStreamingFnType(const FunctionDecl *FD)
static const Expr * maybeConstEvalStringLiteral(ASTContext &Context, const Expr *E)
static bool IsStdFunction(const FunctionDecl *FDecl, const char(&Str)[StrLen])
static void AnalyzeAssignment(Sema &S, BinaryOperator *E)
Analyze the given simple or compound assignment for warning-worthy operations.
static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_function_start is a function.
static bool BuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall)
static bool ShouldDiagnoseEmptyStmtBody(const SourceManager &SourceMgr, SourceLocation StmtLoc, const NullStmt *Body)
static std::pair< CharUnits, CharUnits > getDerivedToBaseAlignmentAndOffset(const CastExpr *CE, QualType DerivedType, CharUnits BaseAlignment, CharUnits Offset, ASTContext &Ctx)
Compute the alignment and offset of the base class object given the derived-to-base cast expression a...
static void diagnoseArrayStarInParamType(Sema &S, QualType PType, SourceLocation Loc)
static ArmSMEState getSMEState(unsigned BuiltinID)
static unsigned changeAbsFunction(unsigned AbsKind, AbsoluteValueKind ValueKind)
static void CheckConditionalOperand(Sema &S, Expr *E, QualType T, SourceLocation CC, bool &ICContext)
static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2)
Check if two types are layout-compatible in C++11 sense.
static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool isValidBPFPreserveFieldInfoArg(Expr *Arg)
static bool checkUnsafeAssignLiteral(Sema &S, SourceLocation Loc, Expr *RHS, bool isProperty)
static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall)
static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx)
Returns true if pipe element type is different from the pointer.
static ExprResult PointerAuthBlendDiscriminator(Sema &S, CallExpr *Call)
static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc)
Analyzes an attempt to assign the given value to a bitfield.
static int classifyConstantValue(Expr *Constant)
static bool IsInAnyMacroBody(const SourceManager &SM, SourceLocation Loc)
static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range, unsigned AbsKind, QualType ArgType)
static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call)
Returns true if pipe element type is different from the pointer.
static bool checkPointerAuthKey(Sema &S, Expr *&Arg)
static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty)
static bool BuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID)
static unsigned getAbsoluteValueFunctionKind(const FunctionDecl *FDecl)
static llvm::SmallPtrSet< MemberKind *, 1 > CXXRecordMembersNamed(StringRef Name, Sema &S, QualType Ty)
static QualType getNeonEltType(NeonTypeFlags Flags, ASTContext &Context, bool IsPolyUnsigned, bool IsInt64Long)
getNeonEltType - Return the QualType corresponding to the elements of the vector type specified by th...
static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool CheckBuiltinTargetInSupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ArchType > SupportedArchs)
static void CheckNonNullArguments(Sema &S, const NamedDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< const Expr * > Args, SourceLocation CallSiteLoc)
static unsigned getLargerAbsoluteValueFunction(unsigned AbsFunction)
static bool hasArmZT0State(const FunctionDecl *FD)
static analyze_format_string::ArgType::MatchKind handleFormatSignedness(analyze_format_string::ArgType::MatchKind Match, DiagnosticsEngine &Diags, SourceLocation Loc)
static bool referToTheSameDecl(const Expr *E1, const Expr *E2)
Check if two expressions refer to the same declaration.
static bool OpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall)
static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall)
Checks that __builtin_{clzg,ctzg} was called with a first argument, which is an unsigned integer,...
static bool requiresParensToAddCast(const Expr *E)
static ExprResult PointerAuthAuthAndResign(Sema &S, CallExpr *Call)
static const Expr * ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx)
static void checkObjCCollectionLiteralElement(Sema &S, QualType TargetElementType, Expr *Element, unsigned ElementKind)
Check a single element within a collection literal against the target element type.
static bool BuiltinPipePackets(Sema &S, CallExpr *Call)
static bool CheckWasmBuiltinArgIsInteger(Sema &S, CallExpr *E, unsigned ArgIndex)
Checks the argument at the given index is an integer.
static std::optional< unsigned > getAndVerifyMatrixDimension(Expr *Expr, StringRef Name, Sema &S)
static bool checkArgCountRange(Sema &S, CallExpr *Call, unsigned MinArgCount, unsigned MaxArgCount)
Checks that a call expression's argument count is in the desired range.
static bool convertArgumentToType(Sema &S, Expr *&Value, QualType Ty)
static bool ProcessFormatStringLiteral(const Expr *FormatExpr, StringRef &FormatStrRef, size_t &StrLen, ASTContext &Context)
static bool checkArgCount(Sema &S, CallExpr *Call, unsigned DesiredArgCount)
Checks that a call expression's argument count is the desired number.
static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall)
Checks that __builtin_popcountg was called with a single argument, which is an unsigned integer.
void SetElementTypeAsReturnType(Sema *S, CallExpr *TheCall, QualType ReturnType)
static const Expr * getSizeOfExprArg(const Expr *E)
If E is a sizeof expression, returns its argument expression, otherwise returns NULL.
static void DiagnoseIntInBoolContext(Sema &S, Expr *E)
static bool CheckBuiltinTargetNotInUnsupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ObjectFormatType > UnsupportedObjectFormatTypes)
static bool BuiltinAddressof(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_addressof is a glvalue, and set the result type to the correspon...
static CharUnits getPresumedAlignmentOfPointer(const Expr *E, Sema &S)
static ExprResult PointerAuthSignOrAuth(Sema &S, CallExpr *Call, PointerAuthOpKind OpKind)
static bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn)
Check that the user is calling the appropriate va_start builtin for the target and calling convention...
static bool IsEnumConstOrFromMacro(Sema &S, Expr *E)
static bool CheckInvalidVLENandLMUL(const TargetInfo &TI, CallExpr *TheCall, Sema &S, QualType Type, int EGW)
static bool GetMatchingCType(const IdentifierInfo *ArgumentKind, const Expr *TypeExpr, const ASTContext &Ctx, const llvm::DenseMap< Sema::TypeTagMagicValue, Sema::TypeTagData > *MagicValues, bool &FoundWrongKind, Sema::TypeTagData &TypeInfo, bool isConstantEvaluated)
Retrieve the C type corresponding to type tag TypeExpr.
static void checkObjCArrayLiteral(Sema &S, QualType TargetType, ObjCArrayLiteral *ArrayLiteral)
Check an Objective-C array literal being converted to the given target type.
static bool isLayoutCompatibleUnion(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout unions are layout-compatible.
static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str, unsigned &Mask)
DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str, advancing the pointer ov...
static QualType getAbsoluteValueArgumentType(ASTContext &Context, unsigned AbsType)
static void DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, const NamedDecl *FDecl, Expr **Args, unsigned NumArgs)
Diagnose use of s directive in an NSString which is being passed as formatting string to formatting m...
static bool isNonNullType(QualType type)
Determine whether the given type has a non-null nullability annotation.
static constexpr unsigned short combineFAPK(Sema::FormatArgumentPassingKind A, Sema::FormatArgumentPassingKind B)
static bool BuiltinAnnotation(Sema &S, CallExpr *TheCall)
Check that the first argument to __builtin_annotation is an integer and the second argument is a non-...
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromPtr(const Expr *E, ASTContext &Ctx)
This helper function takes a pointer expression and returns the alignment of a VarDecl and a constant...
static bool IsShiftedByte(llvm::APSInt Value)
static unsigned getBestAbsFunction(ASTContext &Context, QualType ArgType, unsigned AbsFunctionKind)
static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex)
checkBuiltinArgument - Given a call to a builtin function, perform normal type-checking on the given ...
static void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E)
Analyze the operands of the given comparison.
static bool isPPC_64Builtin(unsigned BuiltinID)
static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call)
static bool isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE)
Return true if ICE is an implicit argument promotion of an arithmetic type.
static bool isValidBPFPreserveEnumValueArg(Expr *Arg)
static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC, bool IsListInit=false)
AnalyzeImplicitConversions - Find and report any interesting implicit conversions in the given expres...
static bool HasEnumType(Expr *E)
static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall, unsigned Start, unsigned End)
static std::optional< std::pair< CharUnits, CharUnits > > getAlignmentAndOffsetFromBinAddOrSub(const Expr *PtrE, const Expr *IntE, bool IsSub, ASTContext &Ctx)
Compute the alignment and offset of a binary additive operator.
static bool checkFPMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static bool checkArgCountAtMost(Sema &S, CallExpr *Call, unsigned MaxArgCount)
Checks that a call expression's argument count is at most the desired number.
static bool BuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall)
static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam=nullptr)
bool CheckArgsTypesAreCorrect(Sema *S, CallExpr *TheCall, QualType ExpectedType, llvm::function_ref< bool(clang::QualType PassedType)> Check)
This file declares semantic analysis for Objective-C.
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Provides definitions for the atomic synchronization scopes.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
__DEVICE__ int min(int __a, int __b)
__device__ __2f16 float __ockl_bool s
llvm::APInt getValue() const
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
APSInt & getComplexIntImag()
bool isComplexInt() const
bool isComplexFloat() const
APValue & getVectorElt(unsigned I)
unsigned getVectorLength() const
APSInt & getComplexIntReal()
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
bool isAddrLabelDiff() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getIntWidth(QualType T) const
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
QualType getRecordType(const RecordDecl *Decl) const
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
Builtin::Context & BuiltinInfo
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const
Compare the rank of two floating point types as above, but compare equal if both types have the same ...
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
llvm::APFixedPoint getFixedPointMin(QualType Ty) const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getWebAssemblyExternrefType() const
Return a WebAssembly externref type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CanQualType OCLClkEventTy
const clang::PrintingPolicy & getPrintingPolicy() const
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType OCLReserveIDTy
CanQualType UnsignedShortTy
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
CanQualType getNSIntegerType() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
QualType DecodeTypeStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequireICE, bool AllowTypeModifiers) const
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
CanQualType getNSUIntegerType() const
uint64_t getCharWidth() const
Return the size of the character type, in bits.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getNonVirtualAlignment() const
getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
SourceLocation getQuestionLoc() const
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
Expr * getBase()
Get base of the array section.
Expr * getLowerBound()
Get lower bound of array section.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getRBracketLoc() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
std::unique_ptr< AtomicScopeModel > getScopeModel() const
Get atomic scope model.
SourceLocation getBeginLoc() const LLVM_READONLY
Attr - This represents one attribute.
const char * getSpelling() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
ConceptDecl * getTypeConstraintConcept() 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.
const ParmVarDecl * getParamDecl(unsigned i) const
QualType getPointeeType() const
This class is used for builtin types like 'int'.
bool isFloatingPoint() const
bool isSignedInteger() const
bool isUnsignedInteger() const
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
unsigned getAuxBuiltinID(unsigned ID) const
Return real builtin ID (i.e.
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Represents a base class of a C++ class.
Represents a call to a C++ constructor.
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
A call to an overloaded operator written using operator syntax.
SourceLocation getExprLoc() const LLVM_READONLY
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents a list-initialization with parenthesis.
ArrayRef< Expr * > getInitExprs()
Represents a C++ struct/union/class.
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
base_class_iterator bases_begin()
bool isDynamicClass() const
Represents a C++ nested-name-specifier or a global scope specifier.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
bool isCallToStdMove() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
Expr ** getArgs()
Retrieve the call arguments.
SourceLocation getRParenLoc() const
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
static CharSourceRange getTokenRange(SourceRange R)
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
bool isOne() const
isOne - Test whether the quantity equals one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
void setExprNeedsCleanups(bool SideEffects)
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
Declaration of a C++20 concept.
ConditionalOperator - The ?: ternary operator.
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
llvm::APInt getSize() const
Return the constant array size as an APInt.
Represents a concrete matrix type with constant number of rows and columns.
static constexpr unsigned getMaxElementsPerDimension()
Returns the maximum number of elements per dimension.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Expr * getOperand() const
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
bool isInStdNamespace() const
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
RAII class that determines when any errors have occurred between the time the instance was created an...
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Concrete class used by the front-end to report problems and issues.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
An instance of this object exists for each enum constant that is defined.
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
bool isComplete() const
Returns true if this can be considered a complete type.
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
@ SE_AllowSideEffects
Allow any unmodeled side effect.
@ SE_NoSideEffects
Strictly evaluate the expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const
If the current Expr is a pointer, this will try to statically determine the strlen of the string poin...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFixedPoint - Return true if this is a constant which we can fold and convert to a fixed poi...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImplicitAsWritten() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_NotNull
Expression is not a Null pointer constant.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
QualType getEnumCoercedType(const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant ...
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool isFlexibleArrayMemberLike(ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
void EvaluateForOverflow(const ASTContext &Ctx) const
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getBitWidthValue(const ASTContext &Ctx) const
Computes the bit width of this field, if this is a bit field.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
llvm::APFloat getValue() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Represents a function declaration or definition.
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool hasCXXExplicitFunctionObjectParameter() const
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
unsigned getAArch64SMEAttributes() const
Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
ArrayRef< QualType > getParamTypes() const
FunctionType - C99 6.7.5.3 - Function Declarators.
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
QualType getReturnType() const
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Describes an C or C++ initializer list.
ArrayRef< Expr * > inits()
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
StrictFlexArraysLevelKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
static StringRef getImmediateMacroName(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
static StringRef getImmediateMacroNameForDiagnostics(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
static bool isValidElementType(QualType T)
Valid elements types are the following:
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
Flags to identify the types for overloaded Neon builtins.
EltType getEltType() const
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NullStmt - This is the null statement ";": C99 6.8.3p3.
bool hasLeadingEmptyMacro() const
SourceLocation getSemiLoc() const
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Represents an ObjC class declaration.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
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
bool isImplicitProperty() 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.
bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parethesized expression, e.g.
Represents a parameter to a function.
QualType getElementType() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
PrimitiveDefaultInitializeKind
QualType withoutLocalFastQualifiers() const
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool isConstant(const ASTContext &Ctx) const
QualType withVolatile() const
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void removeLocalVolatile()
bool isConstQualified() const
Determine whether this type is const-qualified.
const Type * getTypePtrOrNull() const
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
bool hasUnaligned() const
Represents a struct/union/class.
field_iterator field_end() const
field_range fields() const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Scope - A scope is a transient data structure that is used while parsing the program.
ScopeFlags
ScopeFlags - These are bitfields that are or'd together when creating a scope, which defines the sort...
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
@ SEHExceptScope
This scope corresponds to an SEH except.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Sema - This implements semantic analysis and AST building for C.
const FieldDecl * getSelfAssignmentClassMemberCandidate(const ValueDecl *SelfAssigned)
Returns a field in a CXXRecordDecl that has the same name as the decl SelfAssigned when inside a CXXM...
bool IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base, const TypeSourceInfo *Derived)
bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, const Expr *ThisArg, ArrayRef< const Expr * > Args, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any non-ArgDependent DiagnoseIf...
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupAnyName
Look up any declaration with any name.
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
bool isValidPointerAttrType(QualType T, bool RefOkay=false)
Determine if type T is a valid subject for a nonnull and similar attributes.
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
bool FormatStringHasSArg(const StringLiteral *FExpr)
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, bool IsVariadic, FormatStringInfo *FSI)
Given a FunctionDecl's FormatAttr, attempts to populate the FomatStringInfo parameter with the Format...
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...
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
ExprResult tryConvertExprToType(Expr *E, QualType Ty)
Try to convert an expression E to type Ty.
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
DiagnosticsEngine & getDiagnostics() const
static FormatStringType GetFormatStringType(const FormatAttr *Format)
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
bool BuiltinVectorToScalarMath(CallExpr *TheCall)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
bool CheckHLSLBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool IsLayoutCompatible(QualType T1, QualType T2) const
const LangOptions & getLangOpts() const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange)
CheckCastAlign - Implements -Wcast-align, which warns when a pointer cast increases the alignment req...
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
const LangOptions & LangOpts
static const uint64_t MaximumAlignment
ExprResult ConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
ConvertVectorExpr - Handle __builtin_convertvector.
bool checkConstantPointerAuthKey(Expr *keyExpr, unsigned &key)
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx)
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
void popCodeSynthesisContext()
void DiagnoseMisalignedMembers()
Diagnoses the current set of gathered accesses.
sema::FunctionScopeInfo * getCurFunction() const
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
std::pair< const IdentifierInfo *, uint64_t > TypeTagMagicValue
A pair of ArgumentKind identifier and magic value.
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)
Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...
void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)
Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...
ExprResult DefaultLvalueConversion(Expr *E)
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
bool BuiltinVectorMath(CallExpr *TheCall, QualType &Res)
void CheckTCBEnforcement(const SourceLocation CallExprLoc, const NamedDecl *Callee)
Enforce the bounds of a TCB CheckTCBEnforcement - Enforces that every function in a named TCB only di...
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)
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
bool isConstantEvaluatedContext() const
ExprResult BuiltinShuffleVector(CallExpr *TheCall)
BuiltinShuffleVector - Handle __builtin_shufflevector.
QualType GetSignedVectorType(QualType V)
void CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc)
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
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
ExprResult BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder=AtomicArgumentOrder::API)
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto)
CheckFunctionCall - Check a direct function call for various correctness and safety properties not st...
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef< const Expr * > Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType)
Handles the checks for format strings, non-POD arguments to vararg functions, NULL arguments passed t...
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
unsigned getPresumedLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isWrittenInSameFile(SourceLocation Loc1, SourceLocation Loc2) const
Returns true if the spelling locations for both SourceLocations are part of the same file buffer.
unsigned getPresumedColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getLength() const
StringLiteralKind getKind() const
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
unsigned getByteLength() const
StringRef getString() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getCharByteWidth() const
Exposes information about the current target.
virtual bool validatePointerAuthKey(const llvm::APSInt &value) const
Determine whether the given pointer-authentication key is valid.
virtual bool supportsCpuSupports() const
virtual bool validateCpuIs(StringRef Name) const
virtual bool supportsCpuInit() const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
IntType getInt64Type() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
IntType getSizeType() const
IntType getIntPtrType() const
uint32_t getARMCDECoprocMask() const
For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.
virtual bool validateCpuSupports(StringRef Name) const
virtual bool supportsCpuIs() const
const llvm::fltSemantics & getLongDoubleFormat() const
virtual bool checkArithmeticFenceSupported() const
Controls if __arithmetic_fence is supported in the targeted backend.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool hasSjLjLowering() const
Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
@ Type
The template argument is a type.
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isFloat16Type() const
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isFunctionPointerType() const
bool isPointerType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isFloat32Type() const
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
const BuiltinType * getAsPlaceholderType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
QualType getCanonicalTypeInternal() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isAtomicType() const
bool isFunctionProtoType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isBFloat16Type() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isStructureOrClassType() const
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isSizelessVectorType() const
Returns true for all scalable vector types.
QualType getSizelessVectorEltType(const ASTContext &Ctx) const
Returns the representative type for the element of a sizeless vector builtin 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.
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.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
@ After
Like System, but searched after the system directories.
@ FixIt
Parse and apply any fixits to the source.
bool GT(InterpState &S, CodePtr OpPC)
bool NE(InterpState &S, CodePtr OpPC)
bool LE(InterpState &S, CodePtr OpPC)
bool InRange(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
bool EQ(InterpState &S, CodePtr OpPC)
bool GE(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ NonNull
Values of this type can never be null.
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Result
The result type of a method or function.
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
for(const auto &A :T->param_types())
const FunctionProtoType * T
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ Success
Template argument deduction was successful.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecVector
is AltiVec vector
@ Generic
not a target-specific vector type
U cast(CodeGen::Address addr)
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Other
Other implicit parameter.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Extra information about a function prototype.
unsigned AArch64SMEAttributes
Describes how types, statements, expressions, and declarations should be printed.
unsigned AnonymousTagLocations
When printing an anonymous tag name, also print the location of that entity (e.g.,...
unsigned Indentation
The number of spaces to use to indent each line.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
unsigned NumCallArgs
The number of expressions in CallArgs.
const Expr *const * CallArgs
The list of argument expressions in a synthesized call.
@ BuildingBuiltinDumpStructCall
We are building an implied call from __builtin_dump_struct.