[clang] [AArch64][Clang] Add support for __arm_agnostic("sme_za_state") (PR #121788)
Sander de Smalen via cfe-commits
cfe-commits at lists.llvm.org
Sun Jan 12 12:58:05 PST 2025
https://github.com/sdesmalen-arm updated https://github.com/llvm/llvm-project/pull/121788
>From 4e2166f1c19246e3fb5074da466d151070b5606c Mon Sep 17 00:00:00 2001
From: Sander de Smalen <sander.desmalen at arm.com>
Date: Mon, 9 Sep 2024 15:20:26 +0100
Subject: [PATCH 1/4] [AArch64][Clang] Add support for
__arm_agnostic("sme_za_state")
This adds support for parsing the attribute and codegen to
map it to "aarch64_za_state_agnostic" LLVM IR attribute.
This attribute is described in the Arm C Language Extensions
(ACLE) document:
https://github.com/ARM-software/acle/blob/main/main/acle.md#__arm_agnostic
---
clang/include/clang/AST/Type.h | 13 ++++--
clang/include/clang/Basic/Attr.td | 7 +++
clang/include/clang/Basic/AttrDocs.td | 20 ++++++++
.../clang/Basic/DiagnosticSemaKinds.td | 5 ++
clang/lib/AST/TypePrinter.cpp | 2 +
clang/lib/CodeGen/CGCall.cpp | 2 +
clang/lib/Sema/SemaARM.cpp | 8 ++++
clang/lib/Sema/SemaType.cpp | 46 ++++++++++++++++++-
.../sme-intrinsics/aarch64-sme-attrs.cpp | 24 ++++++++++
clang/test/Sema/aarch64-sme-func-attrs.c | 21 +++++++++
10 files changed, 143 insertions(+), 5 deletions(-)
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 09c98f642852fc..49c1681d84dd52 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -4593,9 +4593,14 @@ class FunctionType : public Type {
SME_ZT0Shift = 5,
SME_ZT0Mask = 0b111 << SME_ZT0Shift,
+ // A bit to tell whether a function is agnostic about sme ZA state.
+ SME_AgnosticZAStateShift = 8,
+ SME_AgnosticZAStateMask = 1 << SME_AgnosticZAStateShift,
+
SME_AttributeMask =
- 0b111'111'11 // We can't support more than 8 bits because of
- // the bitmask in FunctionTypeExtraBitfields.
+ 0b1'111'111'11 // We can't support more than 16 bits because of
+ // the bitmask in FunctionTypeArmAttributes
+ // and ExtProtoInfo.
};
enum ArmStateValue : unsigned {
@@ -4620,7 +4625,7 @@ class FunctionType : public Type {
struct alignas(void *) FunctionTypeArmAttributes {
/// Any AArch64 SME ACLE type attributes that need to be propagated
/// on declarations and function pointers.
- unsigned AArch64SMEAttributes : 8;
+ unsigned AArch64SMEAttributes : 9;
FunctionTypeArmAttributes() : AArch64SMEAttributes(SME_NormalFunction) {}
};
@@ -5188,7 +5193,7 @@ class FunctionProtoType final
FunctionType::ExtInfo ExtInfo;
unsigned Variadic : 1;
unsigned HasTrailingReturn : 1;
- unsigned AArch64SMEAttributes : 8;
+ unsigned AArch64SMEAttributes : 9;
Qualifiers TypeQuals;
RefQualifierKind RefQualifier = RQ_None;
ExceptionSpecInfo ExceptionSpec;
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
index 5039c20d8b73be..c0632aaa516255 100644
--- a/clang/include/clang/Basic/Attr.td
+++ b/clang/include/clang/Basic/Attr.td
@@ -2877,6 +2877,13 @@ def ArmPreserves : TypeAttr, TargetSpecificAttr<TargetAArch64> {
let Documentation = [ArmPreservesDocs];
}
+def ArmAgnostic : TypeAttr, TargetSpecificAttr<TargetAArch64> {
+ let Spellings = [RegularKeyword<"__arm_agnostic">];
+ let Args = [VariadicStringArgument<"AgnosticArgs">];
+ let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
+ let Documentation = [ArmAgnosticDocs];
+}
+
def ArmLocallyStreaming : InheritableAttr, TargetSpecificAttr<TargetAArch64> {
let Spellings = [RegularKeyword<"__arm_locally_streaming">];
let Subjects = SubjectList<[Function], ErrorDiag>;
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index 506fe38eb882b2..70c039c2cfa4f1 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -7635,6 +7635,26 @@ The attributes ``__arm_in(S)``, ``__arm_out(S)``, ``__arm_inout(S)`` and
}];
}
+def ArmAgnosticDocs : Documentation {
+ let Category = DocCatArmSmeAttributes;
+ let Content = [{
+The ``__arm_agnostic`` keyword applies to prototyped function types and
+specifies that the function is agnostic about the given state S and
+returns with state S unchanged if state S exists.
+
+The attribute takes string arguments to instruct the compiler which state
+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
+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".
+ }];
+}
+
def ArmSmeLocallyStreamingDocs : Documentation {
let Category = DocCatArmSmeAttributes;
let Content = [{
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index d4e897868f1a9a..14f4dc4d48fab5 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -3835,6 +3835,9 @@ def err_sme_unimplemented_za_save_restore : Error<
"call to a function that shares state other than 'za' from a "
"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">;
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<
@@ -3851,6 +3854,8 @@ def warn_sme_locally_streaming_has_vl_args_returns : Warning<
"%select{returning|passing}0 a VL-dependent argument %select{from|to}0 a locally streaming function is undefined"
" behaviour when the streaming and non-streaming vector lengths are different at runtime">,
InGroup<AArch64SMEAttributes>, DefaultIgnore;
+def err_conflicting_attributes_arm_agnostic : Error<
+ "__arm_agnostic(\"sme_za_state\") cannot share ZA state with its caller">;
def err_conflicting_attributes_arm_state : Error<
"conflicting attributes for state '%0'">;
def err_unknown_arm_state : Error<
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index 7caebfb061a50b..9590145ffbd5ae 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -1000,6 +1000,8 @@ void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
OS << " __arm_streaming_compatible";
if (SMEBits & FunctionType::SME_PStateSMEnabledMask)
OS << " __arm_streaming";
+ if (SMEBits & FunctionType::SME_AgnosticZAStateMask)
+ OS << "__arm_agnostic(\"sme_za_state\")";
if (FunctionType::getArmZAState(SMEBits) == FunctionType::ARM_Preserves)
OS << " __arm_preserves(\"za\")";
if (FunctionType::getArmZAState(SMEBits) == FunctionType::ARM_In)
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 473675d78c66f0..0fde4d8ee296bd 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -1779,6 +1779,8 @@ static void AddAttributesFromFunctionProtoType(ASTContext &Ctx,
FuncAttrs.addAttribute("aarch64_pstate_sm_enabled");
if (SMEBits & FunctionType::SME_PStateSMCompatibleMask)
FuncAttrs.addAttribute("aarch64_pstate_sm_compatible");
+ if (SMEBits & FunctionType::SME_AgnosticZAStateMask)
+ FuncAttrs.addAttribute("aarch64_za_state_agnostic");
// ZA
if (FunctionType::getArmZAState(SMEBits) == FunctionType::ARM_Preserves)
diff --git a/clang/lib/Sema/SemaARM.cpp b/clang/lib/Sema/SemaARM.cpp
index eafd43eb979ba0..8490ee045166fc 100644
--- a/clang/lib/Sema/SemaARM.cpp
+++ b/clang/lib/Sema/SemaARM.cpp
@@ -1337,6 +1337,14 @@ void SemaARM::CheckSMEFunctionDefAttributes(const FunctionDecl *FD) {
bool UsesZA = Attr && Attr->isNewZA();
bool UsesZT0 = Attr && Attr->isNewZT0();
+ if (UsesZA || UsesZT0) {
+ if (const auto *FPT = FD->getType()->getAs<FunctionProtoType>()) {
+ FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
+ if (EPI.AArch64SMEAttributes & FunctionType::SME_AgnosticZAStateMask)
+ Diag(FD->getLocation(), diag::err_sme_unimplemented_agnostic_new);
+ }
+ }
+
if (FD->hasAttr<ArmLocallyStreamingAttr>()) {
if (FD->getReturnType()->isSizelessVectorType())
Diag(FD->getLocation(),
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index d46fbca9ee9768..c9e9a61287daa6 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -161,6 +161,7 @@ static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
case ParsedAttr::AT_ArmIn: \
case ParsedAttr::AT_ArmOut: \
case ParsedAttr::AT_ArmInOut: \
+ case ParsedAttr::AT_ArmAgnostic: \
case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
case ParsedAttr::AT_AnyX86NoCfCheck: \
CALLING_CONV_ATTRS_CASELIST
@@ -7745,6 +7746,38 @@ static bool checkMutualExclusion(TypeProcessingState &state,
return true;
}
+static bool handleArmAgnosticAttribute(Sema &S,
+ FunctionProtoType::ExtProtoInfo &EPI,
+ ParsedAttr &Attr) {
+ if (!Attr.getNumArgs()) {
+ S.Diag(Attr.getLoc(), diag::err_missing_arm_state) << Attr;
+ Attr.setInvalid();
+ return true;
+ }
+
+ for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {
+ StringRef StateName;
+ SourceLocation LiteralLoc;
+ 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 {
+ S.Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
+ Attr.setInvalid();
+ return true;
+ }
+ }
+ return false;
+}
+
static bool handleArmStateAttribute(Sema &S,
FunctionProtoType::ExtProtoInfo &EPI,
ParsedAttr &Attr,
@@ -7775,6 +7808,12 @@ static bool handleArmStateAttribute(Sema &S,
return true;
}
+ if (EPI.AArch64SMEAttributes & FunctionType::SME_AgnosticZAStateMask) {
+ S.Diag(LiteralLoc, diag::err_conflicting_attributes_arm_agnostic);
+ Attr.setInvalid();
+ return true;
+ }
+
// __arm_in(S), __arm_out(S), __arm_inout(S) and __arm_preserves(S)
// are all mutually exclusive for the same S, so check if there are
// conflicting attributes.
@@ -7925,7 +7964,8 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
attr.getKind() == ParsedAttr::AT_ArmPreserves ||
attr.getKind() == ParsedAttr::AT_ArmIn ||
attr.getKind() == ParsedAttr::AT_ArmOut ||
- attr.getKind() == ParsedAttr::AT_ArmInOut) {
+ attr.getKind() == ParsedAttr::AT_ArmInOut ||
+ attr.getKind() == ParsedAttr::AT_ArmAgnostic) {
if (S.CheckAttrTarget(attr))
return true;
@@ -7976,6 +8016,10 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
if (handleArmStateAttribute(S, EPI, attr, FunctionType::ARM_InOut))
return true;
break;
+ case ParsedAttr::AT_ArmAgnostic:
+ if (handleArmAgnosticAttribute(S, EPI, attr))
+ return true;
+ break;
default:
llvm_unreachable("Unsupported attribute");
}
diff --git a/clang/test/CodeGen/AArch64/sme-intrinsics/aarch64-sme-attrs.cpp b/clang/test/CodeGen/AArch64/sme-intrinsics/aarch64-sme-attrs.cpp
index 9885ac45e6a0e0..54762c8b414124 100644
--- a/clang/test/CodeGen/AArch64/sme-intrinsics/aarch64-sme-attrs.cpp
+++ b/clang/test/CodeGen/AArch64/sme-intrinsics/aarch64-sme-attrs.cpp
@@ -15,6 +15,7 @@ int streaming_compatible_decl(void) __arm_streaming_compatible;
int shared_za_decl(void) __arm_inout("za");
int preserves_za_decl(void) __arm_preserves("za");
int private_za_decl(void);
+int agnostic_za_decl(void) __arm_agnostic("sme_za_state");
// == FUNCTION DEFINITIONS ==
@@ -130,6 +131,27 @@ __arm_new("za") int new_za_callee() {
// CHECK: declare i32 @private_za_decl()
+// CHECK-LABEL: @agnostic_za_caller()
+// CHECK-SAME: #[[ZA_AGNOSTIC:[0-9]+]]
+// CHECK: call i32 @normal_callee()
+//
+int agnostic_za_caller() __arm_agnostic("sme_za_state") {
+ return normal_callee();
+}
+
+// CHECK-LABEL: @agnostic_za_callee()
+// CHECK: call i32 @agnostic_za_decl() #[[ZA_AGNOSTIC_CALL:[0-9]+]]
+//
+int agnostic_za_callee() {
+ return agnostic_za_decl();
+}
+
+// CHECK-LABEL: @agnostic_za_callee_live_za()
+// CHECK: call i32 @agnostic_za_decl() #[[ZA_AGNOSTIC_CALL]]
+//
+int agnostic_za_callee_live_za() __arm_inout("za") {
+ return agnostic_za_decl();
+}
// Ensure that the attributes are correctly propagated to function types
// and also to callsites.
@@ -289,12 +311,14 @@ int test_variadic_template() __arm_inout("za") {
// CHECK: attributes #[[ZA_PRESERVED]] = { mustprogress noinline nounwind "aarch64_preserves_za" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+bf16,+sme" }
// CHECK: attributes #[[ZA_PRESERVED_DECL]] = { "aarch64_preserves_za" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+bf16,+sme" }
// CHECK: attributes #[[ZA_NEW]] = { mustprogress noinline nounwind "aarch64_new_za" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+bf16,+sme" }
+// CHECK: attributes #[[ZA_AGNOSTIC]] = { mustprogress noinline nounwind "aarch64_za_state_agnostic" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+bf16,+sme" }
// CHECK: attributes #[[NORMAL_DEF]] = { mustprogress noinline nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+bf16,+sme" }
// CHECK: attributes #[[SM_ENABLED_CALL]] = { "aarch64_pstate_sm_enabled" }
// CHECK: attributes #[[SM_COMPATIBLE_CALL]] = { "aarch64_pstate_sm_compatible" }
// CHECK: attributes #[[SM_BODY_CALL]] = { "aarch64_pstate_sm_body" }
// CHECK: attributes #[[ZA_SHARED_CALL]] = { "aarch64_inout_za" }
// CHECK: attributes #[[ZA_PRESERVED_CALL]] = { "aarch64_preserves_za" }
+// CHECK: attributes #[[ZA_AGNOSTIC_CALL]] = { "aarch64_za_state_agnostic" }
// CHECK: attributes #[[NOUNWIND_CALL]] = { nounwind }
// CHECK: attributes #[[NOUNWIND_SM_ENABLED_CALL]] = { nounwind "aarch64_pstate_sm_enabled" }
// CHECK: attributes #[[NOUNWIND_SM_COMPATIBLE_CALL]] = { nounwind "aarch64_pstate_sm_compatible" }
diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c
index 0c263eb2610cfb..65628bea579fab 100644
--- a/clang/test/Sema/aarch64-sme-func-attrs.c
+++ b/clang/test/Sema/aarch64-sme-func-attrs.c
@@ -9,6 +9,7 @@ void sme_arm_streaming_compatible(void) __arm_streaming_compatible;
__arm_new("za") void sme_arm_new_za(void) {}
void sme_arm_shared_za(void) __arm_inout("za");
void sme_arm_preserves_za(void) __arm_preserves("za");
+void sme_arm_agnostic(void) __arm_agnostic("sme_za_state");
__arm_new("za") void sme_arm_streaming_new_za(void) __arm_streaming {}
void sme_arm_streaming_shared_za(void) __arm_streaming __arm_inout("za");
@@ -88,6 +89,26 @@ fptrty7 invalid_streaming_func() { return streaming_ptr_invalid; }
// expected-error at +1 {{'__arm_streaming' only applies to function types; type here is 'void ()'}}
void function_no_prototype() __arm_streaming;
+// expected-cpp-error at +2 {{__arm_agnostic("sme_za_state") cannot share ZA state with its caller}}
+// expected-error at +1 {{__arm_agnostic("sme_za_state") cannot share ZA state with its caller}}
+void sme_arm_agnostic_shared_za_zt0(void) __arm_agnostic("sme_za_state") __arm_inout("zt0") {}
+
+// expected-cpp-error at +2 {{__arm_agnostic("sme_za_state") cannot share ZA state with its caller}}
+// expected-error at +1 {{__arm_agnostic("sme_za_state") cannot share ZA state with its caller}}
+void sme_arm_agnostic_shared_za_za(void) __arm_agnostic("sme_za_state") __arm_inout("za") {}
+
+// expected-cpp-error at +2 {{__arm_agnostic("sme_za_state") cannot share ZA state with its caller}}
+// expected-error at +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 at +2 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
+// expected-error at +1 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
+__arm_new("zt0") void sme_arm_agnostic_arm_new_zt0(void) __arm_agnostic("sme_za_state") {}
+
+// expected-cpp-error at +2 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
+// expected-error at +1 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
+__arm_new("za") void sme_arm_agnostic_arm_new_za(void) __arm_agnostic("sme_za_state") {}
+
//
// Check for incorrect conversions of function pointers with the attributes
//
>From b880d2586e40088fe87705f18439760a6e94956a Mon Sep 17 00:00:00 2001
From: Sander de Smalen <sander.desmalen at arm.com>
Date: Tue, 7 Jan 2025 11:47:19 +0000
Subject: [PATCH 2/4] Address review comments
---
clang/include/clang/AST/Type.h | 2 +-
clang/include/clang/Basic/AttrDocs.td | 2 +-
.../clang/Basic/DiagnosticSemaKinds.td | 4 ++--
clang/lib/AST/ItaniumMangle.cpp | 14 +++++++------
clang/lib/Sema/SemaType.cpp | 20 ++++++++++---------
.../CodeGenCXX/aarch64-mangle-sme-atts.cpp | 10 ++++++++++
clang/test/Sema/aarch64-sme-func-attrs.c | 8 ++++----
7 files changed, 37 insertions(+), 23 deletions(-)
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 49c1681d84dd52..78677df578c4bc 100644
--- a/clang/include/clang/AST/Type.h
+++ b/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.
};
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index 70c039c2cfa4f1..7abc0266910dc9 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/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".
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 14f4dc4d48fab5..2dd2792309f394 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/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<
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index 47aa9b40dab845..1dd936cf4fb518 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/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";
}
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index c9e9a61287daa6..e3ec327c1b3644 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/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;
}
diff --git a/clang/test/CodeGenCXX/aarch64-mangle-sme-atts.cpp b/clang/test/CodeGenCXX/aarch64-mangle-sme-atts.cpp
index 09db59ac621a22..3612c03a86efd2 100644
--- a/clang/test/CodeGenCXX/aarch64-mangle-sme-atts.cpp
+++ b/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
//
diff --git a/clang/test/Sema/aarch64-sme-func-attrs.c b/clang/test/Sema/aarch64-sme-func-attrs.c
index 65628bea579fab..1543e990dd0424 100644
--- a/clang/test/Sema/aarch64-sme-func-attrs.c
+++ b/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 at +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 at +2 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
-// expected-error at +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 at +2 {{__arm_agnostic("sme_za_state") is not supported together with __arm_new("za") or __arm_new("zt0")}}
+// expected-error at +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 at +2 {{support to handle __arm_agnostic("sme_za_state") together with __arm_new("za") or __arm_new("zt0") is not yet implemented}}
-// expected-error at +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 at +2 {{__arm_agnostic("sme_za_state") is not supported together with __arm_new("za") or __arm_new("zt0")}}
+// expected-error at +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") {}
//
>From 6e855e0192ec6bf779cfb0dcae63c4f44891dea3 Mon Sep 17 00:00:00 2001
From: Sander de Smalen <sander.desmalen at arm.com>
Date: Wed, 8 Jan 2025 11:27:37 +0000
Subject: [PATCH 3/4] Rephrase documentation
---
clang/include/clang/Basic/AttrDocs.td | 20 +++++++++++++-------
1 file changed, 13 insertions(+), 7 deletions(-)
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index 7abc0266910dc9..37112daa3c019e 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -7639,16 +7639,22 @@ def ArmAgnosticDocs : Documentation {
let Category = DocCatArmSmeAttributes;
let Content = [{
The ``__arm_agnostic`` keyword applies to prototyped function types and
-specifies that the function is agnostic about the given state S and
-returns with state S unchanged if state S exists.
+affects the function's calling convention for a given state S. This
+attribute allows the user to describe a function that preserves S, without
+requiring the function to share S with its callers and without the making
+the assumption that S exists.
-The attribute takes string arguments to instruct the compiler which state
-the function is agnostic about. The supported states for S are:
+If a function has the ``__arm_agnostic(S)`` attribute and calls a function
+without this attribute, then the function's object code will contain code
+to preserve state S. Otherwise, the function's object code will be the same
+as if it did not have the attribute.
+
+The attribute takes string arguments to describe state S. The supported
+states are:
-* ``"sme_za_state"`` for any state enabled by PSTATE.ZA (including the
- bit itself)
+* ``"sme_za_state"`` for state enabled by PSTATE.ZA, such as ZA and ZT0.
-The attributes ``__arm_agnostic("sme_za_state")`` cannot be used in conjunction
+The attribute ``__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".
>From 93ff1a3832daf012b680de61cdb4be3b2fb2ba82 Mon Sep 17 00:00:00 2001
From: Sander de Smalen <sander.desmalen at arm.com>
Date: Sun, 12 Jan 2025 20:22:44 +0000
Subject: [PATCH 4/4] Address nits
---
clang/include/clang/Basic/AttrDocs.td | 2 +-
clang/include/clang/Basic/DiagnosticSemaKinds.td | 2 +-
clang/lib/Sema/SemaARM.cpp | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index 37112daa3c019e..953ff9a700e512 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -7641,7 +7641,7 @@ def ArmAgnosticDocs : Documentation {
The ``__arm_agnostic`` keyword applies to prototyped function types and
affects the function's calling convention for a given state S. This
attribute allows the user to describe a function that preserves S, without
-requiring the function to share S with its callers and without the making
+requiring the function to share S with its callers and without making
the assumption that S exists.
If a function has the ``__arm_agnostic(S)`` attribute and calls a function
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 2dd2792309f394..f04381a32a4158 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -3835,7 +3835,7 @@ def err_sme_unimplemented_za_save_restore : Error<
"call to a function that shares state other than 'za' from a "
"function that has live 'za' state requires a spill/fill of ZA, which is not yet "
"implemented">;
-def err_sme_unimplemented_agnostic_new : Error<
+def err_sme_unsupported_agnostic_new : Error<
"__arm_agnostic(\"sme_za_state\") is not supported together with "
"__arm_new(\"za\") or __arm_new(\"zt0\")">;
def note_sme_use_preserves_za : Note<
diff --git a/clang/lib/Sema/SemaARM.cpp b/clang/lib/Sema/SemaARM.cpp
index 8490ee045166fc..db418d80e0e09c 100644
--- a/clang/lib/Sema/SemaARM.cpp
+++ b/clang/lib/Sema/SemaARM.cpp
@@ -1341,7 +1341,7 @@ void SemaARM::CheckSMEFunctionDefAttributes(const FunctionDecl *FD) {
if (const auto *FPT = FD->getType()->getAs<FunctionProtoType>()) {
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
if (EPI.AArch64SMEAttributes & FunctionType::SME_AgnosticZAStateMask)
- Diag(FD->getLocation(), diag::err_sme_unimplemented_agnostic_new);
+ Diag(FD->getLocation(), diag::err_sme_unsupported_agnostic_new);
}
}
More information about the cfe-commits
mailing list