- Mark CheckSMEFunctionDefAttributes as static

- Move CheckSMEFunctionDefAttributes call to ActOnStartOfLambdaDefinition

Author: kmclaughlin-arm

clang/include/clang/Sema/SemaARM.h

@@ -79,7 +79,8 @@ class SemaARM : public SemaBase {
   void handleNewAttr(Decl *D, const ParsedAttr &AL);
   void handleCmseNSEntryAttr(Decl *D, const ParsedAttr &AL);
   void handleInterruptAttr(Decl *D, const ParsedAttr &AL);
-  void CheckSMEFunctionDefAttributes(const FunctionDecl *FD);
+
+  static void CheckSMEFunctionDefAttributes(const FunctionDecl *FD, Sema &S);
 };
 
 SemaARM::ArmStreamingType getArmStreamingFnType(const FunctionDecl *FD);

clang/lib/Sema/SemaARM.cpp

@@ -1331,22 +1331,22 @@ void SemaARM::handleInterruptAttr(Decl *D, const ParsedAttr &AL) {
 // Check if the function definition uses any AArch64 SME features without
 // having the '+sme' feature enabled and warn user if sme locally streaming
 // function returns or uses arguments with VL-based types.
-void SemaARM::CheckSMEFunctionDefAttributes(const FunctionDecl *FD) {
+void SemaARM::CheckSMEFunctionDefAttributes(const FunctionDecl *FD, Sema &S) {
   const auto *Attr = FD->getAttr<ArmNewAttr>();
   bool UsesSM = FD->hasAttr<ArmLocallyStreamingAttr>();
   bool UsesZA = Attr && Attr->isNewZA();
   bool UsesZT0 = Attr && Attr->isNewZT0();
 
   if (FD->hasAttr<ArmLocallyStreamingAttr>()) {
     if (FD->getReturnType()->isSizelessVectorType())
-      Diag(FD->getLocation(),
-           diag::warn_sme_locally_streaming_has_vl_args_returns)
+      S.Diag(FD->getLocation(),
+             diag::warn_sme_locally_streaming_has_vl_args_returns)
           << /*IsArg=*/false;
     if (llvm::any_of(FD->parameters(), [](ParmVarDecl *P) {
           return P->getOriginalType()->isSizelessVectorType();
         }))
-      Diag(FD->getLocation(),
-           diag::warn_sme_locally_streaming_has_vl_args_returns)
+      S.Diag(FD->getLocation(),
+             diag::warn_sme_locally_streaming_has_vl_args_returns)
           << /*IsArg=*/true;
   }
   if (const auto *FPT = FD->getType()->getAs<FunctionProtoType>()) {
@@ -1358,25 +1358,25 @@ void SemaARM::CheckSMEFunctionDefAttributes(const FunctionDecl *FD) {
                FunctionType::ARM_None;
   }
 
-  ASTContext &Context = getASTContext();
+  ASTContext &Context = S.getASTContext();
   if (UsesSM || UsesZA) {
     llvm::StringMap<bool> FeatureMap;
     Context.getFunctionFeatureMap(FeatureMap, FD);
     if (!FeatureMap.contains("sme")) {
       if (UsesSM)
-        Diag(FD->getLocation(),
-             diag::err_sme_definition_using_sm_in_non_sme_target);
+        S.Diag(FD->getLocation(),
+               diag::err_sme_definition_using_sm_in_non_sme_target);
       else
-        Diag(FD->getLocation(),
-             diag::err_sme_definition_using_za_in_non_sme_target);
+        S.Diag(FD->getLocation(),
+               diag::err_sme_definition_using_za_in_non_sme_target);
     }
   }
   if (UsesZT0) {
     llvm::StringMap<bool> FeatureMap;
     Context.getFunctionFeatureMap(FeatureMap, FD);
     if (!FeatureMap.contains("sme2")) {
-      Diag(FD->getLocation(),
-           diag::err_sme_definition_using_zt0_in_non_sme2_target);
+      S.Diag(FD->getLocation(),
+             diag::err_sme_definition_using_zt0_in_non_sme2_target);
     }
   }
 }

clang/lib/Sema/SemaDecl.cpp

@@ -12288,7 +12288,7 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
   }
 
   if (DeclIsDefn && Context.getTargetInfo().getTriple().isAArch64())
-    ARM().CheckSMEFunctionDefAttributes(NewFD);
+    SemaARM::CheckSMEFunctionDefAttributes(NewFD, *this);
 
   return Redeclaration;
 }

clang/lib/Sema/SemaDeclCXX.cpp

@@ -41,7 +41,6 @@
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
-#include "clang/Sema/SemaARM.h"
 #include "clang/Sema/SemaCUDA.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaObjC.h"
@@ -1855,9 +1854,6 @@ bool Sema::CheckConstexprFunctionDefinition(const FunctionDecl *NewFD,
     }
   }
 
-  if (Context.getTargetInfo().getTriple().isAArch64())
-    ARM().CheckSMEFunctionDefAttributes(NewFD);
-
   // - each of its parameter types shall be a literal type; (removed in C++23)
   if (!getLangOpts().CPlusPlus23 &&
       !CheckConstexprParameterTypes(*this, NewFD, Kind))

clang/lib/Sema/SemaLambda.cpp

@@ -21,6 +21,7 @@
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/SemaARM.h"
 #include "clang/Sema/SemaCUDA.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaOpenMP.h"
@@ -1454,6 +1455,9 @@ void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
   // Attributes on the lambda apply to the method.
   ProcessDeclAttributes(CurScope, Method, ParamInfo);
 
+  if (Context.getTargetInfo().getTriple().isAArch64())
+    SemaARM::CheckSMEFunctionDefAttributes(Method, *this);
+
   // CUDA lambdas get implicit host and device attributes.
   if (getLangOpts().CUDA)
     CUDA().SetLambdaAttrs(Method);

clang/test/Sema/aarch64-sme-func-attrs-without-target-feature.cpp

@@ -50,7 +50,7 @@ int streaming_decl_ret_int() __arm_streaming;
 int x = streaming_decl_ret_int(); // expected-error {{call to a streaming function requires 'sme'}}
 
 void sme_attrs_lambdas() {
-  [&] __arm_locally_streaming () { return; }();  // expected-error {{function executed in streaming-SVE mode requires 'sme'}}
-  [&] __arm_new("za") () { return; }();  // expected-error {{function using ZA state requires 'sme'}}
-  [&] __arm_new("zt0") () { return; }();  // expected-error {{function using ZT0 state requires 'sme2'}}
+  [] __arm_locally_streaming () { return; }();  // expected-error {{function executed in streaming-SVE mode requires 'sme'}}
+  [] __arm_new("za") () { return; }();  // expected-error {{function using ZA state requires 'sme'}}
+  [] __arm_new("zt0") () { return; }();  // expected-error {{function using ZT0 state requires 'sme2'}}
 }