https://github.com/dtemirbulatov updated https://github.com/llvm/llvm-project/pull/79842
>From af323998a63a72f569d543cf5167d5d28e784682 Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Mon, 29 Jan 2024 14:43:13 +0000 Subject: [PATCH 01/10] [Clang][AArch64] Warn when calling streaming/non-streaming about vector size might be different. The compiler doesn't know in advance if the streaming and non-streaming vector-lengths are different, so it should be safe to give a warning diagnostic to warn the user about possible undefined behaviour. If the user knows the vector lengths are equal, they can disable the warning separately. --- .../clang/Basic/DiagnosticSemaKinds.td | 24 +++++++ clang/lib/Sema/SemaChecking.cpp | 42 ++++++++++++ clang/test/Sema/aarch64-sme-func-attrs.c | 68 ++++++++++++++++++- 3 files changed, 132 insertions(+), 2 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 24d32cb87c89e2..37fea5746936c7 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3717,6 +3717,30 @@ def err_sme_definition_using_za_in_non_sme_target : Error< "function using ZA state requires 'sme'">; def err_sme_definition_using_zt0_in_non_sme2_target : Error< "function using ZT0 state requires 'sme2'">; +def warn_sme_streaming_caller_pass_args_to_non_streaming : Warning< + "streaming caller passes a VL-dependent argument to non-streaming callee, " + "the streaming and non-streaming vector lengths may be different">, + InGroup<IgnoredAttributes>; +def warn_sme_non_streaming_callee_returns_to_streaming : Warning< + "non-streaming callee returns a VL-dependent value to streaming caller, " + "the streaming and non-streaming vector lengths may be different">, + InGroup<IgnoredAttributes>; +def warn_sme_non_streaming_caller_pass_args_to_streaming : Warning< + "non-streaming caller passes a VL-dependent argument to streaming callee, " + "the streaming and non-streaming vector lengths may be different">, + InGroup<IgnoredAttributes>; +def warn_sme_non_streaming_caller_returns_to_streaming : Warning< + "non-streaming callee returns a VL-dependent value to streaming caller, " + "the streaming and non-streaming vector lengths may be different">, + InGroup<IgnoredAttributes>; +def warn_sme_locally_streaming_has_vl_args : Warning< + "non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, " + "the streaming and non-streaming vector lengths may be different">, + InGroup<IgnoredAttributes>; +def warn_sme_locally_streaming_returns_vl : Warning< + "non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, " + "the streaming and non-streaming vector lengths may be different">, + InGroup<IgnoredAttributes>; def err_conflicting_attributes_arm_state : Error< "conflicting attributes for state '%0'">; def err_unknown_arm_state : Error< diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 502b24bcdf8b42..e668a45c69e5f9 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7480,6 +7480,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, // For variadic functions, we may have more args than parameters. // For some K&R functions, we may have less args than parameters. const auto N = std::min<unsigned>(Proto->getNumParams(), Args.size()); + bool AnyScalableArgs = false; for (unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) { // Args[ArgIdx] can be null in malformed code. if (const Expr *Arg = Args[ArgIdx]) { @@ -7493,6 +7494,8 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, checkAIXMemberAlignment((Arg->getExprLoc()), Arg); QualType ParamTy = Proto->getParamType(ArgIdx); + if (ParamTy->isSizelessVectorType()) + AnyScalableArgs = true; QualType ArgTy = Arg->getType(); CheckArgAlignment(Arg->getExprLoc(), FDecl, std::to_string(ArgIdx + 1), ArgTy, ParamTy); @@ -7513,6 +7516,45 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, } } + auto *CallerFD = dyn_cast<FunctionDecl>(CurContext); + if (FD && CallerFD && Context.getTargetInfo().hasFeature("sme") && + !FD->getBuiltinID()) { + // If the callee has an AArch64 SME __arm_locally_streaming attribute + // warn if this function returns VL-based value or pass any such argument, + // the streaming and non-streaming vector lengths may be different. + ArmStreamingType CalleeFnType = getArmStreamingFnType(FD); + ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); + if (FD->hasAttr<ArmLocallyStreamingAttr>() && + CallerFnType != ArmStreaming) { + if (AnyScalableArgs) + Diag(Loc, diag::warn_sme_locally_streaming_has_vl_args); + if (FD->getReturnType()->isSizelessVectorType()) + Diag(Loc, diag::warn_sme_locally_streaming_returns_vl); + } + // If the caller is a non-streaming function and the callee has a + // streaming attribute. If it passed any VL-based arguments or return + // VL-based value, then warn that the streaming and non-streaming vector + // lengths may be different. + if (CallerFnType != ArmStreaming) { + if (CalleeFnType == ArmStreaming) { + if (AnyScalableArgs) + Diag(Loc, + diag::warn_sme_non_streaming_caller_pass_args_to_streaming); + if (FD->getReturnType()->isSizelessVectorType()) + Diag(Loc, diag::warn_sme_non_streaming_caller_returns_to_streaming); + } + } else if (!FD->hasAttr<ArmLocallyStreamingAttr>()) { + // If the callee is a non-streaming function and the caller has + // streaming attribute. If it passed any VL-based arguments or return + // VL-based value, then warn that the streaming and non-streaming vector + // lengths may be different. + if (AnyScalableArgs) + Diag(Loc, diag::warn_sme_streaming_caller_pass_args_to_non_streaming); + if (FD->getReturnType()->isSizelessVectorType()) + Diag(Loc, diag::warn_sme_non_streaming_callee_returns_to_streaming); + } + } + // If the callee uses AArch64 SME ZA state but the caller doesn't define // any, then this is an error. FunctionType::ArmStateValue ArmZAState = diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index 97409ae7d6040c..0a8e6e03a94f29 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -1,5 +1,6 @@ -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -fsyntax-only -verify %s -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -fsyntax-only -verify=expected-cpp -x c++ %s +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +sme -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +sme -fsyntax-only -verify=expected-cpp -x c++ %s +#include <arm_sme.h> // Valid attributes @@ -48,6 +49,9 @@ typedef void (*fptrty6) (void); fptrty6 cast_nza_func_to_normal() { return sme_arm_new_za; } fptrty6 cast_ls_func_to_normal() { return sme_arm_locally_streaming; } +void sme_arm_streaming_with_vl_args(void) __arm_streaming; + + // Invalid attributes // expected-cpp-error@+4 {{'__arm_streaming_compatible' and '__arm_streaming' are not compatible}} @@ -445,3 +449,63 @@ void conflicting_state_attrs_preserves_out_zt0(void) __arm_preserves("zt0") __ar // expected-cpp-error@+2 {{conflicting attributes for state 'zt0'}} // expected-error@+1 {{conflicting attributes for state 'zt0'}} void conflicting_state_attrs_preserves_inout_zt0(void) __arm_preserves("zt0") __arm_inout("zt0"); + +void sme_streaming_with_vl_arg(svint32x4_t a) __arm_streaming { } + +svint32x4_t sme_streaming_returns_vl(void) __arm_streaming { svint32x4_t r; return r; } + +void sme_none_streaming_with_vl_arg(svint32x4_t a) { } + +svint32x4_t sme_none_streaming_returns_vl(void) { svint32x4_t r; return r; } + +__arm_locally_streaming void sme_locally_streaming_with_vl_arg(svint32x4_t a) { } + +__arm_locally_streaming svint32x4_t sme_locally_streaming_returns_vl(void) { svint32x4_t r; return r; } + +void sme_none_streaming_calling_streaming_with_vl_args() { + svint32x4_t a; + // expected-warning@+2 {{non-streaming caller passes a VL-dependent argument to streaming callee, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming caller passes a VL-dependent argument to streaming callee, the streaming and non-streaming vector lengths may be different}} + sme_streaming_with_vl_arg(a); +} + +void sme_none_streaming_calling_streaming_with_return_vl() { + // expected-warning@+2 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} + svint32x4_t r = sme_streaming_returns_vl(); +} + +void sme_streaming_calling_non_streaming_with_vl_args(void) __arm_streaming { + svint32x4_t a; + // expected-warning@+2 {{streaming caller passes a VL-dependent argument to non-streaming callee, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{streaming caller passes a VL-dependent argument to non-streaming callee, the streaming and non-streaming vector lengths may be different}} + sme_none_streaming_with_vl_arg(a); +} + +void sme_streaming_calling_non_streaming_with_return_vl(void) __arm_streaming { + // expected-warning@+2 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} + svint32x4_t r = sme_streaming_returns_vl(); +} + +void sme_streaming_calling_locally_streaming_with_vl_args(void) __arm_streaming { + svint32x4_t a; + // expected-1warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-1cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + sme_locally_streaming_with_vl_arg(a); +} + +void sme_streaming_calling_locally_streaming_with_return_vl(void) __arm_streaming { + // expected-1warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-1cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + svint32x4_t r = sme_locally_streaming_returns_vl(); +} + +void sme_none_streaming_calling_locally_streaming_with_vl_args(void) __arm_streaming { + svint32x4_t a; + sme_locally_streaming_with_vl_arg(a); +} + +void sme_none_streaming_calling_locally_streaming_with_return_vl(void) __arm_streaming { + svint32x4_t r = sme_locally_streaming_returns_vl(); +} >From 470777a7704353fbf81a61a5c2c5572e9928ce61 Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Tue, 30 Jan 2024 08:59:36 +0000 Subject: [PATCH 02/10] Corrected diagnostics, allowed to emit warning even when we call streaming local function from streaming function. --- clang/lib/Sema/SemaChecking.cpp | 3 +-- clang/test/Sema/aarch64-sme-func-attrs.c | 12 ++++++++---- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index e668a45c69e5f9..5f7044cb09f80d 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7524,8 +7524,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, // the streaming and non-streaming vector lengths may be different. ArmStreamingType CalleeFnType = getArmStreamingFnType(FD); ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); - if (FD->hasAttr<ArmLocallyStreamingAttr>() && - CallerFnType != ArmStreaming) { + if (FD->hasAttr<ArmLocallyStreamingAttr>()) { if (AnyScalableArgs) Diag(Loc, diag::warn_sme_locally_streaming_has_vl_args); if (FD->getReturnType()->isSizelessVectorType()) diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index 0a8e6e03a94f29..05a0eead96d213 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -490,22 +490,26 @@ void sme_streaming_calling_non_streaming_with_return_vl(void) __arm_streaming { void sme_streaming_calling_locally_streaming_with_vl_args(void) __arm_streaming { svint32x4_t a; - // expected-1warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-1cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} sme_locally_streaming_with_vl_arg(a); } void sme_streaming_calling_locally_streaming_with_return_vl(void) __arm_streaming { - // expected-1warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-1cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} svint32x4_t r = sme_locally_streaming_returns_vl(); } void sme_none_streaming_calling_locally_streaming_with_vl_args(void) __arm_streaming { svint32x4_t a; + // expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} sme_locally_streaming_with_vl_arg(a); } void sme_none_streaming_calling_locally_streaming_with_return_vl(void) __arm_streaming { + // expected-warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} svint32x4_t r = sme_locally_streaming_returns_vl(); } >From 540a14782fd868d2b63555c2ae614a6b3e95674d Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Thu, 8 Feb 2024 07:44:47 +0000 Subject: [PATCH 03/10] Resolved comments. --- clang/lib/Sema/SemaChecking.cpp | 8 +-- clang/lib/Sema/SemaDecl.cpp | 16 ++++++ .../Sema/aarch64-incompat-sm-builtin-calls.c | 8 +++ clang/test/Sema/aarch64-sme-func-attrs.c | 56 +++++++------------ 4 files changed, 46 insertions(+), 42 deletions(-) diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 5f7044cb09f80d..1414763fc97c1e 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7524,12 +7524,6 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, // the streaming and non-streaming vector lengths may be different. ArmStreamingType CalleeFnType = getArmStreamingFnType(FD); ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); - if (FD->hasAttr<ArmLocallyStreamingAttr>()) { - if (AnyScalableArgs) - Diag(Loc, diag::warn_sme_locally_streaming_has_vl_args); - if (FD->getReturnType()->isSizelessVectorType()) - Diag(Loc, diag::warn_sme_locally_streaming_returns_vl); - } // If the caller is a non-streaming function and the callee has a // streaming attribute. If it passed any VL-based arguments or return // VL-based value, then warn that the streaming and non-streaming vector @@ -7542,7 +7536,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, if (FD->getReturnType()->isSizelessVectorType()) Diag(Loc, diag::warn_sme_non_streaming_caller_returns_to_streaming); } - } else if (!FD->hasAttr<ArmLocallyStreamingAttr>()) { + } else if (CalleeFnType != ArmStreaming) { // If the callee is a non-streaming function and the caller has // streaming attribute. If it passed any VL-based arguments or return // VL-based value, then warn that the streaming and non-streaming vector diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index e725e187fc9ea0..0acb8e82b71e71 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -12236,6 +12236,22 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, bool UsesSM = NewFD->hasAttr<ArmLocallyStreamingAttr>(); bool UsesZA = Attr && Attr->isNewZA(); bool UsesZT0 = Attr && Attr->isNewZT0(); + + if (UsesSM) { + if (NewFD->getReturnType()->isSizelessVectorType()) + Diag(NewFD->getLocation(), diag::warn_sme_locally_streaming_returns_vl); + auto *FPT = NewFD->getType()->castAs<FunctionProtoType>(); + bool AnyScalableArgs = false; + for (QualType T : FPT->param_types()) { + if (T->isSizelessVectorType()) { + AnyScalableArgs = true; + break; + } + } + if (AnyScalableArgs) + Diag(NewFD->getLocation(), + diag::warn_sme_locally_streaming_has_vl_args); + } if (const auto *FPT = NewFD->getType()->getAs<FunctionProtoType>()) { FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); UsesSM |= diff --git a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c index 55c97c73e8b695..83f61523927bc3 100644 --- a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c +++ b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c @@ -33,6 +33,8 @@ svuint32_t incompat_sve_sm(svbool_t pg, svuint32_t a, int16_t b) __arm_streaming return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); } +// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svuint32_t incompat_sve_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); @@ -48,6 +50,8 @@ svuint32_t incompat_sve2_sm(svbool_t pg, svuint32_t a, int64_t b) __arm_streamin return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); } +// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svuint32_t incompat_sve2_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); @@ -68,6 +72,8 @@ svfloat64_t streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) __arm_ return svadd_n_f64_m(pg, a, b); } +// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svfloat64_t locally_streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) { // expected-no-warning return svadd_n_f64_m(pg, a, b); @@ -83,6 +89,8 @@ svint16_t streaming_caller_sve2(svint16_t op1, svint16_t op2) __arm_streaming { return svmul_lane_s16(op1, op2, 0); } +// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svint16_t locally_streaming_caller_sve2(svint16_t op1, svint16_t op2) { // expected-no-warning return svmul_lane_s16(op1, op2, 0); diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index 05a0eead96d213..f54cad2eee967b 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -1,6 +1,5 @@ -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +sme -fsyntax-only -verify %s -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +sme -fsyntax-only -verify=expected-cpp -x c++ %s -#include <arm_sme.h> +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -fsyntax-only -verify=expected-cpp -x c++ %s // Valid attributes @@ -450,20 +449,24 @@ void conflicting_state_attrs_preserves_out_zt0(void) __arm_preserves("zt0") __ar // expected-error@+1 {{conflicting attributes for state 'zt0'}} void conflicting_state_attrs_preserves_inout_zt0(void) __arm_preserves("zt0") __arm_inout("zt0"); -void sme_streaming_with_vl_arg(svint32x4_t a) __arm_streaming { } +void sme_streaming_with_vl_arg(__SVInt8_t a) __arm_streaming { } -svint32x4_t sme_streaming_returns_vl(void) __arm_streaming { svint32x4_t r; return r; } +__SVInt8_t sme_streaming_returns_vl(void) __arm_streaming { __SVInt8_t r; return r; } -void sme_none_streaming_with_vl_arg(svint32x4_t a) { } +void sme_none_streaming_with_vl_arg(__SVInt8_t a) { } -svint32x4_t sme_none_streaming_returns_vl(void) { svint32x4_t r; return r; } +__SVInt8_t sme_none_streaming_returns_vl(void) { __SVInt8_t r; return r; } -__arm_locally_streaming void sme_locally_streaming_with_vl_arg(svint32x4_t a) { } +// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +__arm_locally_streaming void sme_locally_streaming_with_vl_arg(__SVInt8_t a) { } -__arm_locally_streaming svint32x4_t sme_locally_streaming_returns_vl(void) { svint32x4_t r; return r; } +// expected-warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +__arm_locally_streaming __SVInt8_t sme_locally_streaming_returns_vl(void) { __SVInt8_t r; return r; } void sme_none_streaming_calling_streaming_with_vl_args() { - svint32x4_t a; + __SVInt8_t a; // expected-warning@+2 {{non-streaming caller passes a VL-dependent argument to streaming callee, the streaming and non-streaming vector lengths may be different}} // expected-cpp-warning@+1 {{non-streaming caller passes a VL-dependent argument to streaming callee, the streaming and non-streaming vector lengths may be different}} sme_streaming_with_vl_arg(a); @@ -472,11 +475,11 @@ void sme_none_streaming_calling_streaming_with_vl_args() { void sme_none_streaming_calling_streaming_with_return_vl() { // expected-warning@+2 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} - svint32x4_t r = sme_streaming_returns_vl(); + __SVInt8_t r = sme_streaming_returns_vl(); } void sme_streaming_calling_non_streaming_with_vl_args(void) __arm_streaming { - svint32x4_t a; + __SVInt8_t a; // expected-warning@+2 {{streaming caller passes a VL-dependent argument to non-streaming callee, the streaming and non-streaming vector lengths may be different}} // expected-cpp-warning@+1 {{streaming caller passes a VL-dependent argument to non-streaming callee, the streaming and non-streaming vector lengths may be different}} sme_none_streaming_with_vl_arg(a); @@ -485,31 +488,14 @@ void sme_streaming_calling_non_streaming_with_vl_args(void) __arm_streaming { void sme_streaming_calling_non_streaming_with_return_vl(void) __arm_streaming { // expected-warning@+2 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} - svint32x4_t r = sme_streaming_returns_vl(); -} - -void sme_streaming_calling_locally_streaming_with_vl_args(void) __arm_streaming { - svint32x4_t a; - // expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - sme_locally_streaming_with_vl_arg(a); + __SVInt8_t r = sme_none_streaming_returns_vl(); } -void sme_streaming_calling_locally_streaming_with_return_vl(void) __arm_streaming { - // expected-warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - svint32x4_t r = sme_locally_streaming_returns_vl(); -} - -void sme_none_streaming_calling_locally_streaming_with_vl_args(void) __arm_streaming { - svint32x4_t a; - // expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - sme_locally_streaming_with_vl_arg(a); +void sme_streaming_calling_streaming_with_vl_args(void) __arm_streaming { + __SVInt8_t a; + sme_streaming_with_vl_arg(a); } -void sme_none_streaming_calling_locally_streaming_with_return_vl(void) __arm_streaming { - // expected-warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - svint32x4_t r = sme_locally_streaming_returns_vl(); +void sme_streaming_calling_streaming_with_return_vl(void) __arm_streaming { + __SVInt8_t r = sme_streaming_returns_vl(); } >From 790afb23fca64f59f8672d7e6d6bf08bec08c234 Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Thu, 8 Feb 2024 11:37:26 +0000 Subject: [PATCH 04/10] Add new waring group AArch64SMEAttributes. --- clang/include/clang/Basic/DiagnosticGroups.td | 3 +++ clang/include/clang/Basic/DiagnosticSemaKinds.td | 12 ++++++------ 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticGroups.td b/clang/include/clang/Basic/DiagnosticGroups.td index 6765721ae7002c..7f395a657046c0 100644 --- a/clang/include/clang/Basic/DiagnosticGroups.td +++ b/clang/include/clang/Basic/DiagnosticGroups.td @@ -1390,6 +1390,9 @@ def MultiGPU: DiagGroup<"multi-gpu">; // libc and the CRT to be skipped. def AVRRtlibLinkingQuirks : DiagGroup<"avr-rtlib-linking-quirks">; +// A warning group AArch64 related to SME function attribues. +def AArch64SMEAttributes : DiagGroup<"aarch64-sme-attributes">; + // A warning group for things that will change semantics in the future. def FutureCompat : DiagGroup<"future-compat">; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 37fea5746936c7..03611e0c4531ad 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3720,27 +3720,27 @@ def err_sme_definition_using_zt0_in_non_sme2_target : Error< def warn_sme_streaming_caller_pass_args_to_non_streaming : Warning< "streaming caller passes a VL-dependent argument to non-streaming callee, " "the streaming and non-streaming vector lengths may be different">, - InGroup<IgnoredAttributes>; + InGroup<AArch64SMEAttributes>; def warn_sme_non_streaming_callee_returns_to_streaming : Warning< "non-streaming callee returns a VL-dependent value to streaming caller, " "the streaming and non-streaming vector lengths may be different">, - InGroup<IgnoredAttributes>; + InGroup<AArch64SMEAttributes>; def warn_sme_non_streaming_caller_pass_args_to_streaming : Warning< "non-streaming caller passes a VL-dependent argument to streaming callee, " "the streaming and non-streaming vector lengths may be different">, - InGroup<IgnoredAttributes>; + InGroup<AArch64SMEAttributes>; def warn_sme_non_streaming_caller_returns_to_streaming : Warning< "non-streaming callee returns a VL-dependent value to streaming caller, " "the streaming and non-streaming vector lengths may be different">, - InGroup<IgnoredAttributes>; + InGroup<AArch64SMEAttributes>; def warn_sme_locally_streaming_has_vl_args : Warning< "non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, " "the streaming and non-streaming vector lengths may be different">, - InGroup<IgnoredAttributes>; + InGroup<AArch64SMEAttributes>; def warn_sme_locally_streaming_returns_vl : Warning< "non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, " "the streaming and non-streaming vector lengths may be different">, - InGroup<IgnoredAttributes>; + InGroup<AArch64SMEAttributes>; def err_conflicting_attributes_arm_state : Error< "conflicting attributes for state '%0'">; def err_unknown_arm_state : Error< >From 66a37aa710ed6be7c3fd3ff46b6caf2adf688d65 Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Mon, 12 Feb 2024 18:45:38 +0000 Subject: [PATCH 05/10] Resolved comments. --- .../clang/Basic/DiagnosticSemaKinds.td | 28 ++----- clang/lib/Sema/SemaChecking.cpp | 27 +++--- clang/lib/Sema/SemaDecl.cpp | 5 +- .../Sema/aarch64-incompat-sm-builtin-calls.c | 16 ++-- clang/test/Sema/aarch64-sme-func-attrs.c | 83 ++++++++++++++----- 5 files changed, 95 insertions(+), 64 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 03611e0c4531ad..a94692166f6460 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3717,29 +3717,13 @@ def err_sme_definition_using_za_in_non_sme_target : Error< "function using ZA state requires 'sme'">; def err_sme_definition_using_zt0_in_non_sme2_target : Error< "function using ZT0 state requires 'sme2'">; -def warn_sme_streaming_caller_pass_args_to_non_streaming : Warning< - "streaming caller passes a VL-dependent argument to non-streaming callee, " - "the streaming and non-streaming vector lengths may be different">, +def warn_sme_streaming_pass_return_vl_to_non_streaming : Warning< + "passing a VL-dependent argument to/from a function that has a different" + " streaming-mode, is undefined behaviour">, InGroup<AArch64SMEAttributes>; -def warn_sme_non_streaming_callee_returns_to_streaming : Warning< - "non-streaming callee returns a VL-dependent value to streaming caller, " - "the streaming and non-streaming vector lengths may be different">, - InGroup<AArch64SMEAttributes>; -def warn_sme_non_streaming_caller_pass_args_to_streaming : Warning< - "non-streaming caller passes a VL-dependent argument to streaming callee, " - "the streaming and non-streaming vector lengths may be different">, - InGroup<AArch64SMEAttributes>; -def warn_sme_non_streaming_caller_returns_to_streaming : Warning< - "non-streaming callee returns a VL-dependent value to streaming caller, " - "the streaming and non-streaming vector lengths may be different">, - InGroup<AArch64SMEAttributes>; -def warn_sme_locally_streaming_has_vl_args : Warning< - "non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, " - "the streaming and non-streaming vector lengths may be different">, - InGroup<AArch64SMEAttributes>; -def warn_sme_locally_streaming_returns_vl : Warning< - "non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, " - "the streaming and non-streaming vector lengths may be different">, +def warn_sme_locally_streaming_has_vl_args_returns : Warning< + "passing/returning a VL-dependent argument from a function" + " arm_locally_streaming attribute, is undefined behaviour">, InGroup<AArch64SMEAttributes>; def err_conflicting_attributes_arm_state : Error< "conflicting attributes for state '%0'">; diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 1414763fc97c1e..95ac69d9ea90fd 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7517,34 +7517,37 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, } auto *CallerFD = dyn_cast<FunctionDecl>(CurContext); - if (FD && CallerFD && Context.getTargetInfo().hasFeature("sme") && - !FD->getBuiltinID()) { + bool IsCalleeStreaming = ((ExtInfo.AArch64SMEAttributes & + FunctionType::SME_PStateSMEnabledMask) || + (ExtInfo.AArch64SMEAttributes & + FunctionType::SME_PStateSMCompatibleMask)); + bool IsBuiltin = (FD && FD->getBuiltinID()); + + if (CallerFD && Context.getTargetInfo().hasFeature("sme") && !IsBuiltin) { // If the callee has an AArch64 SME __arm_locally_streaming attribute // warn if this function returns VL-based value or pass any such argument, // the streaming and non-streaming vector lengths may be different. - ArmStreamingType CalleeFnType = getArmStreamingFnType(FD); ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); // If the caller is a non-streaming function and the callee has a // streaming attribute. If it passed any VL-based arguments or return // VL-based value, then warn that the streaming and non-streaming vector // lengths may be different. if (CallerFnType != ArmStreaming) { - if (CalleeFnType == ArmStreaming) { + if (IsCalleeStreaming) { if (AnyScalableArgs) - Diag(Loc, - diag::warn_sme_non_streaming_caller_pass_args_to_streaming); - if (FD->getReturnType()->isSizelessVectorType()) - Diag(Loc, diag::warn_sme_non_streaming_caller_returns_to_streaming); + Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); + if (Proto->getReturnType()->isSizelessVectorType()) + Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); } - } else if (CalleeFnType != ArmStreaming) { + } else if (!IsCalleeStreaming) { // If the callee is a non-streaming function and the caller has // streaming attribute. If it passed any VL-based arguments or return // VL-based value, then warn that the streaming and non-streaming vector // lengths may be different. if (AnyScalableArgs) - Diag(Loc, diag::warn_sme_streaming_caller_pass_args_to_non_streaming); - if (FD->getReturnType()->isSizelessVectorType()) - Diag(Loc, diag::warn_sme_non_streaming_callee_returns_to_streaming); + Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); + if (Proto->getReturnType()->isSizelessVectorType()) + Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); } } diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 0acb8e82b71e71..355f464aa8f3f4 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -12239,7 +12239,8 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, if (UsesSM) { if (NewFD->getReturnType()->isSizelessVectorType()) - Diag(NewFD->getLocation(), diag::warn_sme_locally_streaming_returns_vl); + Diag(NewFD->getLocation(), + diag::warn_sme_locally_streaming_has_vl_args_returns); auto *FPT = NewFD->getType()->castAs<FunctionProtoType>(); bool AnyScalableArgs = false; for (QualType T : FPT->param_types()) { @@ -12250,7 +12251,7 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, } if (AnyScalableArgs) Diag(NewFD->getLocation(), - diag::warn_sme_locally_streaming_has_vl_args); + diag::warn_sme_locally_streaming_has_vl_args_returns); } if (const auto *FPT = NewFD->getType()->getAs<FunctionProtoType>()) { FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); diff --git a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c index 83f61523927bc3..6002e9f25e2736 100644 --- a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c +++ b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c @@ -33,8 +33,8 @@ svuint32_t incompat_sve_sm(svbool_t pg, svuint32_t a, int16_t b) __arm_streaming return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); } -// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} __arm_locally_streaming svuint32_t incompat_sve_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); @@ -50,8 +50,8 @@ svuint32_t incompat_sve2_sm(svbool_t pg, svuint32_t a, int64_t b) __arm_streamin return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); } -// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} __arm_locally_streaming svuint32_t incompat_sve2_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); @@ -72,8 +72,8 @@ svfloat64_t streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) __arm_ return svadd_n_f64_m(pg, a, b); } -// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} __arm_locally_streaming svfloat64_t locally_streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) { // expected-no-warning return svadd_n_f64_m(pg, a, b); @@ -89,8 +89,8 @@ svint16_t streaming_caller_sve2(svint16_t op1, svint16_t op2) __arm_streaming { return svmul_lane_s16(op1, op2, 0); } -// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} __arm_locally_streaming svint16_t locally_streaming_caller_sve2(svint16_t op1, svint16_t op2) { // expected-no-warning return svmul_lane_s16(op1, op2, 0); diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index f54cad2eee967b..83c5776b93d170 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -453,49 +453,92 @@ void sme_streaming_with_vl_arg(__SVInt8_t a) __arm_streaming { } __SVInt8_t sme_streaming_returns_vl(void) __arm_streaming { __SVInt8_t r; return r; } -void sme_none_streaming_with_vl_arg(__SVInt8_t a) { } +void sme_streaming_compatible_with_vl_arg(__SVInt8_t a) __arm_streaming_compatible { } -__SVInt8_t sme_none_streaming_returns_vl(void) { __SVInt8_t r; return r; } +__SVInt8_t sme_streaming_compatible_returns_vl(void) __arm_streaming_compatible { __SVInt8_t r; return r; } -// expected-warning@+2 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee receives a VL-dependent argument and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +void sme_no_streaming_with_vl_arg(__SVInt8_t a) { } + +__SVInt8_t sme_no_streaming_returns_vl(void) { __SVInt8_t r; return r; } + +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} __arm_locally_streaming void sme_locally_streaming_with_vl_arg(__SVInt8_t a) { } -// expected-warning@+2 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value and the callee has an arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} __arm_locally_streaming __SVInt8_t sme_locally_streaming_returns_vl(void) { __SVInt8_t r; return r; } -void sme_none_streaming_calling_streaming_with_vl_args() { +void sme_no_streaming_calling_streaming_with_vl_args() { __SVInt8_t a; - // expected-warning@+2 {{non-streaming caller passes a VL-dependent argument to streaming callee, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming caller passes a VL-dependent argument to streaming callee, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} sme_streaming_with_vl_arg(a); } -void sme_none_streaming_calling_streaming_with_return_vl() { - // expected-warning@+2 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} +void sme_no_streaming_calling_streaming_with_return_vl() { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} __SVInt8_t r = sme_streaming_returns_vl(); } void sme_streaming_calling_non_streaming_with_vl_args(void) __arm_streaming { __SVInt8_t a; - // expected-warning@+2 {{streaming caller passes a VL-dependent argument to non-streaming callee, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{streaming caller passes a VL-dependent argument to non-streaming callee, the streaming and non-streaming vector lengths may be different}} - sme_none_streaming_with_vl_arg(a); + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + sme_no_streaming_with_vl_arg(a); } void sme_streaming_calling_non_streaming_with_return_vl(void) __arm_streaming { - // expected-warning@+2 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{non-streaming callee returns a VL-dependent value to streaming caller, the streaming and non-streaming vector lengths may be different}} - __SVInt8_t r = sme_none_streaming_returns_vl(); + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + __SVInt8_t r = sme_no_streaming_returns_vl(); } -void sme_streaming_calling_streaming_with_vl_args(void) __arm_streaming { - __SVInt8_t a; +void sme_no_streaming_calling_streaming(__SVInt8_t arg, void (*sc)( __SVInt8_t arg) __arm_streaming) { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + sc(arg); +} + +__SVInt8_t sme_no_streaming_calling_streaming_return_vl(__SVInt8_t (*sc)(void) __arm_streaming) { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + return sc(); +} + +void sme_streaming_compatible_calling_streaming(__SVInt8_t arg) __arm_streaming_compatible { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + sme_streaming_with_vl_arg(arg); +} + +void sme_streaming_compatible_sme_streaming_compatible_return_vl(void) __arm_streaming_compatible { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + __SVInt8_t r = sme_streaming_returns_vl(); +} + +void sme_streaming_calling_streaming(__SVInt8_t arg, void (*sc)( __SVInt8_t arg) __arm_streaming) __arm_streaming { + sc(arg); +} + +__SVInt8_t sme_streaming_calling_streaming_return_vl(__SVInt8_t (*sc)(void) __arm_streaming) __arm_streaming { + return sc(); +} + +void sme_streaming_calling_streaming_with_vl_args(__SVInt8_t a) __arm_streaming { sme_streaming_with_vl_arg(a); } void sme_streaming_calling_streaming_with_return_vl(void) __arm_streaming { __SVInt8_t r = sme_streaming_returns_vl(); } + +void sme_streaming_calling_streaming_compatible_with_vl_args(__SVInt8_t a) __arm_streaming { + sme_streaming_compatible_with_vl_arg(a); +} + +void sme_streaming_calling_streaming_compatible_with_return_vl(void) __arm_streaming { + __SVInt8_t r = sme_streaming_compatible_returns_vl(); +} >From 1827ad66a1e4d40542d3a22dc3eb981a6ad1cd2a Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Thu, 15 Feb 2024 11:51:54 +0000 Subject: [PATCH 06/10] Resolve comments. --- .../clang/Basic/DiagnosticSemaKinds.td | 6 +- clang/lib/Sema/SemaChecking.cpp | 49 +++++----- clang/lib/Sema/SemaDecl.cpp | 16 +--- .../Sema/aarch64-incompat-sm-builtin-calls.c | 12 +-- clang/test/Sema/aarch64-sme-func-attrs.c | 96 +++++++++++++------ 5 files changed, 101 insertions(+), 78 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index a94692166f6460..b60b5a6d379bc7 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3719,11 +3719,13 @@ def err_sme_definition_using_zt0_in_non_sme2_target : Error< "function using ZT0 state requires 'sme2'">; def warn_sme_streaming_pass_return_vl_to_non_streaming : Warning< "passing a VL-dependent argument to/from a function that has a different" - " streaming-mode, is undefined behaviour">, + " streaming-mode, the streaming and non-streaming vector lengths may be" + " different">, InGroup<AArch64SMEAttributes>; def warn_sme_locally_streaming_has_vl_args_returns : Warning< "passing/returning a VL-dependent argument from a function" - " arm_locally_streaming attribute, is undefined behaviour">, + " arm_locally_streaming attribute, the streaming and non-streaming vector" + " lengths may be different">, InGroup<AArch64SMEAttributes>; def err_conflicting_attributes_arm_state : Error< "conflicting attributes for state '%0'">; diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 95ac69d9ea90fd..7b501fc1f289bc 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7480,7 +7480,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, // For variadic functions, we may have more args than parameters. // For some K&R functions, we may have less args than parameters. const auto N = std::min<unsigned>(Proto->getNumParams(), Args.size()); - bool AnyScalableArgs = false; + bool AnyScalableArgsOrRet = false; for (unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) { // Args[ArgIdx] can be null in malformed code. if (const Expr *Arg = Args[ArgIdx]) { @@ -7495,7 +7495,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, QualType ParamTy = Proto->getParamType(ArgIdx); if (ParamTy->isSizelessVectorType()) - AnyScalableArgs = true; + AnyScalableArgsOrRet = true; QualType ArgTy = Arg->getType(); CheckArgAlignment(Arg->getExprLoc(), FDecl, std::to_string(ArgIdx + 1), ArgTy, ParamTy); @@ -7517,36 +7517,31 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, } auto *CallerFD = dyn_cast<FunctionDecl>(CurContext); - bool IsCalleeStreaming = ((ExtInfo.AArch64SMEAttributes & - FunctionType::SME_PStateSMEnabledMask) || - (ExtInfo.AArch64SMEAttributes & - FunctionType::SME_PStateSMCompatibleMask)); + bool IsCalleeStreaming = + (ExtInfo.AArch64SMEAttributes & FunctionType::SME_PStateSMEnabledMask); + bool IsCalleeStreamingCompatible = + (ExtInfo.AArch64SMEAttributes & + FunctionType::SME_PStateSMCompatibleMask); bool IsBuiltin = (FD && FD->getBuiltinID()); + AnyScalableArgsOrRet |= Proto->getReturnType()->isSizelessVectorType(); + // If the caller is a function and the callee has a different + // non-compitable streaming attribute. If it passed any VL-based arguments + // or return VL-based value, then warn that the streaming and non-streaming + // vector lengths may be different. if (CallerFD && Context.getTargetInfo().hasFeature("sme") && !IsBuiltin) { - // If the callee has an AArch64 SME __arm_locally_streaming attribute - // warn if this function returns VL-based value or pass any such argument, - // the streaming and non-streaming vector lengths may be different. ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); - // If the caller is a non-streaming function and the callee has a - // streaming attribute. If it passed any VL-based arguments or return - // VL-based value, then warn that the streaming and non-streaming vector - // lengths may be different. - if (CallerFnType != ArmStreaming) { - if (IsCalleeStreaming) { - if (AnyScalableArgs) - Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); - if (Proto->getReturnType()->isSizelessVectorType()) - Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); - } - } else if (!IsCalleeStreaming) { - // If the callee is a non-streaming function and the caller has - // streaming attribute. If it passed any VL-based arguments or return - // VL-based value, then warn that the streaming and non-streaming vector - // lengths may be different. - if (AnyScalableArgs) + if (CallerFnType != ArmStreaming && + CallerFnType != ArmStreamingCompatible) { + if (IsCalleeStreaming && AnyScalableArgsOrRet) + Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); + } else if (CallerFnType == ArmStreaming && !IsCalleeStreaming && + !IsCalleeStreamingCompatible) { + if (AnyScalableArgsOrRet) Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); - if (Proto->getReturnType()->isSizelessVectorType()) + } else if (CallerFnType == ArmStreamingCompatible) { + if ((IsCalleeStreaming || !IsCalleeStreamingCompatible) && + AnyScalableArgsOrRet) Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); } } diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 355f464aa8f3f4..411616ff715544 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -12238,18 +12238,10 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, bool UsesZT0 = Attr && Attr->isNewZT0(); if (UsesSM) { - if (NewFD->getReturnType()->isSizelessVectorType()) - Diag(NewFD->getLocation(), - diag::warn_sme_locally_streaming_has_vl_args_returns); - auto *FPT = NewFD->getType()->castAs<FunctionProtoType>(); - bool AnyScalableArgs = false; - for (QualType T : FPT->param_types()) { - if (T->isSizelessVectorType()) { - AnyScalableArgs = true; - break; - } - } - if (AnyScalableArgs) + if (NewFD->getReturnType()->isSizelessVectorType() || + llvm::any_of(NewFD->parameters(), [](ParmVarDecl *P) { + return P->getOriginalType()->isSizelessVectorType(); + })) Diag(NewFD->getLocation(), diag::warn_sme_locally_streaming_has_vl_args_returns); } diff --git a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c index 6002e9f25e2736..52ca11b3147c9c 100644 --- a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c +++ b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c @@ -33,8 +33,7 @@ svuint32_t incompat_sve_sm(svbool_t pg, svuint32_t a, int16_t b) __arm_streaming return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svuint32_t incompat_sve_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); @@ -50,8 +49,7 @@ svuint32_t incompat_sve2_sm(svbool_t pg, svuint32_t a, int64_t b) __arm_streamin return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svuint32_t incompat_sve2_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); @@ -72,8 +70,7 @@ svfloat64_t streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) __arm_ return svadd_n_f64_m(pg, a, b); } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svfloat64_t locally_streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) { // expected-no-warning return svadd_n_f64_m(pg, a, b); @@ -89,8 +86,7 @@ svint16_t streaming_caller_sve2(svint16_t op1, svint16_t op2) __arm_streaming { return svmul_lane_s16(op1, op2, 0); } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svint16_t locally_streaming_caller_sve2(svint16_t op1, svint16_t op2) { // expected-no-warning return svmul_lane_s16(op1, op2, 0); diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index 83c5776b93d170..88529fe7ef969d 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -461,70 +461,82 @@ void sme_no_streaming_with_vl_arg(__SVInt8_t a) { } __SVInt8_t sme_no_streaming_returns_vl(void) { __SVInt8_t r; return r; } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} -// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming void sme_locally_streaming_with_vl_arg(__SVInt8_t a) { } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} -// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, is undefined behaviour}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} __arm_locally_streaming __SVInt8_t sme_locally_streaming_returns_vl(void) { __SVInt8_t r; return r; } void sme_no_streaming_calling_streaming_with_vl_args() { __SVInt8_t a; - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} sme_streaming_with_vl_arg(a); } void sme_no_streaming_calling_streaming_with_return_vl() { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_streaming_returns_vl(); } void sme_streaming_calling_non_streaming_with_vl_args(void) __arm_streaming { __SVInt8_t a; - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} sme_no_streaming_with_vl_arg(a); } void sme_streaming_calling_non_streaming_with_return_vl(void) __arm_streaming { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_no_streaming_returns_vl(); } -void sme_no_streaming_calling_streaming(__SVInt8_t arg, void (*sc)( __SVInt8_t arg) __arm_streaming) { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} +void sme_no_streaming_calling_streaming_with_vl_args_param(__SVInt8_t arg, void (*sc)( __SVInt8_t arg) __arm_streaming) { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} sc(arg); } -__SVInt8_t sme_no_streaming_calling_streaming_return_vl(__SVInt8_t (*sc)(void) __arm_streaming) { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - return sc(); +__SVInt8_t sme_no_streaming_calling_streaming_return_vl_param(__SVInt8_t (*s)(void) __arm_streaming) { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + return s(); } -void sme_streaming_compatible_calling_streaming(__SVInt8_t arg) __arm_streaming_compatible { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} +void sme_streaming_compatible_calling_streaming_with_vl_args(__SVInt8_t arg) __arm_streaming_compatible { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} sme_streaming_with_vl_arg(arg); } -void sme_streaming_compatible_sme_streaming_compatible_return_vl(void) __arm_streaming_compatible { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, is undefined behaviour}} +void sme_streaming_compatible_calling_sme_streaming_return_vl(void) __arm_streaming_compatible { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_streaming_returns_vl(); } -void sme_streaming_calling_streaming(__SVInt8_t arg, void (*sc)( __SVInt8_t arg) __arm_streaming) __arm_streaming { - sc(arg); +void sme_streaming_compatible_calling_no_streaming_with_vl_args(__SVInt8_t arg) __arm_streaming_compatible { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + sme_no_streaming_with_vl_arg(arg); +} + +void sme_streaming_compatible_calling_no_sme_streaming_return_vl(void) __arm_streaming_compatible { + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + __SVInt8_t r = sme_no_streaming_returns_vl(); } -__SVInt8_t sme_streaming_calling_streaming_return_vl(__SVInt8_t (*sc)(void) __arm_streaming) __arm_streaming { - return sc(); +void sme_streaming_calling_streaming(__SVInt8_t arg, void (*s)( __SVInt8_t arg) __arm_streaming) __arm_streaming { + s(arg); +} + +__SVInt8_t sme_streaming_calling_streaming_return_vl(__SVInt8_t (*s)(void) __arm_streaming) __arm_streaming { + return s(); } void sme_streaming_calling_streaming_with_vl_args(__SVInt8_t a) __arm_streaming { @@ -542,3 +554,29 @@ void sme_streaming_calling_streaming_compatible_with_vl_args(__SVInt8_t a) __arm void sme_streaming_calling_streaming_compatible_with_return_vl(void) __arm_streaming { __SVInt8_t r = sme_streaming_compatible_returns_vl(); } + +void sme_no_streaming_calling_streaming_compatible_with_vl_args() { + __SVInt8_t a; + sme_streaming_compatible_with_vl_arg(a); +} + +void sme_no_streaming_calling_streaming_compatible_with_return_vl() { + __SVInt8_t r = sme_streaming_compatible_returns_vl(); +} + +void sme_no_streaming_calling_non_streaming_compatible_with_vl_args() { + __SVInt8_t a; + sme_no_streaming_with_vl_arg(a); +} + +void sme_no_streaming_calling_non_streaming_compatible_with_return_vl() { + __SVInt8_t r = sme_no_streaming_returns_vl(); +} + +void sme_streaming_compatible_calling_streaming_compatible_with_vl_args(__SVInt8_t arg) __arm_streaming_compatible { + sme_streaming_compatible_with_vl_arg(arg); +} + +void sme_streaming_compatible_calling_streaming_compatible_with_return_vl(void) __arm_streaming_compatible { + __SVInt8_t r = sme_streaming_compatible_returns_vl(); +} >From e2a82ee38fab05ca12c416f3d37d2fad275a069a Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Thu, 15 Feb 2024 12:16:31 +0000 Subject: [PATCH 07/10] Updated comment in clang/lib/Sema/SemaDecl.cpp --- clang/lib/Sema/SemaDecl.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 411616ff715544..55152f3aca7f07 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -12230,7 +12230,8 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, } // Check if the function definition uses any AArch64 SME features without - // having the '+sme' feature enabled. + // having the '+sme' feature enabled and warn user if sme locally streaming + // function returns or uses arguments with VL-based types. if (DeclIsDefn) { const auto *Attr = NewFD->getAttr<ArmNewAttr>(); bool UsesSM = NewFD->hasAttr<ArmLocallyStreamingAttr>(); >From 3c5df4f66bbf4ef7584545cc91e45d679344315b Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Mon, 4 Mar 2024 13:36:26 +0000 Subject: [PATCH 08/10] Resolve comments. --- .../clang/Basic/DiagnosticSemaKinds.td | 4 +- clang/lib/Sema/SemaChecking.cpp | 22 ++++----- clang/lib/Sema/SemaDecl.cpp | 2 +- .../Sema/aarch64-incompat-sm-builtin-calls.c | 8 ++-- clang/test/Sema/aarch64-sme-func-attrs.c | 48 +++++++++---------- 5 files changed, 40 insertions(+), 44 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index b60b5a6d379bc7..b93c004157a403 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3719,12 +3719,12 @@ def err_sme_definition_using_zt0_in_non_sme2_target : Error< "function using ZT0 state requires 'sme2'">; def warn_sme_streaming_pass_return_vl_to_non_streaming : Warning< "passing a VL-dependent argument to/from a function that has a different" - " streaming-mode, the streaming and non-streaming vector lengths may be" + " streaming-mode. The streaming and non-streaming vector lengths may be" " different">, InGroup<AArch64SMEAttributes>; def warn_sme_locally_streaming_has_vl_args_returns : Warning< "passing/returning a VL-dependent argument from a function" - " arm_locally_streaming attribute, the streaming and non-streaming vector" + " arm_locally_streaming attribute. The streaming and non-streaming vector" " lengths may be different">, InGroup<AArch64SMEAttributes>; def err_conflicting_attributes_arm_state : Error< diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 7b501fc1f289bc..b41db76a2057bf 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7531,19 +7531,15 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, // vector lengths may be different. if (CallerFD && Context.getTargetInfo().hasFeature("sme") && !IsBuiltin) { ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); - if (CallerFnType != ArmStreaming && - CallerFnType != ArmStreamingCompatible) { - if (IsCalleeStreaming && AnyScalableArgsOrRet) - Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); - } else if (CallerFnType == ArmStreaming && !IsCalleeStreaming && - !IsCalleeStreamingCompatible) { - if (AnyScalableArgsOrRet) - Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); - } else if (CallerFnType == ArmStreamingCompatible) { - if ((IsCalleeStreaming || !IsCalleeStreamingCompatible) && - AnyScalableArgsOrRet) - Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); - } + if ((CallerFnType != ArmStreaming && + CallerFnType != ArmStreamingCompatible && IsCalleeStreaming && + AnyScalableArgsOrRet) || + (CallerFnType == ArmStreaming && !IsCalleeStreaming && + !IsCalleeStreamingCompatible && AnyScalableArgsOrRet) || + (CallerFnType == ArmStreamingCompatible && + (IsCalleeStreaming || !IsCalleeStreamingCompatible) && + AnyScalableArgsOrRet)) + Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); } // If the callee uses AArch64 SME ZA state but the caller doesn't define diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 55152f3aca7f07..c19922d3b19561 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -12238,7 +12238,7 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, bool UsesZA = Attr && Attr->isNewZA(); bool UsesZT0 = Attr && Attr->isNewZT0(); - if (UsesSM) { + if (NewFD->hasAttr<ArmLocallyStreamingAttr>()) { if (NewFD->getReturnType()->isSizelessVectorType() || llvm::any_of(NewFD->parameters(), [](ParmVarDecl *P) { return P->getOriginalType()->isSizelessVectorType(); diff --git a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c index 52ca11b3147c9c..663813dfc7d930 100644 --- a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c +++ b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c @@ -33,7 +33,7 @@ svuint32_t incompat_sve_sm(svbool_t pg, svuint32_t a, int16_t b) __arm_streaming return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); } -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svuint32_t incompat_sve_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svld1_gather_u32base_index_u32(pg, a, b); @@ -49,7 +49,7 @@ svuint32_t incompat_sve2_sm(svbool_t pg, svuint32_t a, int64_t b) __arm_streamin return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); } -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svuint32_t incompat_sve2_ls(svbool_t pg, svuint32_t a, int64_t b) { // expected-warning@+1 {{builtin call has undefined behaviour when called from a streaming function}} return __builtin_sve_svldnt1_gather_u32base_index_u32(pg, a, b); @@ -70,7 +70,7 @@ svfloat64_t streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) __arm_ return svadd_n_f64_m(pg, a, b); } -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svfloat64_t locally_streaming_caller_sve(svbool_t pg, svfloat64_t a, float64_t b) { // expected-no-warning return svadd_n_f64_m(pg, a, b); @@ -86,7 +86,7 @@ svint16_t streaming_caller_sve2(svint16_t op1, svint16_t op2) __arm_streaming { return svmul_lane_s16(op1, op2, 0); } -// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} __arm_locally_streaming svint16_t locally_streaming_caller_sve2(svint16_t op1, svint16_t op2) { // expected-no-warning return svmul_lane_s16(op1, op2, 0); diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index 88529fe7ef969d..6f74ac5090ff90 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -461,73 +461,73 @@ void sme_no_streaming_with_vl_arg(__SVInt8_t a) { } __SVInt8_t sme_no_streaming_returns_vl(void) { __SVInt8_t r; return r; } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} +// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} __arm_locally_streaming void sme_locally_streaming_with_vl_arg(__SVInt8_t a) { } -// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} -// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute, the streaming and non-streaming vector lengths may be different}} +// expected-warning@+2 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} +// expected-cpp-warning@+1 {{passing/returning a VL-dependent argument from a function arm_locally_streaming attribute. The streaming and non-streaming vector lengths may be different}} __arm_locally_streaming __SVInt8_t sme_locally_streaming_returns_vl(void) { __SVInt8_t r; return r; } void sme_no_streaming_calling_streaming_with_vl_args() { __SVInt8_t a; - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} sme_streaming_with_vl_arg(a); } void sme_no_streaming_calling_streaming_with_return_vl() { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_streaming_returns_vl(); } void sme_streaming_calling_non_streaming_with_vl_args(void) __arm_streaming { __SVInt8_t a; - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} sme_no_streaming_with_vl_arg(a); } void sme_streaming_calling_non_streaming_with_return_vl(void) __arm_streaming { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_no_streaming_returns_vl(); } void sme_no_streaming_calling_streaming_with_vl_args_param(__SVInt8_t arg, void (*sc)( __SVInt8_t arg) __arm_streaming) { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} sc(arg); } __SVInt8_t sme_no_streaming_calling_streaming_return_vl_param(__SVInt8_t (*s)(void) __arm_streaming) { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} return s(); } void sme_streaming_compatible_calling_streaming_with_vl_args(__SVInt8_t arg) __arm_streaming_compatible { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} sme_streaming_with_vl_arg(arg); } void sme_streaming_compatible_calling_sme_streaming_return_vl(void) __arm_streaming_compatible { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_streaming_returns_vl(); } void sme_streaming_compatible_calling_no_streaming_with_vl_args(__SVInt8_t arg) __arm_streaming_compatible { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} sme_no_streaming_with_vl_arg(arg); } void sme_streaming_compatible_calling_no_sme_streaming_return_vl(void) __arm_streaming_compatible { - // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} - // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode, the streaming and non-streaming vector lengths may be different}} + // expected-warning@+2 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} + // expected-cpp-warning@+1 {{passing a VL-dependent argument to/from a function that has a different streaming-mode. The streaming and non-streaming vector lengths may be different}} __SVInt8_t r = sme_no_streaming_returns_vl(); } >From 63d42892b01c1ed5cdf0ec1ffd17e09bbf9a925c Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Wed, 13 Mar 2024 16:52:08 +0000 Subject: [PATCH 09/10] Resolve remaining comments. --- clang/lib/Sema/SemaChecking.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index b41db76a2057bf..e7f1595ef96c48 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -7529,16 +7529,14 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, // non-compitable streaming attribute. If it passed any VL-based arguments // or return VL-based value, then warn that the streaming and non-streaming // vector lengths may be different. - if (CallerFD && Context.getTargetInfo().hasFeature("sme") && !IsBuiltin) { + if (CallerFD && !IsBuiltin && AnyScalableArgsOrRet) { ArmStreamingType CallerFnType = getArmStreamingFnType(CallerFD); if ((CallerFnType != ArmStreaming && - CallerFnType != ArmStreamingCompatible && IsCalleeStreaming && - AnyScalableArgsOrRet) || + CallerFnType != ArmStreamingCompatible && IsCalleeStreaming) || (CallerFnType == ArmStreaming && !IsCalleeStreaming && - !IsCalleeStreamingCompatible && AnyScalableArgsOrRet) || + !IsCalleeStreamingCompatible) || (CallerFnType == ArmStreamingCompatible && - (IsCalleeStreaming || !IsCalleeStreamingCompatible) && - AnyScalableArgsOrRet)) + (IsCalleeStreaming || !IsCalleeStreamingCompatible))) Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming); } >From 552ab6bc4df2eefd8d8282bf732e528f90f9285f Mon Sep 17 00:00:00 2001 From: Dinar Temirbulatov <dinar.temirbula...@arm.com> Date: Fri, 15 Mar 2024 11:35:13 +0000 Subject: [PATCH 10/10] Change all AArch64SMEAttributes warnings off by default. --- clang/include/clang/Basic/DiagnosticSemaKinds.td | 4 ++-- clang/test/Sema/aarch64-incompat-sm-builtin-calls.c | 2 +- clang/test/Sema/aarch64-sme-func-attrs.c | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index b93c004157a403..caff93424c34d9 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3721,12 +3721,12 @@ def warn_sme_streaming_pass_return_vl_to_non_streaming : Warning< "passing a VL-dependent argument to/from a function that has a different" " streaming-mode. The streaming and non-streaming vector lengths may be" " different">, - InGroup<AArch64SMEAttributes>; + InGroup<AArch64SMEAttributes>, DefaultIgnore; def warn_sme_locally_streaming_has_vl_args_returns : Warning< "passing/returning a VL-dependent argument from a function" " arm_locally_streaming attribute. The streaming and non-streaming vector" " lengths may be different">, - InGroup<AArch64SMEAttributes>; + InGroup<AArch64SMEAttributes>, DefaultIgnore; def err_conflicting_attributes_arm_state : Error< "conflicting attributes for state '%0'">; def err_unknown_arm_state : Error< diff --git a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c index 663813dfc7d930..ad52b983a135cd 100644 --- a/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c +++ b/clang/test/Sema/aarch64-incompat-sm-builtin-calls.c @@ -1,6 +1,6 @@ // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \ -// RUN: -target-feature +sme2 -target-feature +sve2 -target-feature +neon -fsyntax-only -verify %s +// RUN: -target-feature +sme2 -target-feature +sve2 -target-feature +neon -Waarch64-sme-attributes -fsyntax-only -verify %s // REQUIRES: aarch64-registered-target diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c index 6f74ac5090ff90..a2d099f80608cb 100644 --- a/clang/test/Sema/aarch64-sme-func-attrs.c +++ b/clang/test/Sema/aarch64-sme-func-attrs.c @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -fsyntax-only -verify %s -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -fsyntax-only -verify=expected-cpp -x c++ %s +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -Waarch64-sme-attributes -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -Waarch64-sme-attributes -fsyntax-only -verify=expected-cpp -x c++ %s // Valid attributes _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits