Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaChecking_8cpp_source.html below:

clang: lib/Sema/SemaChecking.cpp Source File

;

ByteNo)

{

ArgCount =

->getNumArgs();

(ArgCount >= MinArgCount)

(

->getEndLoc(), diag::err_typecheck_call_too_few_args)

<< 0

<< MinArgCount << ArgCount

<<

0 <<

->getSourceRange();

ArgCount =

->getNumArgs();

(ArgCount <= MaxArgCount)

(

->getEndLoc(), diag::err_typecheck_call_too_many_args_at_most)

<< 0

<< MaxArgCount << ArgCount

<<

0 <<

->getSourceRange();

MaxArgCount) {

ArgCount =

->getNumArgs();

(ArgCount == DesiredArgCount)

assert(ArgCount > DesiredArgCount &&

);

->getArg(ArgCount - 1)->getEndLoc());

<< 0

<< DesiredArgCount << ArgCount

<<

0 <<

->getArg(1)->getSourceRange();

HasError =

;

(

I = 0; I <

->getNumArgs(); ++I) {

DiagMsgKind = -1;

(!ArgString.has_value())

(ArgString->find(

) != std::string::npos)

(DiagMsgKind >= 0) {

(

->isTypeDependent())

S.

(ValArg->

(), diag::err_builtin_annotation_first_arg)

(!Literal || !Literal->isOrdinary()) {

S.

(StrArg->

(), diag::err_builtin_annotation_second_arg)

S.

(TheCall->

(), diag::err_typecheck_call_too_few_args_at_least)

*Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());

(!Literal || !Literal->isWide()) {

S.

(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)

<< Arg->getSourceRange();

(ResultType.

())

TheCall->

(ResultType);

*FD = dyn_cast_or_null<FunctionDecl>(

S.

(TheCall->

(), diag::err_function_start_invalid_type)

IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;

IsValidIntegerType = [](

Ty) {

Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();

((!SrcTy->

() && !IsValidIntegerType(SrcTy)) ||

S.

(Source->

(), diag::err_typecheck_expect_scalar_operand)

(!IsValidIntegerType(AlignOp->

())) {

llvm::APSInt AlignValue = AlignResult.

.

();

llvm::APSInt MaxValue(

llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));

(AlignValue < 1) {

S.

(AlignOp->

(), diag::err_alignment_too_small) << 1;

(llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {

(!AlignValue.isPowerOf2()) {

S.

(AlignOp->

(), diag::err_alignment_not_power_of_two);

(AlignValue == 1) {

S.

(AlignOp->

(), diag::warn_alignment_builtin_useless)

<< IsBooleanAlignBuiltin;

std::pair<unsigned, const char *> Builtins[] = {

{ Builtin::BI__builtin_add_overflow,

},

{ Builtin::BI__builtin_sub_overflow,

},

{ Builtin::BI__builtin_mul_overflow,

},

CkdOperation = llvm::any_of(Builtins, [&](

std::pair<

,

*> &

) {

BuiltinID ==

.first && TheCall->

().isMacroID() &&

ValidCkdIntType = [](

QT) {

(

*BT = QT.getCanonicalType()->getAs<

>())

(BT->getKind() >= BuiltinType::Short &&

BT->getKind() <= BuiltinType::Int128) || (

BT->getKind() >= BuiltinType::UShort &&

BT->getKind() <= BuiltinType::UInt128) ||

BT->getKind() == BuiltinType::UChar ||

BT->getKind() == BuiltinType::SChar;

(

I = 0; I < 2; ++I) {

IsValid = CkdOperation ? ValidCkdIntType(Ty) : Ty->

();

!PtrTy->getPointeeType()->isIntegerType() ||

(!ValidCkdIntType(PtrTy->getPointeeType()) && CkdOperation) ||

PtrTy->getPointeeType().isConstQualified()) {

diag::err_overflow_builtin_must_be_ptr_int)

(BuiltinID == Builtin::BI__builtin_mul_overflow) {

(

I = 0; I < 3; ++I) {

Arg = TheCall->

(I);

(Ty->isBitIntType() && Ty->isSignedIntegerType() &&

S.

(Arg->getBeginLoc(),

diag::err_overflow_builtin_bit_int_max_size)

BuiltinDumpStructGenerator {

: S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),

Policy(S.Context.getPrintingPolicy()) {

*makeOpaqueValueExpr(

*Inner) {

Inner->getObjectKind(), Inner);

Actions.push_back(OVE);

*getStringLiteral(llvm::StringRef Str) {

callPrintFunction(llvm::StringRef Format,

Args.reserve((TheCall->

() - 2) +

1 + Exprs.size());

Args.push_back(getStringLiteral(Format));

Args.insert(Args.end(), Exprs.begin(), Exprs.end());

Ctx.PointOfInstantiation =

;

Ctx.CallArgs = Args.data();

Ctx.NumCallArgs = Args.size();

Actions.push_back(RealCall.

());

*getIndentString(

Depth) {

getStringLiteral(Indent);

getStringLiteral(

.getAsString(Policy));

llvm::raw_svector_ostream OS(Str);

(BT->getKind()) {

BuiltinType::Bool:

BuiltinType::Char_U:

BuiltinType::UChar:

BuiltinType::Char_S:

BuiltinType::SChar:

analyze_printf::PrintfConversionSpecifier::sArg) {

dumpUnnamedRecord(

*RD,

*

,

Depth) {

*IndentLit = getIndentString(Depth);

(IndentLit ? callPrintFunction(

, {IndentLit, TypeLit})

: callPrintFunction(

, {TypeLit}))

dumpRecordValue(RD,

, IndentLit, Depth);

*RecordArg = makeOpaqueValueExpr(

);

(callPrintFunction(

))

(

*CXXRD = dyn_cast<CXXRecordDecl>(RD)) {

(

&

: CXXRD->bases()) {

dumpUnnamedRecord(

.getType()->getAsRecordDecl(), BasePtr.

(),

*FieldIndentArg = getIndentString(Depth + 1);

(

*

: RD->

()) {

*IFD = dyn_cast<IndirectFieldDecl>(

);

*FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(

);

(!FD || FD->isUnnamedBitField() || FD->isAnonymousStructOrUnion())

getStringLiteral(FD->getName())};

(FD->isBitField()) {

FD->getBitWidthValue());

(

.isInvalid())

*InnerRD = FD->getType()->getAsRecordDecl();

*InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);

(InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {

(callPrintFunction(Format, Args) ||

dumpRecordValue(InnerRD,

.get(), FieldIndentArg, Depth + 1))

(appendFormatSpecifier(FD->getType(), Format)) {

Args.push_back(

.get());

Args.push_back(FieldAddr.

());

(callPrintFunction(Format, Args))

RecordIndent ? callPrintFunction(

, RecordIndent)

: callPrintFunction(

);

*buildWrapper() {

TheCall->

(Wrapper->getType());

TheCall->

(0, PtrArgResult.

());

diag::err_expected_struct_pointer_argument)

diag::err_incomplete_type))

(BT ? BT->getKind() : BuiltinType::Void) {

BuiltinType::Dependent:

BuiltinType::Overload:

BuiltinType::BoundMember:

BuiltinType::PseudoObject:

BuiltinType::UnknownAny:

BuiltinType::BuiltinFn:

diag::err_expected_callable_argument)

BuiltinDumpStructGenerator Generator(S, TheCall);

*PtrArg = PtrArgResult.

();

(Generator.dumpUnnamedRecord(RD, PtrArg, 0))

Generator.buildWrapper();

(

->getStmtClass() != Stmt::CallExprClass) {

S.

(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)

<<

->getSourceRange();

CE = cast<CallExpr>(

);

(CE->getCallee()->getType()->isBlockPointerType()) {

S.

(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)

<<

->getSourceRange();

*TargetDecl = CE->getCalleeDecl();

(

*FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))

(FD->getBuiltinID()) {

S.

(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)

<<

->getSourceRange();

(isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {

S.

(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)

<<

->getSourceRange();

S.

(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)

BuiltinCall->

(CE->getType());

BuiltinCall->

(1, ChainResult.

());

ScanfDiagnosticFormatHandler

ComputeSizeFunction =

llvm::function_ref<std::optional<llvm::APSInt>(

)>;

DiagnoseFunction =

llvm::function_ref<void(

,

,

)>;

ComputeSizeFunction ComputeSizeArgument;

DiagnoseFunction Diagnose;

ScanfDiagnosticFormatHandler(ComputeSizeFunction ComputeSizeArgument,

DiagnoseFunction Diagnose)

: ComputeSizeArgument(ComputeSizeArgument), Diagnose(Diagnose) {}

*StartSpecifier,

specifierLen)

{

(!FS.consumesDataArgument())

NulByte = 0;

((FS.getConversionSpecifier().getKind())) {

analyze_format_string::OptionalAmount::HowSpecified::Constant)

std::optional<llvm::APSInt> DestSizeAPS =

ComputeSizeArgument(FS.getArgIndex());

DestSize = DestSizeAPS->getZExtValue();

(DestSize < SourceSize)

Diagnose(FS.getArgIndex(), DestSize, SourceSize);

EstimateSizeFormatHandler

IsKernelCompatible =

;

EstimateSizeFormatHandler(StringRef Format)

:

(

::

(Format.find(0), Format.size()) +

*,

SpecifierLen,

FieldWidth = computeFieldWidth(FS);

Precision = computePrecision(FS);

(FS.getConversionSpecifier().getKind()) {

+= std::max(FieldWidth, (

)1);

+= std::max(FieldWidth, Precision);

+= std::max(FieldWidth, 1

+

(Precision ? 1 + Precision

(Precision ? 1 + Precision : 0)

+

(Precision ? 1 + Precision : 0)

+

IsKernelCompatible =

;

+= std::max(FieldWidth, 2

+ Precision);

+= FS.hasPlusPrefix() || FS.hasSpacePrefix();

(FS.hasAlternativeForm()) {

(FS.getConversionSpecifier().getKind()) {

+= (Precision ? 0 : 1);

assert(SpecifierLen <= Size &&

);

-= SpecifierLen;

getSizeLowerBound()

{

; }

isKernelCompatible()

{

IsKernelCompatible; }

FieldWidth = 0;

Precision = 0;

(FS.getConversionSpecifier().getKind()) {

StringRef &FormatStrRef,

&StrLen,

(

*Format = dyn_cast<StringLiteral>(FormatExpr);

Format && (Format->isOrdinary() || Format->isUTF8())) {

FormatStrRef = Format->getString();

assert(

&&

);

TypeSize =

->getZExtSize();

StrLen = std::min(std::max(TypeSize,

(1)) - 1, FormatStrRef.find(0));

Sema::checkFortifiedBuiltinMemoryFunction(

*FD,

UseDABAttr =

;

*DABAttr = FD->

<DiagnoseAsBuiltinAttr>();

UseDecl = DABAttr->getFunction();

assert(UseDecl &&

);

TranslateIndex = [&](

Index) -> std::optional<unsigned> {

DABIndices = DABAttr->argIndices_size();

NewIndex = Index < DABIndices

? DABAttr->argIndices_begin()[Index]

std::nullopt;

ComputeExplicitObjectSizeArgument =

[&](

Index) -> std::optional<llvm::APSInt> {

std::optional<unsigned> IndexOptional = TranslateIndex(Index);

std::nullopt;

NewIndex = *IndexOptional;

std::nullopt;

.setIsUnsigned(

);

ComputeSizeArgument =

[&](

Index) -> std::optional<llvm::APSInt> {

(Index < FD->getNumParams()) {

(

*POS =

BOSType = POS->getType();

std::optional<unsigned> IndexOptional = TranslateIndex(Index);

std::nullopt;

NewIndex = *IndexOptional;

std::nullopt;

*ObjArg = TheCall->

(NewIndex);

std::nullopt;

llvm::APSInt::getUnsigned(

).extOrTrunc(SizeTypeWidth);

ComputeStrLenArgument =

[&](

Index) -> std::optional<llvm::APSInt> {

std::optional<unsigned> IndexOptional = TranslateIndex(Index);

std::nullopt;

NewIndex = *IndexOptional;

*ObjArg = TheCall->

(NewIndex);

std::nullopt;

llvm::APSInt::getUnsigned(

+ 1).extOrTrunc(SizeTypeWidth);

std::optional<llvm::APSInt> SourceSize;

std::optional<llvm::APSInt> DestinationSize;

DiagID = 0;

IsChkVariant =

;

GetFunctionName = [&]() {

FunctionName = FunctionName.drop_front(std::strlen(

));

FunctionName = FunctionName.drop_back(std::strlen(

));

FunctionName.consume_front(

);

FunctionName;

(BuiltinID) {

Builtin::BI__builtin_strcpy:

Builtin::BIstrcpy: {

DiagID = diag::warn_fortify_strlen_overflow;

SourceSize = ComputeStrLenArgument(1);

DestinationSize = ComputeSizeArgument(0);

Builtin::BI__builtin___strcpy_chk: {

DiagID = diag::warn_fortify_strlen_overflow;

SourceSize = ComputeStrLenArgument(1);

DestinationSize = ComputeExplicitObjectSizeArgument(2);

IsChkVariant =

;

Builtin::BIscanf:

Builtin::BIfscanf:

Builtin::BIsscanf: {

FormatIndex = 1;

DataIndex = 2;

(BuiltinID == Builtin::BIscanf) {

*FormatExpr =

StringRef FormatStrRef;

= [&](

ArgIndex,

DestSize,

SourceSize) {

DiagID = diag::warn_fortify_scanf_overflow;

Index = ArgIndex + DataIndex;

StringRef FunctionName = GetFunctionName();

(DiagID) << FunctionName << (Index + 1)

<< DestSize << SourceSize);

ShiftedComputeSizeArgument = [&](

Index) {

ComputeSizeArgument(Index + DataIndex);

ScanfDiagnosticFormatHandler H(ShiftedComputeSizeArgument,

);

*FormatBytes = FormatStrRef.data();

Builtin::BIsprintf:

Builtin::BI__builtin___sprintf_chk: {

FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;

StringRef FormatStrRef;

EstimateSizeFormatHandler H(FormatStrRef);

*FormatBytes = FormatStrRef.data();

H, FormatBytes, FormatBytes + StrLen,

(),

DiagID = H.isKernelCompatible()

? diag::warn_format_overflow

: diag::warn_format_overflow_non_kprintf;

SourceSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())

.extOrTrunc(SizeTypeWidth);

(BuiltinID == Builtin::BI__builtin___sprintf_chk) {

DestinationSize = ComputeExplicitObjectSizeArgument(2);

IsChkVariant =

;

DestinationSize = ComputeSizeArgument(0);

Builtin::BI__builtin___memcpy_chk:

Builtin::BI__builtin___memmove_chk:

Builtin::BI__builtin___memset_chk:

Builtin::BI__builtin___strlcat_chk:

Builtin::BI__builtin___strlcpy_chk:

Builtin::BI__builtin___strncat_chk:

Builtin::BI__builtin___strncpy_chk:

Builtin::BI__builtin___stpncpy_chk:

Builtin::BI__builtin___memccpy_chk:

Builtin::BI__builtin___mempcpy_chk: {

DiagID = diag::warn_builtin_chk_overflow;

SourceSize = ComputeExplicitObjectSizeArgument(TheCall->

() - 2);

ComputeExplicitObjectSizeArgument(TheCall->

() - 1);

IsChkVariant =

;

Builtin::BI__builtin___snprintf_chk:

Builtin::BI__builtin___vsnprintf_chk: {

DiagID = diag::warn_builtin_chk_overflow;

SourceSize = ComputeExplicitObjectSizeArgument(1);

DestinationSize = ComputeExplicitObjectSizeArgument(3);

IsChkVariant =

;

Builtin::BIstrncat:

Builtin::BI__builtin_strncat:

Builtin::BIstrncpy:

Builtin::BI__builtin_strncpy:

Builtin::BIstpncpy:

Builtin::BI__builtin_stpncpy: {

DiagID = diag::warn_fortify_source_size_mismatch;

SourceSize = ComputeExplicitObjectSizeArgument(TheCall->

() - 1);

DestinationSize = ComputeSizeArgument(0);

Builtin::BImemcpy:

Builtin::BI__builtin_memcpy:

Builtin::BImemmove:

Builtin::BI__builtin_memmove:

Builtin::BImemset:

Builtin::BI__builtin_memset:

Builtin::BImempcpy:

Builtin::BI__builtin_mempcpy: {

DiagID = diag::warn_fortify_source_overflow;

SourceSize = ComputeExplicitObjectSizeArgument(TheCall->

() - 1);

DestinationSize = ComputeSizeArgument(0);

Builtin::BIsnprintf:

Builtin::BI__builtin_snprintf:

Builtin::BIvsnprintf:

Builtin::BI__builtin_vsnprintf: {

DiagID = diag::warn_fortify_source_size_mismatch;

SourceSize = ComputeExplicitObjectSizeArgument(1);

StringRef FormatStrRef;

EstimateSizeFormatHandler H(FormatStrRef);

*FormatBytes = FormatStrRef.data();

H, FormatBytes, FormatBytes + StrLen,

(),

llvm::APSInt FormatSize =

llvm::APSInt::getUnsigned(H.getSizeLowerBound())

.extOrTrunc(SizeTypeWidth);

(FormatSize > *SourceSize && *SourceSize != 0) {

TruncationDiagID =

H.isKernelCompatible() ? diag::warn_format_truncation

: diag::warn_format_truncation_non_kprintf;

SourceSize->toString(SpecifiedSizeStr,

10);

FormatSize.toString(FormatSizeStr,

10);

(TruncationDiagID)

<< GetFunctionName() << SpecifiedSizeStr

DestinationSize = ComputeSizeArgument(0);

(!SourceSize || !DestinationSize ||

llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)

StringRef FunctionName = GetFunctionName();

DestinationSize->toString(DestinationStr,

10);

SourceSize->toString(SourceStr,

10);

<< FunctionName << DestinationStr << SourceStr);

(S && !S->isSEHExceptScope())

(!S || !(S->getFlags() & NeededScopeFlags)) {

<< DRE->getDecl()->getIdentifier();

);

PointerAuthOpKind {

llvm::raw_svector_ostream Str(

);

= KeyValue->getZExtValue();

std::pair<const ValueDecl *, CharUnits>

*BaseDecl =

{BaseDecl,

.Val.getLValueOffset()};

RequireConstant =

) {

AllowsPointer = [](PointerAuthOpKind OpKind) {

OpKind != PAO_BlendInteger;

AllowsInteger = [](PointerAuthOpKind OpKind) {

OpKind == PAO_Discriminator || OpKind == PAO_BlendInteger ||

OpKind == PAO_SignGeneric;

}

(AllowsInteger(OpKind) &&

<<

(OpKind == PAO_Discriminator ? 1

: OpKind == PAO_BlendPointer ? 2

: OpKind == PAO_BlendInteger ? 3

<<

(AllowsInteger(OpKind) ? (AllowsPointer(OpKind) ? 2 : 1) : 0)

(!RequireConstant) {

((OpKind == PAO_Sign || OpKind == PAO_Auth) &&

? diag::warn_ptrauth_sign_null_pointer

: diag::warn_ptrauth_auth_null_pointer)

(OpKind == PAO_Sign) {

(isa<FunctionDecl>(BaseDecl))

S.

(Arg->

(), diag::err_ptrauth_bad_constant_pointer);

assert(OpKind == PAO_Discriminator);

(

->getBuiltinCallee() ==

Builtin::BI__builtin_ptrauth_blend_discriminator) {

assert(

->getType()->isPointerType());

(!BaseDecl || !isa<VarDecl>(BaseDecl))

assert(

->getType()->isIntegerType());

S.

(Arg->

(), diag::err_ptrauth_bad_constant_discriminator);

->setType(

->getArgs()[0]->getType());

PointerAuthOpKind OpKind,

RequireConstant) {

->setType(

->getArgs()[0]->getType());

->setType(

->getArgs()[0]->getType());

*Arg =

->getArg(0)->IgnoreParenImpCasts();

*Literal = dyn_cast<StringLiteral>(Arg);

(!Literal || Literal->getCharByteWidth() != 1) {

S.

(Arg->

(), diag::err_ptrauth_string_not_literal)

DiagSelect = [&]() -> std::optional<unsigned> {

std::optional<unsigned>{};

S.

(TheCall->

(), diag::err_builtin_launder_invalid_arg)

diag::err_incomplete_type))

);

(PT->getPointeeType()->isFunctionType()) {

diag::err_builtin_is_within_lifetime_invalid_arg)

(PT->getPointeeType()->isVariableArrayType()) {

<< 1 <<

;

diag::err_builtin_is_within_lifetime_invalid_arg)

llvm::Triple::ObjectFormatType CurObjFormat =

(llvm::is_contained(UnsupportedObjectFormatTypes, CurObjFormat)) {

S.

(TheCall->

(), diag::err_builtin_target_unsupported)

llvm::Triple::ArchType CurArch =

(llvm::is_contained(SupportedArchs, CurArch))

S.

(TheCall->

(), diag::err_builtin_target_unsupported)

Sema::CheckTSBuiltinFunctionCall(

&TI,

BuiltinID,

llvm::Triple::arm:

llvm::Triple::armeb:

llvm::Triple::thumb:

llvm::Triple::thumbeb:

llvm::Triple::aarch64:

llvm::Triple::aarch64_32:

llvm::Triple::aarch64_be:

llvm::Triple::bpfeb:

llvm::Triple::bpfel:

llvm::Triple::hexagon:

llvm::Triple::mips:

llvm::Triple::mipsel:

llvm::Triple::mips64:

llvm::Triple::mips64el:

llvm::Triple::spirv:

llvm::Triple::systemz:

llvm::Triple::x86:

llvm::Triple::x86_64:

llvm::Triple::ppc:

llvm::Triple::ppcle:

llvm::Triple::ppc64:

llvm::Triple::ppc64le:

llvm::Triple::amdgcn:

llvm::Triple::riscv32:

llvm::Triple::riscv64:

llvm::Triple::loongarch32:

llvm::Triple::loongarch64:

llvm::Triple::wasm32:

llvm::Triple::wasm64:

llvm::Triple::nvptx:

llvm::Triple::nvptx64:

S.

(

, diag::err_builtin_invalid_arg_type)

<< ArgIndex <<

0 << ArgTy;

EltTy = VecTy->getElementType();

S.

(

, diag::err_builtin_invalid_arg_type)

<< ArgIndex <<

5 << ArgTy;

*AuxTI,

BuiltinID) {

assert((BuiltinID == Builtin::BI__builtin_cpu_supports ||

BuiltinID == Builtin::BI__builtin_cpu_is) &&

);

IsCPUSupports = BuiltinID == Builtin::BI__builtin_cpu_supports;

SupportsBI = [=](

*TInfo) {

TInfo && ((IsCPUSupports && TInfo->supportsCpuSupports()) ||

(!IsCPUSupports && TInfo->supportsCpuIs()));

(!SupportsBI(&TI) && SupportsBI(AuxTI))

? diag::err_builtin_aix_os_unsupported

: diag::err_builtin_target_unsupported)

(!isa<StringLiteral>(Arg))

S.

(TheCall->

(), diag::err_expr_not_string_literal)

StringRef Feature = cast<StringLiteral>(Arg)->getString();

TheCall->

(0, Arg);

TheCall->

(0, Arg0);

<< 1 <<

7 << Arg0Ty;

TheCall->

(1, Arg1);

<< 2 <<

8 << Arg1Ty;

Sema::CheckBuiltinFunctionCall(

*FDecl,

BuiltinID,

ICEArguments = 0;

(

ArgNo = 0; ICEArguments != 0; ++ArgNo) {

((ICEArguments & (1 << ArgNo)) == 0)

;

(ArgNo < TheCall->getNumArgs() &&

ICEArguments &= ~(1 << ArgNo);

(BuiltinID) {

Builtin::BI__builtin_cpu_supports:

Builtin::BI__builtin_cpu_is:

Builtin::BI__builtin_cpu_init:

Builtin::BI__builtin___CFStringMakeConstantString:

*

, BuiltinID, TheCall,

{llvm::Triple::GOFF, llvm::Triple::XCOFF}))

);

(

().CheckObjCString(TheCall->

(0)))

Builtin::BI__builtin_ms_va_start:

Builtin::BI__builtin_stdarg_start:

Builtin::BI__builtin_va_start:

(BuiltinVAStart(BuiltinID, TheCall))

Builtin::BI__va_start: {

llvm::Triple::aarch64:

llvm::Triple::arm:

llvm::Triple::thumb:

(BuiltinVAStartARMMicrosoft(TheCall))

(BuiltinVAStart(BuiltinID, TheCall))

Builtin::BI_interlockedbittestandset_acq:

Builtin::BI_interlockedbittestandset_rel:

Builtin::BI_interlockedbittestandset_nf:

Builtin::BI_interlockedbittestandreset_acq:

Builtin::BI_interlockedbittestandreset_rel:

Builtin::BI_interlockedbittestandreset_nf:

{llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))

Builtin::BI_bittest64:

Builtin::BI_bittestandcomplement64:

Builtin::BI_bittestandreset64:

Builtin::BI_bittestandset64:

Builtin::BI_interlockedbittestandreset64:

Builtin::BI_interlockedbittestandset64:

{llvm::Triple::x86_64, llvm::Triple::arm, llvm::Triple::thumb,

llvm::Triple::aarch64, llvm::Triple::amdgcn}))

Builtin::BI__builtin_set_flt_rounds:

{llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::arm,

llvm::Triple::thumb, llvm::Triple::aarch64, llvm::Triple::amdgcn,

llvm::Triple::ppc, llvm::Triple::ppc64, llvm::Triple::ppcle,

llvm::Triple::ppc64le}))

Builtin::BI__builtin_isgreater:

Builtin::BI__builtin_isgreaterequal:

Builtin::BI__builtin_isless:

Builtin::BI__builtin_islessequal:

Builtin::BI__builtin_islessgreater:

Builtin::BI__builtin_isunordered:

(BuiltinUnorderedCompare(TheCall, BuiltinID))

Builtin::BI__builtin_fpclassify:

(BuiltinFPClassification(TheCall, 6, BuiltinID))

Builtin::BI__builtin_isfpclass:

(BuiltinFPClassification(TheCall, 2, BuiltinID))

Builtin::BI__builtin_isfinite:

Builtin::BI__builtin_isinf:

Builtin::BI__builtin_isinf_sign:

Builtin::BI__builtin_isnan:

Builtin::BI__builtin_issignaling:

Builtin::BI__builtin_isnormal:

Builtin::BI__builtin_issubnormal:

Builtin::BI__builtin_iszero:

Builtin::BI__builtin_signbit:

Builtin::BI__builtin_signbitf:

Builtin::BI__builtin_signbitl:

(BuiltinFPClassification(TheCall, 1, BuiltinID))

Builtin::BI__builtin_shufflevector:

Builtin::BI__builtin_prefetch:

(BuiltinPrefetch(TheCall))

Builtin::BI__builtin_alloca_with_align:

Builtin::BI__builtin_alloca_with_align_uninitialized:

(BuiltinAllocaWithAlign(TheCall))

Builtin::BI__builtin_alloca:

Builtin::BI__builtin_alloca_uninitialized:

Builtin::BI__arithmetic_fence:

(BuiltinArithmeticFence(TheCall))

Builtin::BI__assume:

Builtin::BI__builtin_assume:

(BuiltinAssume(TheCall))

Builtin::BI__builtin_assume_aligned:

(BuiltinAssumeAligned(TheCall))

Builtin::BI__builtin_dynamic_object_size:

Builtin::BI__builtin_object_size:

Builtin::BI__builtin_longjmp:

(BuiltinLongjmp(TheCall))

Builtin::BI__builtin_setjmp:

(BuiltinSetjmp(TheCall))

Builtin::BI__builtin_classify_type:

Builtin::BI__builtin_complex:

(BuiltinComplex(TheCall))

Builtin::BI__builtin_constant_p: {

Builtin::BI__builtin_launder:

Builtin::BI__builtin_is_within_lifetime:

Builtin::BI__sync_fetch_and_add:

Builtin::BI__sync_fetch_and_add_1:

Builtin::BI__sync_fetch_and_add_2:

Builtin::BI__sync_fetch_and_add_4:

Builtin::BI__sync_fetch_and_add_8:

Builtin::BI__sync_fetch_and_add_16:

Builtin::BI__sync_fetch_and_sub:

Builtin::BI__sync_fetch_and_sub_1:

Builtin::BI__sync_fetch_and_sub_2:

Builtin::BI__sync_fetch_and_sub_4:

Builtin::BI__sync_fetch_and_sub_8:

Builtin::BI__sync_fetch_and_sub_16:

Builtin::BI__sync_fetch_and_or:

Builtin::BI__sync_fetch_and_or_1:

Builtin::BI__sync_fetch_and_or_2:

Builtin::BI__sync_fetch_and_or_4:

Builtin::BI__sync_fetch_and_or_8:

Builtin::BI__sync_fetch_and_or_16:

Builtin::BI__sync_fetch_and_and:

Builtin::BI__sync_fetch_and_and_1:

Builtin::BI__sync_fetch_and_and_2:

Builtin::BI__sync_fetch_and_and_4:

Builtin::BI__sync_fetch_and_and_8:

Builtin::BI__sync_fetch_and_and_16:

Builtin::BI__sync_fetch_and_xor:

Builtin::BI__sync_fetch_and_xor_1:

Builtin::BI__sync_fetch_and_xor_2:

Builtin::BI__sync_fetch_and_xor_4:

Builtin::BI__sync_fetch_and_xor_8:

Builtin::BI__sync_fetch_and_xor_16:

Builtin::BI__sync_fetch_and_nand:

Builtin::BI__sync_fetch_and_nand_1:

Builtin::BI__sync_fetch_and_nand_2:

Builtin::BI__sync_fetch_and_nand_4:

Builtin::BI__sync_fetch_and_nand_8:

Builtin::BI__sync_fetch_and_nand_16:

Builtin::BI__sync_add_and_fetch:

Builtin::BI__sync_add_and_fetch_1:

Builtin::BI__sync_add_and_fetch_2:

Builtin::BI__sync_add_and_fetch_4:

Builtin::BI__sync_add_and_fetch_8:

Builtin::BI__sync_add_and_fetch_16:

Builtin::BI__sync_sub_and_fetch:

Builtin::BI__sync_sub_and_fetch_1:

Builtin::BI__sync_sub_and_fetch_2:

Builtin::BI__sync_sub_and_fetch_4:

Builtin::BI__sync_sub_and_fetch_8:

Builtin::BI__sync_sub_and_fetch_16:

Builtin::BI__sync_and_and_fetch:

Builtin::BI__sync_and_and_fetch_1:

Builtin::BI__sync_and_and_fetch_2:

Builtin::BI__sync_and_and_fetch_4:

Builtin::BI__sync_and_and_fetch_8:

Builtin::BI__sync_and_and_fetch_16:

Builtin::BI__sync_or_and_fetch:

Builtin::BI__sync_or_and_fetch_1:

Builtin::BI__sync_or_and_fetch_2:

Builtin::BI__sync_or_and_fetch_4:

Builtin::BI__sync_or_and_fetch_8:

Builtin::BI__sync_or_and_fetch_16:

Builtin::BI__sync_xor_and_fetch:

Builtin::BI__sync_xor_and_fetch_1:

Builtin::BI__sync_xor_and_fetch_2:

Builtin::BI__sync_xor_and_fetch_4:

Builtin::BI__sync_xor_and_fetch_8:

Builtin::BI__sync_xor_and_fetch_16:

Builtin::BI__sync_nand_and_fetch:

Builtin::BI__sync_nand_and_fetch_1:

Builtin::BI__sync_nand_and_fetch_2:

Builtin::BI__sync_nand_and_fetch_4:

Builtin::BI__sync_nand_and_fetch_8:

Builtin::BI__sync_nand_and_fetch_16:

Builtin::BI__sync_val_compare_and_swap:

Builtin::BI__sync_val_compare_and_swap_1:

Builtin::BI__sync_val_compare_and_swap_2:

Builtin::BI__sync_val_compare_and_swap_4:

Builtin::BI__sync_val_compare_and_swap_8:

Builtin::BI__sync_val_compare_and_swap_16:

Builtin::BI__sync_bool_compare_and_swap:

Builtin::BI__sync_bool_compare_and_swap_1:

Builtin::BI__sync_bool_compare_and_swap_2:

Builtin::BI__sync_bool_compare_and_swap_4:

Builtin::BI__sync_bool_compare_and_swap_8:

Builtin::BI__sync_bool_compare_and_swap_16:

Builtin::BI__sync_lock_test_and_set:

Builtin::BI__sync_lock_test_and_set_1:

Builtin::BI__sync_lock_test_and_set_2:

Builtin::BI__sync_lock_test_and_set_4:

Builtin::BI__sync_lock_test_and_set_8:

Builtin::BI__sync_lock_test_and_set_16:

Builtin::BI__sync_lock_release:

Builtin::BI__sync_lock_release_1:

Builtin::BI__sync_lock_release_2:

Builtin::BI__sync_lock_release_4:

Builtin::BI__sync_lock_release_8:

Builtin::BI__sync_lock_release_16:

Builtin::BI__sync_swap:

Builtin::BI__sync_swap_1:

Builtin::BI__sync_swap_2:

Builtin::BI__sync_swap_4:

Builtin::BI__sync_swap_8:

Builtin::BI__sync_swap_16:

BuiltinAtomicOverloaded(TheCallResult);

Builtin::BI__sync_synchronize:

Builtin::BI__builtin_nontemporal_load:

Builtin::BI__builtin_nontemporal_store:

BuiltinNontemporalOverloaded(TheCallResult);

Builtin::BI__builtin_memcpy_inline: {

Builtin::BI__builtin_memset_inline: {

Builtin::BI__annotation:

Builtin::BI__builtin_annotation:

Builtin::BI__builtin_addressof:

Builtin::BI__builtin_function_start:

Builtin::BI__builtin_is_aligned:

Builtin::BI__builtin_align_up:

Builtin::BI__builtin_align_down:

Builtin::BI__builtin_add_overflow:

Builtin::BI__builtin_sub_overflow:

Builtin::BI__builtin_mul_overflow:

Builtin::BI__builtin_operator_new:

Builtin::BI__builtin_operator_delete: {

IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;

BuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);

Builtin::BI__builtin_dump_struct:

Builtin::BI__builtin_expect_with_probability: {

Eval.

= &Notes;

(ProbArg->

(), diag::err_probability_not_constant_float)

llvm::APFloat Probability = Eval.

.

();

LoseInfo =

;

Probability.convert(llvm::APFloat::IEEEdouble(),

llvm::RoundingMode::Dynamic, &LoseInfo);

(!(Probability >= llvm::APFloat(0.0) &&

Probability <= llvm::APFloat(1.0))) {

Builtin::BI__builtin_preserve_access_index:

Builtin::BI__builtin_call_with_static_chain:

Builtin::BI__exception_code:

Builtin::BI_exception_code:

diag::err_seh___except_block))

Builtin::BI__exception_info:

Builtin::BI_exception_info:

diag::err_seh___except_filter))

Builtin::BI__GetExceptionInfo:

Builtin::BIaddressof:

Builtin::BI__addressof:

Builtin::BIforward:

Builtin::BIforward_like:

Builtin::BImove:

Builtin::BImove_if_noexcept:

Builtin::BIas_const: {

ReturnsPointer = BuiltinID == Builtin::BIaddressof ||

BuiltinID == Builtin::BI__addressof;

(ReturnsPointer ?

->isAnyPointerType()

:

->isReferenceType()) &&

->getPointeeType()))) {

(TheCall->

(), diag::err_builtin_move_forward_unsupported)

Builtin::BI__builtin_ptrauth_strip:

Builtin::BI__builtin_ptrauth_blend_discriminator:

Builtin::BI__builtin_ptrauth_sign_constant:

Builtin::BI__builtin_ptrauth_sign_unauthenticated:

Builtin::BI__builtin_ptrauth_auth:

Builtin::BI__builtin_ptrauth_sign_generic_data:

Builtin::BI__builtin_ptrauth_auth_and_resign:

Builtin::BI__builtin_ptrauth_string_discriminator:

Builtin::BIread_pipe:

Builtin::BIwrite_pipe:

(

().checkBuiltinRWPipe(TheCall))

Builtin::BIreserve_read_pipe:

Builtin::BIreserve_write_pipe:

Builtin::BIwork_group_reserve_read_pipe:

Builtin::BIwork_group_reserve_write_pipe:

(

().checkBuiltinReserveRWPipe(TheCall))

Builtin::BIsub_group_reserve_read_pipe:

Builtin::BIsub_group_reserve_write_pipe:

(

().checkSubgroupExt(TheCall) ||

().checkBuiltinReserveRWPipe(TheCall))

Builtin::BIcommit_read_pipe:

Builtin::BIcommit_write_pipe:

Builtin::BIwork_group_commit_read_pipe:

Builtin::BIwork_group_commit_write_pipe:

(

().checkBuiltinCommitRWPipe(TheCall))

Builtin::BIsub_group_commit_read_pipe:

Builtin::BIsub_group_commit_write_pipe:

(

().checkSubgroupExt(TheCall) ||

().checkBuiltinCommitRWPipe(TheCall))

Builtin::BIget_pipe_num_packets:

Builtin::BIget_pipe_max_packets:

(

().checkBuiltinPipePackets(TheCall))

Builtin::BIto_global:

Builtin::BIto_local:

Builtin::BIto_private:

(

().checkBuiltinToAddr(BuiltinID, TheCall))

Builtin::BIenqueue_kernel:

(

().checkBuiltinEnqueueKernel(TheCall))

Builtin::BIget_kernel_work_group_size:

Builtin::BIget_kernel_preferred_work_group_size_multiple:

(

().checkBuiltinKernelWorkGroupSize(TheCall))

Builtin::BIget_kernel_max_sub_group_size_for_ndrange:

Builtin::BIget_kernel_sub_group_count_for_ndrange:

(

().checkBuiltinNDRangeAndBlock(TheCall))

Builtin::BI__builtin_os_log_format:

Builtin::BI__builtin_os_log_format_buffer_size:

(BuiltinOSLogFormat(TheCall))

Builtin::BI__builtin_frame_address:

Builtin::BI__builtin_return_address: {

.Val.getInt() != 0)

<< ((BuiltinID == Builtin::BI__builtin_return_address)

?

:

)

Builtin::BI__builtin_nondeterministic_value: {

(BuiltinNonDeterministicValue(TheCall))

Builtin::BI__builtin_elementwise_abs: {

EltTy = VecTy->getElementType();

diag::err_builtin_invalid_arg_type)

Builtin::BI__builtin_elementwise_acos:

Builtin::BI__builtin_elementwise_asin:

Builtin::BI__builtin_elementwise_atan:

Builtin::BI__builtin_elementwise_ceil:

Builtin::BI__builtin_elementwise_cos:

Builtin::BI__builtin_elementwise_cosh:

Builtin::BI__builtin_elementwise_exp:

Builtin::BI__builtin_elementwise_exp2:

Builtin::BI__builtin_elementwise_floor:

Builtin::BI__builtin_elementwise_log:

Builtin::BI__builtin_elementwise_log2:

Builtin::BI__builtin_elementwise_log10:

Builtin::BI__builtin_elementwise_roundeven:

Builtin::BI__builtin_elementwise_round:

Builtin::BI__builtin_elementwise_rint:

Builtin::BI__builtin_elementwise_nearbyint:

Builtin::BI__builtin_elementwise_sin:

Builtin::BI__builtin_elementwise_sinh:

Builtin::BI__builtin_elementwise_sqrt:

Builtin::BI__builtin_elementwise_tan:

Builtin::BI__builtin_elementwise_tanh:

Builtin::BI__builtin_elementwise_trunc:

Builtin::BI__builtin_elementwise_canonicalize: {

Builtin::BI__builtin_elementwise_fma: {

Builtin::BI__builtin_elementwise_minimum:

Builtin::BI__builtin_elementwise_maximum:

Builtin::BI__builtin_elementwise_atan2:

Builtin::BI__builtin_elementwise_fmod:

Builtin::BI__builtin_elementwise_pow: {

(BuiltinElementwiseMath(TheCall,

))

Builtin::BI__builtin_elementwise_add_sat:

Builtin::BI__builtin_elementwise_sub_sat: {

(BuiltinElementwiseMath(TheCall))

EltTy = VecTy->getElementType();

Builtin::BI__builtin_elementwise_min:

Builtin::BI__builtin_elementwise_max:

(BuiltinElementwiseMath(TheCall))

Builtin::BI__builtin_elementwise_popcount:

Builtin::BI__builtin_elementwise_bitreverse: {

EltTy = VecTy->getElementType();

Builtin::BI__builtin_elementwise_copysign: {

diag::err_typecheck_call_different_arg_types)

<< MagnitudeTy << SignTy;

TheCall->

(0, Magnitude.

());

Builtin::BI__builtin_reduce_max:

Builtin::BI__builtin_reduce_min: {

(PrepareBuiltinReduceMathOneArgCall(TheCall))

ElTy = TyA->getElementType();

(ElTy.isNull()) {

<< 1 <<

4 << Arg->

();

Builtin::BI__builtin_reduce_maximum:

Builtin::BI__builtin_reduce_minimum: {

(PrepareBuiltinReduceMathOneArgCall(TheCall))

ElTy = TyA->getElementType();

(ElTy.isNull() || !ElTy->isFloatingType()) {

<< 1 <<

9 << Arg->

();

Builtin::BI__builtin_reduce_add:

Builtin::BI__builtin_reduce_mul:

Builtin::BI__builtin_reduce_xor:

Builtin::BI__builtin_reduce_or:

Builtin::BI__builtin_reduce_and: {

(PrepareBuiltinReduceMathOneArgCall(TheCall))

ElTy = TyA->getElementType();

(ElTy.isNull() || !ElTy->isIntegerType()) {

<< 1 <<

6 << Arg->

();

Builtin::BI__builtin_matrix_transpose:

BuiltinMatrixTranspose(TheCall, TheCallResult);

Builtin::BI__builtin_matrix_column_major_load:

BuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);

Builtin::BI__builtin_matrix_column_major_store:

BuiltinMatrixColumnMajorStore(TheCall, TheCallResult);

Builtin::BI__builtin_verbose_trap:

Builtin::BI__builtin_get_device_side_mangled_name: {

Check = [](

*TheCall) {

*

= DRE->getDecl();

(!isa<FunctionDecl>(

) && !isa<VarDecl>(

))

->

<CUDAGlobalAttr>() ||

->

<CUDADeviceAttr>() ||

(!Check(TheCall)) {

diag::err_hip_invalid_args_builtin_mangled_name);

Builtin::BI__builtin_popcountg:

Builtin::BI__builtin_clzg:

Builtin::BI__builtin_ctzg:

Builtin::BI__builtin_allow_runtime_check: {

Builtin::BI__builtin_counted_by_ref:

(BuiltinCountedByRef(TheCall))

);

(CheckTSBuiltinFunctionCall(

TheCallResult;

(

.isShiftedMask() || (~

).isShiftedMask())

diag::err_argument_not_contiguous_bit_field)

(Format->getFirstArg() == 0)

(IsVariadic)

FSI->

= Format->getFormatIdx() - 1;

(isa<CXXNullPtrLiteralExpr>(

(

*CLE = dyn_cast<CompoundLiteralExpr>(

))

(

*ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))

= ILE->getInit(0);

*ArgExpr,

S.

(diag::warn_null_arg)

(

nullability =

->getNullability())

assert((FDecl || Proto) &&

);

llvm::SmallBitVector NonNullArgs;

(!

->args_size()) {

(

*Arg : Args)

IdxAST = Idx.getASTIndex();

(IdxAST >= Args.size())

(NonNullArgs.empty())

NonNullArgs.resize(Args.size());

NonNullArgs.set(IdxAST);

(FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {

(

*FD = dyn_cast<FunctionDecl>(FDecl))

parms = cast<ObjCMethodDecl>(FDecl)->parameters();

ParamIndex = 0;

I !=

; ++I, ++ParamIndex) {

(NonNullArgs.empty())

NonNullArgs.resize(Args.size());

NonNullArgs.set(ParamIndex);

(

*VD = dyn_cast<ValueDecl>(FDecl)) {

= blockType->getPointeeType();

(NonNullArgs.empty())

NonNullArgs.resize(Args.size());

NonNullArgs.set(Index);

(

ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();

ArgIndex != ArgIndexEnd; ++ArgIndex) {

(NonNullArgs[ArgIndex])

StringRef ParamName,

ArgTy,

(ArgAlign < ParamAlign)

(

, diag::warn_param_mismatched_alignment)

<< ParamName << (FDecl !=

) << FDecl;

*ThisArg,

(!FD || Args.empty())

GetArgAt = [&](

Idx) ->

* {

(Idx == LifetimeCaptureByAttr::GLOBAL ||

Idx == LifetimeCaptureByAttr::UNKNOWN)

(IsMemberFunction && Idx == 0)

Args[Idx - IsMemberFunction];

HandleCaptureByAttr = [&](

LifetimeCaptureByAttr *

,

*Captured =

*

(GetArgAt(ArgIdx));

(

CapturingParamIdx :

->params()) {

(CapturingParamIdx == LifetimeCaptureByAttr::THIS &&

isa<CXXConstructorDecl>(FD))

*Capturing =

*

(GetArgAt(CapturingParamIdx));

I + IsMemberFunction);

(IsMemberFunction) {

HandleCaptureByAttr(ATL.

<LifetimeCaptureByAttr>(), 0);

llvm::SmallBitVector CheckedVarArgs;

CheckedVarArgs.resize(Args.size());

CheckFormatArguments(I, Args, IsMemberFunction, CallType,

,

,

*FD = dyn_cast_or_null<FunctionDecl>(FDecl);

: isa_and_nonnull<FunctionDecl>(FDecl)

? cast<FunctionDecl>(FDecl)->getNumParams()

: isa_and_nonnull<ObjCMethodDecl>(FDecl)

? cast<ObjCMethodDecl>(FDecl)->param_size()

(

ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {

(

*Arg = Args[ArgIdx]) {

(CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])

(FDecl || Proto) {

(

*I : FDecl->

<ArgumentWithTypeTagAttr>())

CheckArgumentWithTypeTag(I, Args,

);

(!Proto && FDecl) {

(isa_and_nonnull<FunctionProtoType>(FT))

N = std::min<unsigned>(Proto->

(), Args.size());

IsScalableArg =

;

(

ArgIdx = 0; ArgIdx < N; ++ArgIdx) {

(

*Arg = Args[ArgIdx]) {

IsScalableArg =

;

CheckArgAlignment(Arg->

(), FDecl, std::to_string(ArgIdx + 1),

(

*CallerFD = dyn_cast<FunctionDecl>(

)) {

llvm::StringMap<bool> CallerFeatureMap;

(!CallerFeatureMap.contains(

))

(

, diag::err_sme_call_in_non_sme_target);

(

, diag::err_sme_call_in_non_sme_target);

*CallerFD = dyn_cast<FunctionDecl>(

);

(IsScalableArg || IsScalableRet)) {

IsCalleeStreaming =

IsCalleeStreamingCompatible =

(!IsCalleeStreamingCompatible &&

(

, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)

(

, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)

CallerHasZAState =

;

CallerHasZT0State =

;

*

= CallerFD->getAttr<ArmNewAttr>();

CallerHasZAState =

;

CallerHasZT0State =

;

FPT->getExtProtoInfo().AArch64SMEAttributes) !=

CallerHasZT0State |=

FPT->getExtProtoInfo().AArch64SMEAttributes) !=

(

, diag::err_sme_za_call_no_za_state);

(

, diag::err_sme_zt0_call_no_zt0_state);

(

, diag::err_sme_unimplemented_za_save_restore);

(

, diag::note_sme_use_preserves_za);

(FDecl && FDecl->

<AllocAlignAttr>()) {

*AA = FDecl->

<AllocAlignAttr>();

*Arg = Args[AA->getParamIndex().getASTIndex()];

(!Arg->isValueDependent()) {

(Arg->EvaluateAsInt(Align,

)) {

llvm::APSInt &I = Align.

.

();

(!I.isPowerOf2())

(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)

<< Arg->getSourceRange();

(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)

*Ctor = cast<CXXConstructorDecl>(FDecl);

(FDecl, Proto,

, Args,

,

IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&

isa<CXXMethodDecl>(FDecl);

IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||

IsMemberOperatorCall;

*ImplicitThis =

;

ImplicitThis = Args[0];

}

(IsMemberFunction && !FDecl->

() &&

cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();

cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());

CheckArgAlignment(TheCall->

(), FDecl,

, ThisType,

CheckAbsoluteValueFunction(TheCall, FDecl);

CheckMaxUnsignedZero(TheCall, FDecl);

CheckInfNaNFunction(TheCall, FDecl);

Builtin::BIstrlcpy:

Builtin::BIstrlcat:

CheckStrlcpycatArguments(TheCall, FnInfo);

Builtin::BIstrncat:

CheckStrncatArguments(TheCall, FnInfo);

Builtin::BIfree:

CheckFreeArguments(TheCall);

CheckMemaccessArguments(TheCall, CMId, FnInfo);

(

*

= dyn_cast<VarDecl>(NDecl))

Ty =

->getType().getNonReferenceType();

(

*F = dyn_cast<FieldDecl>(NDecl))

Ty = F->getType().getNonReferenceType();

(!llvm::isValidAtomicOrderingCABI(Ordering))

OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;

AtomicExpr::AO__c11_atomic_init:

AtomicExpr::AO__opencl_atomic_init:

llvm_unreachable(

);

AtomicExpr::AO__c11_atomic_load:

AtomicExpr::AO__opencl_atomic_load:

AtomicExpr::AO__hip_atomic_load:

AtomicExpr::AO__atomic_load_n:

AtomicExpr::AO__atomic_load:

AtomicExpr::AO__scoped_atomic_load_n:

AtomicExpr::AO__scoped_atomic_load:

OrderingCABI != llvm::AtomicOrderingCABI::release &&

OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;

AtomicExpr::AO__c11_atomic_store:

AtomicExpr::AO__opencl_atomic_store:

AtomicExpr::AO__hip_atomic_store:

AtomicExpr::AO__atomic_store:

AtomicExpr::AO__atomic_store_n:

AtomicExpr::AO__scoped_atomic_store:

AtomicExpr::AO__scoped_atomic_store_n:

AtomicExpr::AO__atomic_clear:

OrderingCABI != llvm::AtomicOrderingCABI::consume &&

OrderingCABI != llvm::AtomicOrderingCABI::acquire &&

OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;

*TheCall = cast<CallExpr>(TheCallResult.

());

NumForm = ClearByte + 1;

NumArgs[] = {2, 2, 3, 3, 3, 3, 4, 5, 6, 2, 2};

NumVals[] = {1, 0, 1, 1, 1, 1, 2, 2, 3, 0, 0};

(

(NumArgs)/

(NumArgs[0]) == NumForm

&&

(NumVals)/

(NumVals[0]) == NumForm,

);

(AtomicExpr::AO__atomic_add_fetch == 0 &&

AtomicExpr::AO__atomic_xor_fetch + 1 ==

AtomicExpr::AO__c11_atomic_compare_exchange_strong,

);

IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&

Op <= AtomicExpr::AO__opencl_atomic_store;

IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&

Op <= AtomicExpr::AO__hip_atomic_store;

IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&

Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;

IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&

Op <= AtomicExpr::AO__c11_atomic_store) ||

IsN = Op == AtomicExpr::AO__atomic_load_n ||

Op == AtomicExpr::AO__atomic_store_n ||

Op == AtomicExpr::AO__atomic_exchange_n ||

Op == AtomicExpr::AO__atomic_compare_exchange_n ||

Op == AtomicExpr::AO__scoped_atomic_load_n ||

Op == AtomicExpr::AO__scoped_atomic_store_n ||

Op == AtomicExpr::AO__scoped_atomic_exchange_n ||

Op == AtomicExpr::AO__scoped_atomic_compare_exchange_n;

ArithOpExtraValueType {

ArithAllows = AOEVT_None;

AtomicExpr::AO__c11_atomic_init:

AtomicExpr::AO__opencl_atomic_init:

AtomicExpr::AO__c11_atomic_load:

AtomicExpr::AO__opencl_atomic_load:

AtomicExpr::AO__hip_atomic_load:

AtomicExpr::AO__atomic_load_n:

AtomicExpr::AO__scoped_atomic_load_n:

AtomicExpr::AO__atomic_load:

AtomicExpr::AO__scoped_atomic_load:

AtomicExpr::AO__c11_atomic_store:

AtomicExpr::AO__opencl_atomic_store:

AtomicExpr::AO__hip_atomic_store:

AtomicExpr::AO__atomic_store:

AtomicExpr::AO__atomic_store_n:

AtomicExpr::AO__scoped_atomic_store:

AtomicExpr::AO__scoped_atomic_store_n:

AtomicExpr::AO__atomic_fetch_add:

AtomicExpr::AO__atomic_fetch_sub:

AtomicExpr::AO__atomic_add_fetch:

AtomicExpr::AO__atomic_sub_fetch:

AtomicExpr::AO__scoped_atomic_fetch_add:

AtomicExpr::AO__scoped_atomic_fetch_sub:

AtomicExpr::AO__scoped_atomic_add_fetch:

AtomicExpr::AO__scoped_atomic_sub_fetch:

AtomicExpr::AO__c11_atomic_fetch_add:

AtomicExpr::AO__c11_atomic_fetch_sub:

AtomicExpr::AO__opencl_atomic_fetch_add:

AtomicExpr::AO__opencl_atomic_fetch_sub:

AtomicExpr::AO__hip_atomic_fetch_add:

AtomicExpr::AO__hip_atomic_fetch_sub:

ArithAllows = AOEVT_Pointer | AOEVT_FP;

AtomicExpr::AO__atomic_fetch_max:

AtomicExpr::AO__atomic_fetch_min:

AtomicExpr::AO__atomic_max_fetch:

AtomicExpr::AO__atomic_min_fetch:

AtomicExpr::AO__scoped_atomic_fetch_max:

AtomicExpr::AO__scoped_atomic_fetch_min:

AtomicExpr::AO__scoped_atomic_max_fetch:

AtomicExpr::AO__scoped_atomic_min_fetch:

AtomicExpr::AO__c11_atomic_fetch_max:

AtomicExpr::AO__c11_atomic_fetch_min:

AtomicExpr::AO__opencl_atomic_fetch_max:

AtomicExpr::AO__opencl_atomic_fetch_min:

AtomicExpr::AO__hip_atomic_fetch_max:

AtomicExpr::AO__hip_atomic_fetch_min:

ArithAllows = AOEVT_FP;

AtomicExpr::AO__c11_atomic_fetch_and:

AtomicExpr::AO__c11_atomic_fetch_or:

AtomicExpr::AO__c11_atomic_fetch_xor:

AtomicExpr::AO__hip_atomic_fetch_and:

AtomicExpr::AO__hip_atomic_fetch_or:

AtomicExpr::AO__hip_atomic_fetch_xor:

AtomicExpr::AO__c11_atomic_fetch_nand:

AtomicExpr::AO__opencl_atomic_fetch_and:

AtomicExpr::AO__opencl_atomic_fetch_or:

AtomicExpr::AO__opencl_atomic_fetch_xor:

AtomicExpr::AO__atomic_fetch_and:

AtomicExpr::AO__atomic_fetch_or:

AtomicExpr::AO__atomic_fetch_xor:

AtomicExpr::AO__atomic_fetch_nand:

AtomicExpr::AO__atomic_and_fetch:

AtomicExpr::AO__atomic_or_fetch:

AtomicExpr::AO__atomic_xor_fetch:

AtomicExpr::AO__atomic_nand_fetch:

AtomicExpr::AO__scoped_atomic_fetch_and:

AtomicExpr::AO__scoped_atomic_fetch_or:

AtomicExpr::AO__scoped_atomic_fetch_xor:

AtomicExpr::AO__scoped_atomic_fetch_nand:

AtomicExpr::AO__scoped_atomic_and_fetch:

AtomicExpr::AO__scoped_atomic_or_fetch:

AtomicExpr::AO__scoped_atomic_xor_fetch:

AtomicExpr::AO__scoped_atomic_nand_fetch:

AtomicExpr::AO__c11_atomic_exchange:

AtomicExpr::AO__hip_atomic_exchange:

AtomicExpr::AO__opencl_atomic_exchange:

AtomicExpr::AO__atomic_exchange_n:

AtomicExpr::AO__scoped_atomic_exchange_n:

AtomicExpr::AO__atomic_exchange:

AtomicExpr::AO__scoped_atomic_exchange:

AtomicExpr::AO__c11_atomic_compare_exchange_strong:

AtomicExpr::AO__c11_atomic_compare_exchange_weak:

AtomicExpr::AO__hip_atomic_compare_exchange_strong:

AtomicExpr::AO__opencl_atomic_compare_exchange_strong:

AtomicExpr::AO__opencl_atomic_compare_exchange_weak:

AtomicExpr::AO__hip_atomic_compare_exchange_weak:

AtomicExpr::AO__atomic_compare_exchange:

AtomicExpr::AO__atomic_compare_exchange_n:

AtomicExpr::AO__scoped_atomic_compare_exchange:

AtomicExpr::AO__scoped_atomic_compare_exchange_n:

AtomicExpr::AO__atomic_test_and_set:

Form = TestAndSetByte;

AtomicExpr::AO__atomic_clear:

AdjustedNumArgs = NumArgs[Form];

((IsOpenCL || IsHIP || IsScoped) &&

Op != AtomicExpr::AO__opencl_atomic_init)

(Args.size() < AdjustedNumArgs) {

(CallRange.

(), diag::err_typecheck_call_too_few_args)

<< 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())

}

(Args.size() > AdjustedNumArgs) {

(Args[AdjustedNumArgs]->getBeginLoc(),

diag::err_typecheck_call_too_many_args)

<< 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())

*Ptr = Args[0];

Ptr = ConvertedPtr.

();

(ExprRange.

(), diag::err_atomic_builtin_must_be_pointer)

(ExprRange.

(), diag::err_atomic_op_needs_atomic)

(ExprRange.

(), diag::err_atomic_op_needs_non_const_atomic)

}

(Form != Load && Form != LoadCopy) {

(ExprRange.

(), diag::err_atomic_op_needs_non_const_pointer)

(Form != TestAndSetByte && Form != ClearByte) {

diag::err_incomplete_type))

(ExprRange.

(), diag::err_atomic_builtin_must_be_pointer)

->getPointeeType().getCVRQualifiers());

(Form == Arithmetic) {

IsAllowedValueType = [&](

ValType,

AllowedType) ->

{

AllowedType & AOEVT_Pointer;

&llvm::APFloat::x87DoubleExtended())

(!IsAllowedValueType(ValType, ArithAllows)) {

DID = ArithAllows & AOEVT_FP

? (ArithAllows & AOEVT_Pointer

? diag::err_atomic_op_needs_atomic_int_ptr_or_fp

: diag::err_atomic_op_needs_atomic_int_or_fp)

: diag::err_atomic_op_needs_atomic_int;

diag::err_incomplete_type)) {

(ExprRange.

(), diag::err_atomic_op_needs_atomic_int_or_ptr)

(ExprRange.

(), diag::err_atomic_op_needs_trivial_copy)

(ExprRange.

(), diag::err_arc_atomic_ownership)

(Form ==

|| Form == LoadCopy || Form == GNUXchg || Form ==

||

(Form == C11CmpXchg || Form == GNUCmpXchg || Form == TestAndSetByte)

IsPassedByAddress =

;

(!IsC11 && !IsHIP && !IsN) {

IsPassedByAddress =

;

APIOrderedArgs.push_back(Args[0]);

APIOrderedArgs.push_back(Args[1]);

APIOrderedArgs.push_back(Args[2]);

APIOrderedArgs.push_back(Args[1]);

APIOrderedArgs.push_back(Args[2]);

APIOrderedArgs.push_back(Args[3]);

APIOrderedArgs.push_back(Args[1]);

APIOrderedArgs.push_back(Args[2]);

APIOrderedArgs.push_back(Args[4]);

APIOrderedArgs.push_back(Args[1]);

APIOrderedArgs.push_back(Args[3]);

APIOrderedArgs.push_back(Args[2]);

APIOrderedArgs.push_back(Args[4]);

APIOrderedArgs.push_back(Args[5]);

APIOrderedArgs.push_back(Args[1]);

APIOrderedArgs.push_back(Args[3]);

TestAndSetByte:

APIOrderedArgs.push_back(Args[1]);

APIOrderedArgs.append(Args.begin(), Args.end());

(

i = 0; i != APIOrderedArgs.size(); ++i) {

(i < NumVals[Form] + 1) {

assert(Form != Load);

(Form ==

|| Form == Arithmetic)

(Form ==

|| Form == Xchg) {

(IsPassedByAddress) {

*ValArg = APIOrderedArgs[i];

AS = PtrTy->getPointeeType().getAddressSpace();

(IsPassedByAddress)

APIOrderedArgs[i] = Arg.

();

SubExprs.push_back(Ptr);

SubExprs.push_back(APIOrderedArgs[1]);

TestAndSetByte:

SubExprs.push_back(APIOrderedArgs[1]);

SubExprs.push_back(APIOrderedArgs[2]);

SubExprs.push_back(APIOrderedArgs[1]);

SubExprs.push_back(APIOrderedArgs[3]);

SubExprs.push_back(APIOrderedArgs[1]);

SubExprs.push_back(APIOrderedArgs[2]);

SubExprs.push_back(APIOrderedArgs[3]);

SubExprs.push_back(APIOrderedArgs[1]);

SubExprs.push_back(APIOrderedArgs[4]);

SubExprs.push_back(APIOrderedArgs[2]);

SubExprs.push_back(APIOrderedArgs[4]);

SubExprs.push_back(APIOrderedArgs[1]);

SubExprs.push_back(APIOrderedArgs[5]);

SubExprs.push_back(APIOrderedArgs[2]);

SubExprs.push_back(APIOrderedArgs[3]);

(SubExprs.size() >= 2 && Form !=

) {

std::optional<llvm::APSInt>

=

SubExprs[1]->getIntegerConstantExpr(

);

(SubExprs[1]->getBeginLoc(),

diag::warn_atomic_op_has_invalid_memory_order)

<<

(Form == C11CmpXchg || Form == GNUCmpXchg)

<< SubExprs[1]->getSourceRange();

(SubExprs.size() >= 5) {

(std::optional<llvm::APSInt> Failure =

SubExprs[3]->getIntegerConstantExpr(

)) {

(!llvm::is_contained(

{llvm::AtomicOrderingCABI::relaxed,

llvm::AtomicOrderingCABI::consume,

llvm::AtomicOrderingCABI::acquire,

llvm::AtomicOrderingCABI::seq_cst},

(llvm::AtomicOrderingCABI)Failure->getSExtValue())) {

(SubExprs[3]->getBeginLoc(),

diag::warn_atomic_op_has_invalid_memory_order)

<<

2 << SubExprs[3]->getSourceRange();

*

= Args[Args.size() - 1];

(std::optional<llvm::APSInt>

=

(!ScopeModel->isValid(

->getZExtValue()))

(

->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)

<<

->getSourceRange();

SubExprs.push_back(

);

((Op == AtomicExpr::AO__c11_atomic_load ||

Op == AtomicExpr::AO__c11_atomic_store ||

Op == AtomicExpr::AO__opencl_atomic_load ||

Op == AtomicExpr::AO__hip_atomic_load ||

Op == AtomicExpr::AO__opencl_atomic_store ||

Op == AtomicExpr::AO__hip_atomic_store) &&

<< ((Op == AtomicExpr::AO__c11_atomic_load ||

Op == AtomicExpr::AO__opencl_atomic_load ||

Op == AtomicExpr::AO__hip_atomic_load)

(Ptr->

(), diag::err_atomic_builtin_bit_int_prohibit);

assert(Fn &&

);

->setArg(ArgIndex, Arg.

());

(TheCall->

(), diag::err_typecheck_call_too_few_args_at_least)

<<

->getSourceRange();

FirstArg = FirstArgResult.

();

TheCall->

(0, FirstArg);

(DRE->

(), diag::err_atomic_builtin_must_be_pointer_intptr)

BuiltinIndices[][5] = {

1: SizeIndex = 0;

;

2: SizeIndex = 1;

;

4: SizeIndex = 2;

;

8: SizeIndex = 3;

;

16: SizeIndex = 4;

;

BuiltinIndex, NumFixed = 1;

WarnAboutSemanticsChange =

;

(BuiltinID) {

: llvm_unreachable(

);

Builtin::BI__sync_fetch_and_add:

Builtin::BI__sync_fetch_and_add_1:

Builtin::BI__sync_fetch_and_add_2:

Builtin::BI__sync_fetch_and_add_4:

Builtin::BI__sync_fetch_and_add_8:

Builtin::BI__sync_fetch_and_add_16:

Builtin::BI__sync_fetch_and_sub:

Builtin::BI__sync_fetch_and_sub_1:

Builtin::BI__sync_fetch_and_sub_2:

Builtin::BI__sync_fetch_and_sub_4:

Builtin::BI__sync_fetch_and_sub_8:

Builtin::BI__sync_fetch_and_sub_16:

Builtin::BI__sync_fetch_and_or:

Builtin::BI__sync_fetch_and_or_1:

Builtin::BI__sync_fetch_and_or_2:

Builtin::BI__sync_fetch_and_or_4:

Builtin::BI__sync_fetch_and_or_8:

Builtin::BI__sync_fetch_and_or_16:

Builtin::BI__sync_fetch_and_and:

Builtin::BI__sync_fetch_and_and_1:

Builtin::BI__sync_fetch_and_and_2:

Builtin::BI__sync_fetch_and_and_4:

Builtin::BI__sync_fetch_and_and_8:

Builtin::BI__sync_fetch_and_and_16:

Builtin::BI__sync_fetch_and_xor:

Builtin::BI__sync_fetch_and_xor_1:

Builtin::BI__sync_fetch_and_xor_2:

Builtin::BI__sync_fetch_and_xor_4:

Builtin::BI__sync_fetch_and_xor_8:

Builtin::BI__sync_fetch_and_xor_16:

Builtin::BI__sync_fetch_and_nand:

Builtin::BI__sync_fetch_and_nand_1:

Builtin::BI__sync_fetch_and_nand_2:

Builtin::BI__sync_fetch_and_nand_4:

Builtin::BI__sync_fetch_and_nand_8:

Builtin::BI__sync_fetch_and_nand_16:

WarnAboutSemanticsChange =

;

Builtin::BI__sync_add_and_fetch:

Builtin::BI__sync_add_and_fetch_1:

Builtin::BI__sync_add_and_fetch_2:

Builtin::BI__sync_add_and_fetch_4:

Builtin::BI__sync_add_and_fetch_8:

Builtin::BI__sync_add_and_fetch_16:

Builtin::BI__sync_sub_and_fetch:

Builtin::BI__sync_sub_and_fetch_1:

Builtin::BI__sync_sub_and_fetch_2:

Builtin::BI__sync_sub_and_fetch_4:

Builtin::BI__sync_sub_and_fetch_8:

Builtin::BI__sync_sub_and_fetch_16:

Builtin::BI__sync_and_and_fetch:

Builtin::BI__sync_and_and_fetch_1:

Builtin::BI__sync_and_and_fetch_2:

Builtin::BI__sync_and_and_fetch_4:

Builtin::BI__sync_and_and_fetch_8:

Builtin::BI__sync_and_and_fetch_16:

Builtin::BI__sync_or_and_fetch:

Builtin::BI__sync_or_and_fetch_1:

Builtin::BI__sync_or_and_fetch_2:

Builtin::BI__sync_or_and_fetch_4:

Builtin::BI__sync_or_and_fetch_8:

Builtin::BI__sync_or_and_fetch_16:

Builtin::BI__sync_xor_and_fetch:

Builtin::BI__sync_xor_and_fetch_1:

Builtin::BI__sync_xor_and_fetch_2:

Builtin::BI__sync_xor_and_fetch_4:

Builtin::BI__sync_xor_and_fetch_8:

Builtin::BI__sync_xor_and_fetch_16:

Builtin::BI__sync_nand_and_fetch:

Builtin::BI__sync_nand_and_fetch_1:

Builtin::BI__sync_nand_and_fetch_2:

Builtin::BI__sync_nand_and_fetch_4:

Builtin::BI__sync_nand_and_fetch_8:

Builtin::BI__sync_nand_and_fetch_16:

WarnAboutSemanticsChange =

;

Builtin::BI__sync_val_compare_and_swap:

Builtin::BI__sync_val_compare_and_swap_1:

Builtin::BI__sync_val_compare_and_swap_2:

Builtin::BI__sync_val_compare_and_swap_4:

Builtin::BI__sync_val_compare_and_swap_8:

Builtin::BI__sync_val_compare_and_swap_16:

Builtin::BI__sync_bool_compare_and_swap:

Builtin::BI__sync_bool_compare_and_swap_1:

Builtin::BI__sync_bool_compare_and_swap_2:

Builtin::BI__sync_bool_compare_and_swap_4:

Builtin::BI__sync_bool_compare_and_swap_8:

Builtin::BI__sync_bool_compare_and_swap_16:

Builtin::BI__sync_lock_test_and_set:

Builtin::BI__sync_lock_test_and_set_1:

Builtin::BI__sync_lock_test_and_set_2:

Builtin::BI__sync_lock_test_and_set_4:

Builtin::BI__sync_lock_test_and_set_8:

Builtin::BI__sync_lock_test_and_set_16:

Builtin::BI__sync_lock_release:

Builtin::BI__sync_lock_release_1:

Builtin::BI__sync_lock_release_2:

Builtin::BI__sync_lock_release_4:

Builtin::BI__sync_lock_release_8:

Builtin::BI__sync_lock_release_16:

Builtin::BI__sync_swap:

Builtin::BI__sync_swap_1:

Builtin::BI__sync_swap_2:

Builtin::BI__sync_swap_4:

Builtin::BI__sync_swap_8:

Builtin::BI__sync_swap_16:

(TheCall->

(), diag::err_typecheck_call_too_few_args_at_least)

<< 0 << 1 + NumFixed << TheCall->

() <<

0

<<

->getSourceRange();

(TheCall->

(), diag::warn_atomic_implicit_seq_cst)

<<

->getSourceRange();

(WarnAboutSemanticsChange) {

(TheCall->

(), diag::warn_sync_fetch_and_nand_semantics_change)

<<

->getSourceRange();

NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];

(NewBuiltinID == BuiltinID)

NewBuiltinDecl = FDecl;

assert(Res.getFoundDecl());

NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());

(!NewBuiltinDecl)

(

i = 0; i != NumFixed; ++i) {

CK_BuiltinFnToFnPtr);

TheCall->

(ResultType);

(BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {

(FirstArg->

(), diag::err_atomic_builtin_ext_int_size);

TheCallResult;

assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||

BuiltinID == Builtin::BI__builtin_nontemporal_load) &&

);

isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;

numArgs = isStore ? 2 : 1;

*PointerArg = TheCall->

(numArgs - 1);

PointerArg = PointerArgResult.

();

TheCall->

(numArgs - 1, PointerArg);

(DRE->

(), diag::err_nontemporal_builtin_must_be_pointer)

diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)

TheCallResult;

TheCallResult;

*

= dyn_cast<StringLiteral>(Arg);

(

*ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {

= ObjcLiteral->getString();

(!Literal || (!

->isOrdinary() && !

->isUTF8())) {

(Arg->

(), diag::err_os_log_format_not_string_constant)

IsX64 = TT.getArch() == llvm::Triple::x86_64;

IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||

TT.getArch() == llvm::Triple::aarch64_32);

IsWindows = TT.isOSWindows();

IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;

(IsX64 || IsAArch64) {

S.

(Fn->getBeginLoc(),

diag::err_ms_va_start_used_in_sysv_function);

S.

(Fn->getBeginLoc(),

diag::err_va_start_used_in_wrong_abi_function)

S.

(Fn->getBeginLoc(), diag::err_builtin_x64_aarch64_only);

IsVariadic =

;

(

*

= dyn_cast<BlockDecl>(Caller)) {

IsVariadic =

->isVariadic();

Params =

->parameters();

}

(

*FD = dyn_cast<FunctionDecl>(Caller)) {

}

(

*MD = dyn_cast<ObjCMethodDecl>(Caller)) {

IsVariadic = MD->isVariadic();

Params = MD->parameters();

}

(isa<CapturedDecl>(Caller)) {

S.

(Fn->getBeginLoc(), diag::err_va_start_captured_stmt);

S.

(Fn->getBeginLoc(), diag::err_va_start_outside_function);

S.

(Fn->getBeginLoc(), diag::err_va_start_fixed_function);

*LastParam = Params.empty() ? nullptr : Params.back();

Sema::BuiltinVAStart(

BuiltinID,

*TheCall) {

SecondArgIsLastNamedArgument =

;

(std::optional<llvm::APSInt> Val =

IsCRegister =

;

(

*DR = dyn_cast<DeclRefExpr>(Arg)) {

(

*PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {

SecondArgIsLastNamedArgument = PV == LastParam;

= PV->getType();

ParamLoc = PV->getLocation();

(!SecondArgIsLastNamedArgument)

diag::warn_second_arg_of_va_start_not_last_named_param);

if (!Context.isPromotableIntegerType(Type))

if (!Type->isEnumeralType())

const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();

Context.typesAreCompatible(ED->getPromotionType(), Type));

Reason = 0;

(IsCRegister) Reason = 2;

(Arg->

(), diag::warn_va_start_type_is_undefined) << Reason;

(ParamLoc, diag::note_parameter_type) <<

;

Sema::BuiltinVAStartARMMicrosoft(

*

) {

IsSuitablyTypedFormatArgument = [

](

*Arg) ->

{

(

->getNumArgs() < 3)

diag::err_typecheck_call_too_few_args_at_least)

<< 0

<< 3 <<

->getNumArgs()

*Arg1 =

->getArg(1)->IgnoreParens();

*Arg2 =

->getArg(2)->IgnoreParens();

(!Arg1Ty->

() || !IsSuitablyTypedFormatArgument(Arg1))

(Arg1->

(), diag::err_typecheck_convert_incompatible)

<< Arg1->

() << ConstCharPtrTy << 1

<< 2 << Arg1->

() << ConstCharPtrTy;

(Arg2->

(), diag::err_typecheck_convert_incompatible)

<< Arg2->

() << SizeTy << 1

<< 3 << Arg2->

() << SizeTy;

Sema::BuiltinUnorderedCompare(

*TheCall,

BuiltinID) {

(BuiltinID == Builtin::BI__builtin_isunordered &&

diag::err_typecheck_call_invalid_ordered_compare)

Sema::BuiltinFPClassification(

*TheCall,

NumArgs,

BuiltinID) {

(FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||

BuiltinID == Builtin::BI__builtin_isinf ||

BuiltinID == Builtin::BI__builtin_isinf_sign))

(FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||

BuiltinID == Builtin::BI__builtin_isunordered))

IsFPClass = NumArgs == 2;

FPArgNo = IsFPClass ? 0 : NumArgs - 1;

(

i = 0; i < FPArgNo; ++i) {

OrigArg = Res.

();

OrigArg = Res.

();

TheCall->

(FPArgNo, OrigArg);

diag::err_typecheck_call_invalid_unary_fp)

(!VectorResultTy.

())

ResultTy = VectorResultTy;

Sema::BuiltinComplex(

*TheCall) {

(

I = 0; I != 2; ++I) {

(Arg->

(), diag::err_typecheck_call_requires_real_fp)

TheCall->

(I, Converted.

());

diag::err_typecheck_call_different_arg_types)

(TheCall->

(), diag::err_invalid_complex_spec)

(TheCall->

(), diag::err_invalid_complex_spec)

diag::err_typecheck_call_too_few_args_at_least)

numElements = 0;

numResElements = TheCall->

() - 2;

diag::err_vec_builtin_incompatible_vector)

diag::err_vec_builtin_incompatible_vector)

}

(numElements != numResElements) {

(

i = 2; i < TheCall->

(); i++) {

std::optional<llvm::APSInt>

;

diag::err_shufflevector_nonconstant_argument)

(

->getActiveBits() > 64 ||

->getZExtValue() >= numElements * 2)

diag::err_shufflevector_argument_too_large)

(

i = 0, e = TheCall->

(); i != e; i++) {

exprs.push_back(TheCall->

(i));

TheCall->

(i,

);

diag::err_convertvector_non_vector)

(

(BuiltinLoc, diag::err_builtin_non_vector_type)

<<

);

(SrcElts != DstElts)

diag::err_convertvector_incompatible_vector)

BuiltinLoc, RParenLoc);

Sema::BuiltinPrefetch(

*TheCall) {

diag::err_typecheck_call_too_many_args_at_most)

<< 0

<< 3 << NumArgs <<

0

(

i = 1; i != NumArgs; ++i)

Sema::BuiltinArithmeticFence(

*TheCall) {

(TheCall->

(), diag::err_builtin_target_unsupported)

(TheCall->

(), diag::err_typecheck_expect_flt_or_vector)

Sema::BuiltinAssume(

*TheCall) {

<< cast<FunctionDecl>(TheCall->

())->getIdentifier();

Sema::BuiltinAllocaWithAlign(

*TheCall) {

(

*UE =

(UE->getKind() == UETT_AlignOf ||

UE->getKind() == UETT_PreferredAlignOf)

(!

.isPowerOf2())

(TheCall->

(), diag::err_alignment_not_power_of_two)

(

> std::numeric_limits<int32_t>::max())

<< std::numeric_limits<int32_t>::max() << Arg->

();

Sema::BuiltinAssumeAligned(

*TheCall) {

(TheCall->

(), diag::err_builtin_assume_aligned_invalid_arg)

TheCall->

(0, FirstArgResult.

());

(!

.isPowerOf2())

(TheCall->

(), diag::err_alignment_not_power_of_two)

TheCall->

(2, ThirdArg);

Sema::BuiltinOSLogFormat(

*TheCall) {

BuiltinID =

cast<FunctionDecl>(TheCall->

())->getBuiltinID();

IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;

NumRequiredArgs = IsSizeCall ? 1 : 2;

(NumArgs < NumRequiredArgs) {

(TheCall->

(), diag::err_typecheck_call_too_few_args)

<< 0

<< NumRequiredArgs << NumArgs

(NumArgs >= NumRequiredArgs + 0x100) {

diag::err_typecheck_call_too_many_args_at_most)

<< 0

<< (NumRequiredArgs + 0xff) << NumArgs

(Arg.isInvalid())

TheCall->

(i, Arg.get());

FormatIdx = i;

FirstDataArg = i;

(i < NumArgs) {

(Arg.

()->

(), diag::err_os_log_argument_too_big)

llvm::SmallBitVector CheckedVarArgs(NumArgs,

);

= CheckFormatArguments(

llvm::APSInt &

) {

std::optional<llvm::APSInt> R;

(TheCall->

(), diag::err_constant_integer_arg_type)

High,

RangeIsError) {

(

.getSExtValue() < Low ||

.getSExtValue() > High) {

(TheCall->

(), diag::err_argument_invalid_range)

(diag::warn_argument_invalid_range)

(TheCall->

(), diag::err_argument_not_multiple)

(TheCall->

(), diag::err_argument_not_power_of_2)

(

.isNegative())

((

& 0xFF) != 0)

.setIsUnsigned(

);

(TheCall->

(), diag::err_argument_not_shifted_byte)

.setIsUnsigned(

);

diag::err_argument_not_shifted_byte_or_xxff)

Sema::BuiltinLongjmp(

*TheCall) {

(TheCall->

(), diag::err_builtin_longjmp_unsupported)

(TheCall->

(), diag::err_builtin_longjmp_invalid_val)

Sema::BuiltinSetjmp(

*TheCall) {

(TheCall->

(), diag::err_builtin_setjmp_unsupported)

Sema::BuiltinCountedByRef(

*TheCall) {

diag::err_builtin_counted_by_ref_must_be_flex_array_member)

diag::err_builtin_counted_by_ref_has_side_effects)

(

*ME = dyn_cast<MemberExpr>(Arg)) {

(!ME->isFlexibleArrayMemberLike(

diag::err_builtin_counted_by_ref_must_be_flex_array_member)

*FAMDecl = cast<FieldDecl>(ME->getMemberDecl());

diag::err_builtin_counted_by_ref_must_be_flex_array_member)

Sema::CheckInvalidBuiltinCountedByRef(

*

,

BuiltinCountedByRefKind K) {

(!CE || CE->

() != Builtin::BI__builtin_counted_by_ref)

AssignmentKind:

InitializerKind:

diag::err_builtin_counted_by_ref_cannot_leak_reference)

FunctionArgKind:

diag::err_builtin_counted_by_ref_cannot_leak_reference)

diag::err_builtin_counted_by_ref_cannot_leak_reference)

ArraySubscriptKind:

(

->

(), diag::err_builtin_counted_by_ref_invalid_use)

BinaryExprKind:

(

->

(), diag::err_builtin_counted_by_ref_invalid_use)

UncoveredArgHandler {

{

= -1, AllCovered = -2 };

FirstUncoveredArg =

;

UncoveredArgHandler() =

;

hasUncoveredArg()

{

(FirstUncoveredArg >= 0);

getUncoveredArg()

{

assert(hasUncoveredArg() &&

);

FirstUncoveredArg;

setAllCovered() {

DiagnosticExprs.clear();

FirstUncoveredArg = AllCovered;

(

NewFirstUncoveredArg,

*StrExpr) {

assert(NewFirstUncoveredArg >= 0 &&

);

(FirstUncoveredArg == AllCovered)

(NewFirstUncoveredArg == FirstUncoveredArg)

DiagnosticExprs.push_back(StrExpr);

(NewFirstUncoveredArg > FirstUncoveredArg) {

DiagnosticExprs.clear();

DiagnosticExprs.push_back(StrExpr);

FirstUncoveredArg = NewFirstUncoveredArg;

Diagnose(

&S,

IsFunctionCall,

*ArgExpr);

StringLiteralCheckType {

SLCT_UncheckedLiteral,

(llvm::APSInt &Offset, llvm::APSInt Addend,

AddendIsRight) {

BitWidth = Offset.getBitWidth();

AddendBitWidth = Addend.getBitWidth();

(Addend.isUnsigned()) {

Addend = Addend.zext(++AddendBitWidth);

Addend.setIsSigned(

);

(AddendBitWidth > BitWidth) {

Offset = Offset.sext(AddendBitWidth);

BitWidth = AddendBitWidth;

}

(BitWidth > AddendBitWidth) {

Addend = Addend.sext(BitWidth);

llvm::APSInt ResOffset = Offset;

(BinOpKind == BO_Add)

ResOffset = Offset.sadd_ov(Addend, Ov);

assert(AddendIsRight && BinOpKind == BO_Sub &&

);

ResOffset = Offset.ssub_ov(Addend, Ov);

assert(BitWidth <= std::numeric_limits<unsigned>::max() / 2 &&

);

Offset = Offset.sext(2 * BitWidth);

(Offset, Addend, BinOpKind, AddendIsRight);

FormatStringLiteral {

FormatStringLiteral(

*fexpr, int64_t Offset = 0)

: FExpr(fexpr), Offset(Offset) {}

StringRef getString()

{

FExpr->

().drop_front(Offset);

getByteLength()

{

FExpr->

() - getCharByteWidth() * Offset;

getLength()

{

FExpr->

() - Offset; }

isAscii()

{

FExpr->

(); }

isWide()

{

FExpr->

(); }

isUTF8()

{

FExpr->

(); }

isUTF16()

{

FExpr->

(); }

isUTF32()

{

FExpr->

(); }

isPascal()

{

FExpr->

(); }

*StartTokenByteOffset =

)

{

StartToken, StartTokenByteOffset);

&S,

FormatStringLiteral *FExpr,

*OrigFormatExpr,

llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,

IgnoreStringsWithoutSpecifiers);

StringLiteralCheckType

llvm::SmallBitVector &CheckedVarArgs,

UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset,

IgnoreStringsWithoutSpecifiers =

) {

SLCT_NotALiteral;

assert(Offset.isSigned() &&

);

SLCT_NotALiteral;

SLCT_UncheckedLiteral;

Stmt::InitListExprClass:

, CallType,

,

CheckedVarArgs, UncoveredArg, Offset,

IgnoreStringsWithoutSpecifiers);

SLCT_NotALiteral;

Stmt::BinaryConditionalOperatorClass:

Stmt::ConditionalOperatorClass: {

cast<AbstractConditionalOperator>(

);

CheckLeft =

, CheckRight =

;

(

->getCond()->EvaluateAsBooleanCondition(

CheckRight =

;

StringLiteralCheckType Left;

Left = SLCT_UncheckedLiteral;

firstDataArg,

, CallType, InFunctionCall,

CheckedVarArgs, UncoveredArg, Offset,

IgnoreStringsWithoutSpecifiers);

(Left == SLCT_NotALiteral || !CheckRight) {

S,

->getFalseExpr(), Args, APK, format_idx, firstDataArg,

,

CallType, InFunctionCall, CheckedVarArgs, UncoveredArg, Offset,

IgnoreStringsWithoutSpecifiers);

(CheckLeft && Left < Right) ? Left : Right;

Stmt::ImplicitCastExprClass:

= cast<ImplicitCastExpr>(

)->getSubExpr();

Stmt::OpaqueValueExprClass:

(

*src = cast<OpaqueValueExpr>(

)->getSourceExpr()) {

SLCT_NotALiteral;

Stmt::PredefinedExprClass:

SLCT_UncheckedLiteral;

Stmt::DeclRefExprClass: {

isConstant =

;

isConstant = AT->getElementType().isConstant(S.

);

isConstant =

.isConstant(S.

) &&

isConstant =

.isConstant(S.

);

(

*

= VD->getAnyInitializer()) {

(InitList->isStringLiteralInit())

= InitList->getInit(0)->IgnoreParenImpCasts();

S,

, Args, APK, format_idx, firstDataArg,

, CallType,

, CheckedVarArgs, UncoveredArg, Offset);

(

*PV = dyn_cast<ParmVarDecl>(VD)) {

(

*

= dyn_cast<Decl>(PV->getDeclContext())) {

IsCXXMember =

;

(

*MD = dyn_cast<CXXMethodDecl>(

))

IsCXXMember = MD->isInstance();

IsVariadic =

;

IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();

(

*BD = dyn_cast<BlockDecl>(

))