Address review comments

Author: sdesmalen-arm

clang/include/clang/AST/Type.h

@@ -4598,7 +4598,7 @@ class FunctionType : public Type {
     SME_AgnosticZAStateMask = 1 << SME_AgnosticZAStateShift,
 
     SME_AttributeMask =
-        0b1'111'111'11 // We can't support more than 16 bits because of
+        0b1'111'111'11 // We can't support more than 9 bits because of
                        // the bitmask in FunctionTypeArmAttributes
                        // and ExtProtoInfo.
   };

clang/include/clang/Basic/AttrDocs.td

@@ -7648,7 +7648,7 @@ the function is agnostic about.  The supported states for S are:
 * ``"sme_za_state"`` for any state enabled by PSTATE.ZA (including the
   bit itself)
 
-The attributes ``__arm_agnostic("sme_za_state") cannot be used in conjunction
+The attributes ``__arm_agnostic("sme_za_state")`` cannot be used in conjunction
 with ``__arm_in(S)``, ``__arm_out(S)``, ``__arm_inout(S)`` or
 ``__arm_preserves(S)`` where state S describes state enabled by PSTATE.ZA,
 such as "za" or "zt0".

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3836,8 +3836,8 @@ def err_sme_unimplemented_za_save_restore : Error<
   "function that has live 'za' state requires a spill/fill of ZA, which is not yet "
   "implemented">;
 def err_sme_unimplemented_agnostic_new : Error<
-  "support to handle __arm_agnostic(\"sme_za_state\") together with "
-  "__arm_new(\"za\") or __arm_new(\"zt0\") is not yet implemented">;
+  "__arm_agnostic(\"sme_za_state\") is not supported together with "
+  "__arm_new(\"za\") or __arm_new(\"zt0\")">;
 def note_sme_use_preserves_za : Note<
   "add '__arm_preserves(\"za\")' to the callee if it preserves ZA">;
 def err_sme_definition_using_sm_in_non_sme_target : Error<

clang/lib/AST/ItaniumMangle.cpp

@@ -3585,13 +3585,15 @@ void CXXNameMangler::mangleSMEAttrs(unsigned SMEAttrs) {
   else if (SMEAttrs & FunctionType::SME_PStateSMCompatibleMask)
     Bitmask |= AAPCSBitmaskSME::ArmStreamingCompatibleBit;
 
-  // TODO: Must represent __arm_agnostic("sme_za_state")
-
-  Bitmask |= encodeAAPCSZAState(FunctionType::getArmZAState(SMEAttrs))
-             << AAPCSBitmaskSME::ZA_Shift;
+  if (SMEAttrs & FunctionType::SME_AgnosticZAStateMask)
+    Bitmask |= AAPCSBitmaskSME::ArmAgnosticSMEZAStateBit;
+  else {
+    Bitmask |= encodeAAPCSZAState(FunctionType::getArmZAState(SMEAttrs))
+               << AAPCSBitmaskSME::ZA_Shift;
 
-  Bitmask |= encodeAAPCSZAState(FunctionType::getArmZT0State(SMEAttrs))
-             << AAPCSBitmaskSME::ZT0_Shift;
+    Bitmask |= encodeAAPCSZAState(FunctionType::getArmZT0State(SMEAttrs))
+               << AAPCSBitmaskSME::ZT0_Shift;
+  }
 
   Out << "Lj" << static_cast<unsigned>(Bitmask) << "EE";
 }

clang/lib/Sema/SemaType.cpp

@@ -7761,20 +7761,22 @@ static bool handleArmAgnosticAttribute(Sema &S,
     if (!S.checkStringLiteralArgumentAttr(Attr, I, StateName, &LiteralLoc))
       return true;
 
-    if (StateName == "sme_za_state") {
-      if (EPI.AArch64SMEAttributes &
-          (FunctionType::SME_ZAMask | FunctionType::SME_ZT0Mask)) {
-        S.Diag(Attr.getLoc(), diag::err_conflicting_attributes_arm_agnostic);
-        Attr.setInvalid();
-        return true;
-      }
-      EPI.setArmSMEAttribute(FunctionType::SME_AgnosticZAStateMask);
-    } else {
+    if (StateName != "sme_za_state") {
       S.Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
       Attr.setInvalid();
       return true;
     }
+
+    if (EPI.AArch64SMEAttributes &
+        (FunctionType::SME_ZAMask | FunctionType::SME_ZT0Mask)) {
+      S.Diag(Attr.getLoc(), diag::err_conflicting_attributes_arm_agnostic);
+      Attr.setInvalid();
+      return true;
+    }
+
+    EPI.setArmSMEAttribute(FunctionType::SME_AgnosticZAStateMask);
   }
+
   return false;
 }
 

clang/test/CodeGenCXX/aarch64-mangle-sme-atts.cpp

@@ -45,6 +45,16 @@ __arm_new("zt0") void fn_zt0_out(int (*foo)() __arm_out("zt0")) { foo(); }
 // CHECK: define dso_local void @_Z12fn_zt0_inoutP11__SME_ATTRSIFivELj192EE(
 __arm_new("zt0") void fn_zt0_inout(int (*foo)() __arm_inout("zt0")) { foo(); }
 
+//
+// __arm_agnostic("sme_za_state") Attribute
+//
+
+// CHECK: define dso_local void @_Z24fn_sme_za_state_agnosticP11__SME_ATTRSIFvvELj4EE(
+void fn_sme_za_state_agnostic(void (*foo)() __arm_agnostic("sme_za_state")) { foo(); }
+
+// CHECK: define dso_local void @_Z34fn_sme_za_state_streaming_agnosticP11__SME_ATTRSIFvvELj5EE(
+void fn_sme_za_state_streaming_agnostic(void (*foo)() __arm_streaming __arm_agnostic("sme_za_state")) { foo(); }
+
 //
 // Streaming-mode, ZA & ZT0 Attributes
 //

clang/test/Sema/aarch64-sme-func-attrs.c

@@ -101,12 +101,12 @@ void sme_arm_agnostic_shared_za_za(void) __arm_agnostic("sme_za_state") __arm_in
 // expected-error@+1 {{__arm_agnostic("sme_za_state") cannot share ZA state with its caller}}
 void sme_arm_agnostic_shared_za_za_rev(void) __arm_inout("za") __arm_agnostic("sme_za_state") {}
 
-// expected-cpp-error@+2 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
-// expected-error@+1 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
+// expected-cpp-error@+2 {{__arm_agnostic("sme_za_state") is not supported together with __arm_new("za") or __arm_new("zt0")}}
+// expected-error@+1 {{__arm_agnostic("sme_za_state") is not supported together with __arm_new("za") or __arm_new("zt0")}}
 __arm_new("zt0") void sme_arm_agnostic_arm_new_zt0(void) __arm_agnostic("sme_za_state") {}
 
-// expected-cpp-error@+2 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
-// expected-error@+1 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
+// expected-cpp-error@+2 {{__arm_agnostic("sme_za_state") is not supported together with __arm_new("za") or __arm_new("zt0")}}
+// expected-error@+1 {{__arm_agnostic("sme_za_state") is not supported together with __arm_new("za") or __arm_new("zt0")}}
 __arm_new("za") void sme_arm_agnostic_arm_new_za(void) __arm_agnostic("sme_za_state") {}
 
 //