Reland "[AArch64][SME] Split SMECallAttrs out of SMEAttrs" #138671
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-backend-aarch64 Author: Benjamin Maxwell (MacDue) ChangesSMECallAttrs is a new helper class that holds all the SMEAttrs for a call. The interfaces to query actions needed for the call (e.g. change streaming mode) have been moved to the SMECallAttrs class. The main motivation for this change is to make the split between the caller, callee, and callsite attributes more apparent. Before this change, we would always merge callsite and callee attributes. The main reason to do this was to handle indirect calls, however, we also occasionally used callsite attributes on direct calls in tests (mainly to avoid creating multiple function declarations). With this patch, we now explicitly handle indirect calls and disallow incompatible attributes on direct calls (so this patch is not entirely an NFC). Same as #137239, but the final commit avoids inferring SME attributes for function definitions. This allows stubbing the SME ABI routines in C/C++ (and matches the old behaviour). Patch is 43.78 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/138671.diff 8 Files Affected:
diff --git a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
index 1c889d67c81e0..ab577e130ad9c 100644
--- a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
+++ b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
@@ -8636,6 +8636,16 @@ static void analyzeCallOperands(const AArch64TargetLowering &TLI,
}
}
+static SMECallAttrs
+getSMECallAttrs(const Function &Function,
+ const TargetLowering::CallLoweringInfo &CLI) {
+ if (CLI.CB)
+ return SMECallAttrs(*CLI.CB);
+ if (auto *ES = dyn_cast<ExternalSymbolSDNode>(CLI.Callee))
+ return SMECallAttrs(SMEAttrs(Function), SMEAttrs(ES->getSymbol()));
+ return SMECallAttrs(SMEAttrs(Function), SMEAttrs(SMEAttrs::Normal));
+}
+
bool AArch64TargetLowering::isEligibleForTailCallOptimization(
const CallLoweringInfo &CLI) const {
CallingConv::ID CalleeCC = CLI.CallConv;
@@ -8654,12 +8664,10 @@ bool AArch64TargetLowering::isEligibleForTailCallOptimization(
// SME Streaming functions are not eligible for TCO as they may require
// the streaming mode or ZA to be restored after returning from the call.
- SMEAttrs CallerAttrs(MF.getFunction());
- auto CalleeAttrs = CLI.CB ? SMEAttrs(*CLI.CB) : SMEAttrs(SMEAttrs::Normal);
- if (CallerAttrs.requiresSMChange(CalleeAttrs) ||
- CallerAttrs.requiresLazySave(CalleeAttrs) ||
- CallerAttrs.requiresPreservingAllZAState(CalleeAttrs) ||
- CallerAttrs.hasStreamingBody())
+ SMECallAttrs CallAttrs = getSMECallAttrs(CallerF, CLI);
+ if (CallAttrs.requiresSMChange() || CallAttrs.requiresLazySave() ||
+ CallAttrs.requiresPreservingAllZAState() ||
+ CallAttrs.caller().hasStreamingBody())
return false;
// Functions using the C or Fast calling convention that have an SVE signature
@@ -8951,14 +8959,13 @@ static SDValue emitSMEStateSaveRestore(const AArch64TargetLowering &TLI,
return TLI.LowerCallTo(CLI).second;
}
-static unsigned getSMCondition(const SMEAttrs &CallerAttrs,
- const SMEAttrs &CalleeAttrs) {
- if (!CallerAttrs.hasStreamingCompatibleInterface() ||
- CallerAttrs.hasStreamingBody())
+static unsigned getSMCondition(const SMECallAttrs &CallAttrs) {
+ if (!CallAttrs.caller().hasStreamingCompatibleInterface() ||
+ CallAttrs.caller().hasStreamingBody())
return AArch64SME::Always;
- if (CalleeAttrs.hasNonStreamingInterface())
+ if (CallAttrs.callee().hasNonStreamingInterface())
return AArch64SME::IfCallerIsStreaming;
- if (CalleeAttrs.hasStreamingInterface())
+ if (CallAttrs.callee().hasStreamingInterface())
return AArch64SME::IfCallerIsNonStreaming;
llvm_unreachable("Unsupported attributes");
@@ -9091,11 +9098,7 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
}
// Determine whether we need any streaming mode changes.
- SMEAttrs CalleeAttrs, CallerAttrs(MF.getFunction());
- if (CLI.CB)
- CalleeAttrs = SMEAttrs(*CLI.CB);
- else if (auto *ES = dyn_cast<ExternalSymbolSDNode>(CLI.Callee))
- CalleeAttrs = SMEAttrs(ES->getSymbol());
+ SMECallAttrs CallAttrs = getSMECallAttrs(MF.getFunction(), CLI);
auto DescribeCallsite =
[&](OptimizationRemarkAnalysis &R) -> OptimizationRemarkAnalysis & {
@@ -9110,9 +9113,8 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
return R;
};
- bool RequiresLazySave = CallerAttrs.requiresLazySave(CalleeAttrs);
- bool RequiresSaveAllZA =
- CallerAttrs.requiresPreservingAllZAState(CalleeAttrs);
+ bool RequiresLazySave = CallAttrs.requiresLazySave();
+ bool RequiresSaveAllZA = CallAttrs.requiresPreservingAllZAState();
if (RequiresLazySave) {
const TPIDR2Object &TPIDR2 = FuncInfo->getTPIDR2Obj();
MachinePointerInfo MPI =
@@ -9140,18 +9142,18 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
return DescribeCallsite(R) << " sets up a lazy save for ZA";
});
} else if (RequiresSaveAllZA) {
- assert(!CalleeAttrs.hasSharedZAInterface() &&
+ assert(!CallAttrs.callee().hasSharedZAInterface() &&
"Cannot share state that may not exist");
Chain = emitSMEStateSaveRestore(*this, DAG, FuncInfo, DL, Chain,
/*IsSave=*/true);
}
SDValue PStateSM;
- bool RequiresSMChange = CallerAttrs.requiresSMChange(CalleeAttrs);
+ bool RequiresSMChange = CallAttrs.requiresSMChange();
if (RequiresSMChange) {
- if (CallerAttrs.hasStreamingInterfaceOrBody())
+ if (CallAttrs.caller().hasStreamingInterfaceOrBody())
PStateSM = DAG.getConstant(1, DL, MVT::i64);
- else if (CallerAttrs.hasNonStreamingInterface())
+ else if (CallAttrs.caller().hasNonStreamingInterface())
PStateSM = DAG.getConstant(0, DL, MVT::i64);
else
PStateSM = getRuntimePStateSM(DAG, Chain, DL, MVT::i64);
@@ -9168,7 +9170,7 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
SDValue ZTFrameIdx;
MachineFrameInfo &MFI = MF.getFrameInfo();
- bool ShouldPreserveZT0 = CallerAttrs.requiresPreservingZT0(CalleeAttrs);
+ bool ShouldPreserveZT0 = CallAttrs.requiresPreservingZT0();
// If the caller has ZT0 state which will not be preserved by the callee,
// spill ZT0 before the call.
@@ -9184,7 +9186,7 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
// If caller shares ZT0 but the callee is not shared ZA, we need to stop
// PSTATE.ZA before the call if there is no lazy-save active.
- bool DisableZA = CallerAttrs.requiresDisablingZABeforeCall(CalleeAttrs);
+ bool DisableZA = CallAttrs.requiresDisablingZABeforeCall();
assert((!DisableZA || !RequiresLazySave) &&
"Lazy-save should have PSTATE.SM=1 on entry to the function");
@@ -9466,9 +9468,9 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
InGlue = Chain.getValue(1);
}
- SDValue NewChain = changeStreamingMode(
- DAG, DL, CalleeAttrs.hasStreamingInterface(), Chain, InGlue,
- getSMCondition(CallerAttrs, CalleeAttrs), PStateSM);
+ SDValue NewChain =
+ changeStreamingMode(DAG, DL, CallAttrs.callee().hasStreamingInterface(),
+ Chain, InGlue, getSMCondition(CallAttrs), PStateSM);
Chain = NewChain.getValue(0);
InGlue = NewChain.getValue(1);
}
@@ -9647,8 +9649,8 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
if (RequiresSMChange) {
assert(PStateSM && "Expected a PStateSM to be set");
Result = changeStreamingMode(
- DAG, DL, !CalleeAttrs.hasStreamingInterface(), Result, InGlue,
- getSMCondition(CallerAttrs, CalleeAttrs), PStateSM);
+ DAG, DL, !CallAttrs.callee().hasStreamingInterface(), Result, InGlue,
+ getSMCondition(CallAttrs), PStateSM);
if (!Subtarget->isTargetDarwin() || Subtarget->hasSVE()) {
InGlue = Result.getValue(1);
@@ -9658,7 +9660,7 @@ AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
}
}
- if (CallerAttrs.requiresEnablingZAAfterCall(CalleeAttrs))
+ if (CallAttrs.requiresEnablingZAAfterCall())
// Unconditionally resume ZA.
Result = DAG.getNode(
AArch64ISD::SMSTART, DL, MVT::Other, Result,
@@ -28518,12 +28520,10 @@ bool AArch64TargetLowering::fallBackToDAGISel(const Instruction &Inst) const {
// Checks to allow the use of SME instructions
if (auto *Base = dyn_cast<CallBase>(&Inst)) {
- auto CallerAttrs = SMEAttrs(*Inst.getFunction());
- auto CalleeAttrs = SMEAttrs(*Base);
- if (CallerAttrs.requiresSMChange(CalleeAttrs) ||
- CallerAttrs.requiresLazySave(CalleeAttrs) ||
- CallerAttrs.requiresPreservingZT0(CalleeAttrs) ||
- CallerAttrs.requiresPreservingAllZAState(CalleeAttrs))
+ auto CallAttrs = SMECallAttrs(*Base);
+ if (CallAttrs.requiresSMChange() || CallAttrs.requiresLazySave() ||
+ CallAttrs.requiresPreservingZT0() ||
+ CallAttrs.requiresPreservingAllZAState())
return true;
}
return false;
diff --git a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
index 5b3a1df9dfd7c..34fb76e66ec00 100644
--- a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
+++ b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
@@ -268,22 +268,21 @@ const FeatureBitset AArch64TTIImpl::InlineInverseFeatures = {
bool AArch64TTIImpl::areInlineCompatible(const Function *Caller,
const Function *Callee) const {
- SMEAttrs CallerAttrs(*Caller), CalleeAttrs(*Callee);
+ SMECallAttrs CallAttrs(*Caller, *Callee);
// When inlining, we should consider the body of the function, not the
// interface.
- if (CalleeAttrs.hasStreamingBody()) {
- CalleeAttrs.set(SMEAttrs::SM_Compatible, false);
- CalleeAttrs.set(SMEAttrs::SM_Enabled, true);
+ if (CallAttrs.callee().hasStreamingBody()) {
+ CallAttrs.callee().set(SMEAttrs::SM_Compatible, false);
+ CallAttrs.callee().set(SMEAttrs::SM_Enabled, true);
}
- if (CalleeAttrs.isNewZA() || CalleeAttrs.isNewZT0())
+ if (CallAttrs.callee().isNewZA() || CallAttrs.callee().isNewZT0())
return false;
- if (CallerAttrs.requiresLazySave(CalleeAttrs) ||
- CallerAttrs.requiresSMChange(CalleeAttrs) ||
- CallerAttrs.requiresPreservingZT0(CalleeAttrs) ||
- CallerAttrs.requiresPreservingAllZAState(CalleeAttrs)) {
+ if (CallAttrs.requiresLazySave() || CallAttrs.requiresSMChange() ||
+ CallAttrs.requiresPreservingZT0() ||
+ CallAttrs.requiresPreservingAllZAState()) {
if (hasPossibleIncompatibleOps(Callee))
return false;
}
@@ -349,12 +348,14 @@ AArch64TTIImpl::getInlineCallPenalty(const Function *F, const CallBase &Call,
// streaming-mode change, and the call to G from F would also require a
// streaming-mode change, then there is benefit to do the streaming-mode
// change only once and avoid inlining of G into F.
+
SMEAttrs FAttrs(*F);
- SMEAttrs CalleeAttrs(Call);
- if (FAttrs.requiresSMChange(CalleeAttrs)) {
+ SMECallAttrs CallAttrs(Call);
+
+ if (SMECallAttrs(FAttrs, CallAttrs.callee()).requiresSMChange()) {
if (F == Call.getCaller()) // (1)
return CallPenaltyChangeSM * DefaultCallPenalty;
- if (FAttrs.requiresSMChange(SMEAttrs(*Call.getCaller()))) // (2)
+ if (SMECallAttrs(FAttrs, CallAttrs.caller()).requiresSMChange()) // (2)
return InlineCallPenaltyChangeSM * DefaultCallPenalty;
}
diff --git a/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.cpp b/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.cpp
index 76d2ac6a601e5..23de691fafef2 100644
--- a/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.cpp
+++ b/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.cpp
@@ -27,15 +27,14 @@ void SMEAttrs::set(unsigned M, bool Enable) {
"ZA_New and SME_ABI_Routine are mutually exclusive");
assert(
- (!sharesZA() ||
- (isNewZA() ^ isInZA() ^ isInOutZA() ^ isOutZA() ^ isPreservesZA())) &&
+ (isNewZA() + isInZA() + isOutZA() + isInOutZA() + isPreservesZA()) <= 1 &&
"Attributes 'aarch64_new_za', 'aarch64_in_za', 'aarch64_out_za', "
"'aarch64_inout_za' and 'aarch64_preserves_za' are mutually exclusive");
// ZT0 Attrs
assert(
- (!sharesZT0() || (isNewZT0() ^ isInZT0() ^ isInOutZT0() ^ isOutZT0() ^
- isPreservesZT0())) &&
+ (isNewZT0() + isInZT0() + isOutZT0() + isInOutZT0() + isPreservesZT0()) <=
+ 1 &&
"Attributes 'aarch64_new_zt0', 'aarch64_in_zt0', 'aarch64_out_zt0', "
"'aarch64_inout_zt0' and 'aarch64_preserves_zt0' are mutually exclusive");
@@ -44,27 +43,6 @@ void SMEAttrs::set(unsigned M, bool Enable) {
"interface");
}
-SMEAttrs::SMEAttrs(const CallBase &CB) {
- *this = SMEAttrs(CB.getAttributes());
- if (auto *F = CB.getCalledFunction()) {
- set(SMEAttrs(*F).Bitmask | SMEAttrs(F->getName()).Bitmask);
- }
-}
-
-SMEAttrs::SMEAttrs(StringRef FuncName) : Bitmask(0) {
- if (FuncName == "__arm_tpidr2_save" || FuncName == "__arm_sme_state")
- Bitmask |= (SMEAttrs::SM_Compatible | SMEAttrs::SME_ABI_Routine);
- if (FuncName == "__arm_tpidr2_restore")
- Bitmask |= SMEAttrs::SM_Compatible | encodeZAState(StateValue::In) |
- SMEAttrs::SME_ABI_Routine;
- if (FuncName == "__arm_sc_memcpy" || FuncName == "__arm_sc_memset" ||
- FuncName == "__arm_sc_memmove" || FuncName == "__arm_sc_memchr")
- Bitmask |= SMEAttrs::SM_Compatible;
- if (FuncName == "__arm_sme_save" || FuncName == "__arm_sme_restore" ||
- FuncName == "__arm_sme_state_size")
- Bitmask |= SMEAttrs::SM_Compatible | SMEAttrs::SME_ABI_Routine;
-}
-
SMEAttrs::SMEAttrs(const AttributeList &Attrs) {
Bitmask = 0;
if (Attrs.hasFnAttr("aarch64_pstate_sm_enabled"))
@@ -99,17 +77,50 @@ SMEAttrs::SMEAttrs(const AttributeList &Attrs) {
Bitmask |= encodeZT0State(StateValue::New);
}
-bool SMEAttrs::requiresSMChange(const SMEAttrs &Callee) const {
- if (Callee.hasStreamingCompatibleInterface())
+void SMEAttrs::addKnownFunctionAttrs(StringRef FuncName) {
+ unsigned KnownAttrs = SMEAttrs::Normal;
+ if (FuncName == "__arm_tpidr2_save" || FuncName == "__arm_sme_state")
+ KnownAttrs |= (SMEAttrs::SM_Compatible | SMEAttrs::SME_ABI_Routine);
+ if (FuncName == "__arm_tpidr2_restore")
+ KnownAttrs |= SMEAttrs::SM_Compatible | encodeZAState(StateValue::In) |
+ SMEAttrs::SME_ABI_Routine;
+ if (FuncName == "__arm_sc_memcpy" || FuncName == "__arm_sc_memset" ||
+ FuncName == "__arm_sc_memmove" || FuncName == "__arm_sc_memchr")
+ KnownAttrs |= SMEAttrs::SM_Compatible;
+ if (FuncName == "__arm_sme_save" || FuncName == "__arm_sme_restore" ||
+ FuncName == "__arm_sme_state_size")
+ KnownAttrs |= SMEAttrs::SM_Compatible | SMEAttrs::SME_ABI_Routine;
+ set(KnownAttrs, /*Enable=*/true);
+}
+
+bool SMECallAttrs::requiresSMChange() const {
+ if (callee().hasStreamingCompatibleInterface())
return false;
// Both non-streaming
- if (hasNonStreamingInterfaceAndBody() && Callee.hasNonStreamingInterface())
+ if (caller().hasNonStreamingInterfaceAndBody() &&
+ callee().hasNonStreamingInterface())
return false;
// Both streaming
- if (hasStreamingInterfaceOrBody() && Callee.hasStreamingInterface())
+ if (caller().hasStreamingInterfaceOrBody() &&
+ callee().hasStreamingInterface())
return false;
return true;
}
+
+SMECallAttrs::SMECallAttrs(const CallBase &CB)
+ : CallerFn(*CB.getFunction()), CalledFn(SMEAttrs::Normal),
+ Callsite(CB.getAttributes()), IsIndirect(CB.isIndirectCall()) {
+ if (auto *CalledFunction = CB.getCalledFunction()) {
+ CalledFn = SMEAttrs(*CalledFunction);
+ CalledFn.addKnownFunctionAttrs(CalledFunction->getName());
+ }
+
+ // FIXME: We probably should not allow SME attributes on direct calls but
+ // clang duplicates streaming mode attributes at each callsite.
+ assert((IsIndirect ||
+ ((Callsite.withoutPerCallsiteFlags() | CalledFn) == CalledFn)) &&
+ "SME attributes at callsite do not match declaration");
+}
diff --git a/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.h b/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.h
index 1691d4fec8b68..9cbb444429431 100644
--- a/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.h
+++ b/llvm/lib/Target/AArch64/Utils/AArch64SMEAttributes.h
@@ -17,13 +17,12 @@ class Function;
class CallBase;
class AttributeList;
+class SMECallAttrs;
+
/// SMEAttrs is a utility class to parse the SME ACLE attributes on functions.
-/// It helps determine a function's requirements for PSTATE.ZA and PSTATE.SM. It
-/// has interfaces to query whether a streaming mode change or lazy-save
-/// mechanism is required when going from one function to another (e.g. through
-/// a call).
+/// It helps determine a function's requirements for PSTATE.ZA and PSTATE.SM.
class SMEAttrs {
- unsigned Bitmask;
+ unsigned Bitmask = Normal;
public:
enum class StateValue {
@@ -43,18 +42,19 @@ class SMEAttrs {
SM_Body = 1 << 2, // aarch64_pstate_sm_body
SME_ABI_Routine = 1 << 3, // Used for SME ABI routines to avoid lazy saves
ZA_State_Agnostic = 1 << 4,
- ZT0_Undef = 1 << 5, // Use to mark ZT0 as undef to avoid spills
+ ZT0_Undef = 1 << 5, // Use to mark ZT0 as undef to avoid spills
ZA_Shift = 6,
ZA_Mask = 0b111 << ZA_Shift,
ZT0_Shift = 9,
- ZT0_Mask = 0b111 << ZT0_Shift
+ ZT0_Mask = 0b111 << ZT0_Shift,
+ Callsite_Flags = ZT0_Undef
};
- SMEAttrs(unsigned Mask = Normal) : Bitmask(0) { set(Mask); }
+ SMEAttrs() = default;
+ SMEAttrs(unsigned Mask) { set(Mask); }
SMEAttrs(const Function &F) : SMEAttrs(F.getAttributes()) {}
- SMEAttrs(const CallBase &CB);
SMEAttrs(const AttributeList &L);
- SMEAttrs(StringRef FuncName);
+ SMEAttrs(StringRef FuncName) { addKnownFunctionAttrs(FuncName); };
void set(unsigned M, bool Enable = true);
@@ -74,10 +74,6 @@ class SMEAttrs {
return hasNonStreamingInterface() && !hasStreamingBody();
}
- /// \return true if a call from Caller -> Callee requires a change in
- /// streaming mode.
- bool requiresSMChange(const SMEAttrs &Callee) const;
-
// Interfaces to query ZA
static StateValue decodeZAState(unsigned Bitmask) {
return static_cast<StateValue>((Bitmask & ZA_Mask) >> ZA_Shift);
@@ -104,10 +100,7 @@ class SMEAttrs {
return !hasSharedZAInterface() && !hasAgnosticZAInterface();
}
bool hasZAState() const { return isNewZA() || sharesZA(); }
- bool requiresLazySave(const SMEAttrs &Callee) const {
- return hasZAState() && Callee.hasPrivateZAInterface() &&
- !(Callee.Bitmask & SME_ABI_Routine);
- }
+ bool isSMEABIRoutine() const { return Bitmask & SME_ABI_Routine; }
// Interfaces to query ZT0 State
static StateValue decodeZT0State(unsigned Bitmask) {
@@ -126,27 +119,85 @@ class SMEAttrs {
bool isPreservesZT0() const {
return decodeZT0State(Bitmask) == StateValue::Preserved;
}
- bool isUndefZT0() const { return Bitmask & ZT0_Undef; }
+ bool hasUndefZT0() const { return Bitmask & ZT0_Undef; }
bool sharesZT0() const {
StateValue State = decodeZT0State(Bitmask);
return State == StateValue::In || State == StateValue::Out ||
State == StateValue::InOut || State == StateValue::Preserved;
}
bool hasZT0State() const { return isNewZT0() || sharesZT0(); }
- bool requiresPreservingZT0(const SMEAttrs &Callee) const {
- return hasZT0State() && !Callee.isUndefZT0() && !Callee.sharesZT0() &&
- !Callee.hasAgnosticZAInterface();
+
+ SMEAttrs operator|(SMEAttrs Other) const {
+ SMEAttrs Merged(*this);
+ Merged.set(Other.Bitmask, /*Enable=*/true);
+ return Merged;
}
- bool requiresDisablingZABeforeCall(const SMEAttrs &Callee) const {
- return hasZT0State() && !hasZAState() && Callee.hasPrivateZAInterface() &&
- !(Callee.Bitmask & SME_ABI_Routine);
+
+ SMEAttrs withoutPerCallsiteFlags() const {
+ return (Bitmask & ~Callsite_Flags);
}
- bool requiresEnablingZAAfterCall(const SMEAttrs &Callee) const {
- return requiresLazySave(Callee) || requiresDisablingZABeforeCall(Callee);
+
+ bool operator==(SMEAttrs const &Other) const {
+ return Bitmask == Other.Bitmask;
}
- bool requiresPreservingAllZAState(const SMEAttrs &Callee) const {
- return hasAgnosticZAInterface() && !Callee.hasAgnosticZAInterface() &&
- !(Callee.Bitmask & SME_ABI_Routine);
+
+ friend SMECallAttrs;
+
+private:
+ void addKnownFunctionAttrs(StringRef FuncName);
+};
+
+/// SMECallAttrs is a utility class to hold the SMEAttrs for a callsite. It has
+/// interfaces to query whether a streaming mode change or lazy-save mechanism
+/// is required when going from one function to another (e.g. through a call).
+class SMECallAttrs {
+ SMEAttrs CallerFn;
+ SMEAttrs CalledFn;
+ SMEAttrs Callsite;
+ bool IsIndirect = false;
+
+public:
+ SMECallAttrs(SMEAttrs Caller, SMEAttrs Callee,
+ SMEAttrs Callsite = SMEAttrs::Normal)
+ : CallerFn(Caller), CalledFn(Callee), Callsite(Callsite) {}
+
+ SMECallAttrs(const CallBase &CB);
+
+ SMEAttrs &caller() { return CallerFn; }
+ SMEAttrs &callee() { return IsIndirect ? Callsite : CalledFn; }
+ SMEAttrs &callsite() { return Callsite; }
+ SMEAttrs const &caller() const { return CallerFn; }
+ SMEAttrs const &callee() const {
+ return const_cast<SMECallAttrs *>(this)->callee();
+ }
+ SMEAttrs const &callsite() const { return Callsite; }
+
+ /// \return true if a ...
[truncated]
|
e5c1a4c to
70410f5
Compare
|
Ping (added a new test case) 🙂 |
SMECallAttrs is a new helper class that holds all the SMEAttrs for a call. The interfaces to query actions needed for the call (e.g. change streaming mode) have been moved to the SMECallAttrs class. The main motivation for this change is to make the split between caller, callee, and callsite attributes more apparent. Places that previously implicitly checked callsite attributes have been updated to make these checks explicit. Similarly, places known to only check callee or callsite attributes have also been updated to make this clear.
This was only used in a handful of tests (mainly to avoid making multiple function declarations). These tests can easily be updated to use indirect calls or attributes on declarations. This allows us to remove checks that looked at both the "callee" and "callsite" attributes, which makes the API of SMECallAttrs a clearer and less error-prone (as you can't accidentally use .callee() when you should have used .calleeOrCallsite()). Note: This currently still allows non-conflicting attributes on direct calls (as clang currently duplicates streaming mode attributes at each callsite).
This matches the old behaviour and allows stubbing the ABI routines in C++.
f78429f to
9ddaf09
Compare
sdesmalen-arm
approved these changes
May 14, 2025
TIFitis
pushed a commit
to TIFitis/llvm-project
that referenced
this pull request
May 19, 2025
SMECallAttrs is a new helper class that holds all the SMEAttrs for a call. The interfaces to query actions needed for the call (e.g. change streaming mode) have been moved to the SMECallAttrs class. The main motivation for this change is to make the split between the caller, callee, and callsite attributes more apparent. Before this change, we would always merge callsite and callee attributes. The main reason to do this was to handle indirect calls, however, we also occasionally used callsite attributes on direct calls in tests (mainly to avoid creating multiple function declarations). With this patch, we now explicitly handle indirect calls and disallow incompatible attributes on direct calls (so this patch is not entirely an NFC). Same as llvm#137239, but with a change to avoid inferring SME attributes for function definitions. This allows stubbing the SME ABI routines in C/C++ (and matches the old behaviour).
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
SMECallAttrs is a new helper class that holds all the SMEAttrs for a call. The interfaces to query actions needed for the call (e.g. change streaming mode) have been moved to the SMECallAttrs class.
The main motivation for this change is to make the split between the caller, callee, and callsite attributes more apparent.
Before this change, we would always merge callsite and callee attributes. The main reason to do this was to handle indirect calls, however, we also occasionally used callsite attributes on direct calls in tests (mainly to avoid creating multiple function declarations). With this patch, we now explicitly handle indirect calls and disallow incompatible attributes on direct calls (so this patch is not entirely an NFC).
Same as #137239, but with a change to avoid inferring SME attributes for function definitions. This allows stubbing the SME ABI routines in C/C++ (and matches the old behaviour).