[Clang][AArch64] Generalise streaming mode checks for builtins.

PR #76975 added 'IsStreamingOrSVE2p1' to emit a diagnostic when a builtin marked
with 'IsStreamingOrSVE2p1' is used in a non-streaming function that is not
compiled with `+sve2p1`.

The problem is a bit more complex than only this case. For example, we've marked
lots of builtins with 'IsStreamingCompatible', meaning it can be used in either
streaming, streaming-compatible or non-streaming functions. But the code in
SemaChecking, doesn't check the appropriate target guards. This issue becomes
relevant when SVE builtins are only available in streaming mode, e.g. when
compiling for SME without SVE.

If we were to add the appropriate target guards, we'd have to add many more
combinations, e.g.:
  IsStreamingSMEOrSVE
  IsStreamingSME2OrSVE2
  IsStreamingSMEOrSVE2p1
  IsStreamingSME2OrSVE2p1
  etc.

To avoid having to add more combinations (and avoid having to add more in the
future for new extensions), we use a single 'IsSVEOrStreamingSVE' flag for all
builtins that are available in streaming mode for the appropriate SME flags, or
in non-streaming mode for the appropriate SVE flags, or both.  The code in
SemaChecking will then verify for which mode (or both) the builtin would be
defined, given the target features of the function/compilation unit.

For example:

  'svclamp' is enabled under FEAT_SVE2p1 and FEAT_SME2

* When we compile for SVE2p1 and SME (but not SME2), the builtin is undefined
  behaviour when called from a streaming function.

* When we compile for SME2 and SVE2 (but not SVE2p1), the builtin is undefined
  behaviour when called from a non-streaming function.

* When we compile for _both_ SVE2p1 and SME2, the builtin can be used in either
  mode (non-streaming, streaming or streaming-compatible)

Author: sdesmalen-arm

clang/include/clang/Basic/arm_sve.td

@@ -225,7 +225,7 @@ def IsStreamingCompatible           : FlagType<0x4000000000>;
 def IsReadZA                        : FlagType<0x8000000000>;
 def IsWriteZA                       : FlagType<0x10000000000>;
 def IsReductionQV                   : FlagType<0x20000000000>;
-def IsStreamingOrSVE2p1             : FlagType<0x40000000000>; // Use for intrinsics that are common between sme/sme2 and sve2p1.
+def IsSVEOrStreamingSVE             : FlagType<0x40000000000>; // Use for intrinsics that are common between SVE and SME.
 def IsInZA                          : FlagType<0x80000000000>;
 def IsOutZA                         : FlagType<0x100000000000>;
 def IsInOutZA                       : FlagType<0x200000000000>;

clang/include/clang/Basic/arm_sve_sme_incl.td

@@ -26,10 +26,12 @@ class SemaARM : public SemaBase {
   SemaARM(Sema &S);
 
   enum ArmStreamingType {
-    ArmNonStreaming,
-    ArmStreaming,
-    ArmStreamingCompatible,
-    ArmStreamingOrSVE2p1
+    ArmNonStreaming, /// Intrinsic is only available in normal mode
+    ArmStreaming,    /// Intrinsic is only available in Streaming-SVE mode.
+    ArmStreamingCompatible, /// Intrinsic is available both in normal and
+                            /// Streaming-SVE mode.
+    ArmStreamingOrHasSVE /// Intrinsic is available in normal mode with +sve, or
+                         /// in Streaming-SVE mode with +sme.
   };
 
   bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,

clang/include/clang/Sema/SemaARM.h

@@ -561,16 +561,61 @@ SemaARM::ArmStreamingType getArmStreamingFnType(const FunctionDecl *FD) {
 
 static void checkArmStreamingBuiltin(Sema &S, CallExpr *TheCall,
                                      const FunctionDecl *FD,
-                                     SemaARM::ArmStreamingType BuiltinType) {
+                                     SemaARM::ArmStreamingType BuiltinType,
+                                     unsigned BuiltinID) {
   SemaARM::ArmStreamingType FnType = getArmStreamingFnType(FD);
-  if (BuiltinType == SemaARM::ArmStreamingOrSVE2p1) {
-    // Check intrinsics that are available in [sve2p1 or sme/sme2].
-    llvm::StringMap<bool> CallerFeatureMap;
-    S.Context.getFunctionFeatureMap(CallerFeatureMap, FD);
-    if (Builtin::evaluateRequiredTargetFeatures("sve2p1", CallerFeatureMap))
+
+  // Check if the intrinsic is available in the right mode, i.e.
+  // * When compiling for SME only, the caller must be in streaming mode.
+  // * When compiling for SVE only, the caller must be in non-streaming mode.
+  // * When compiling for both SVE and SME, the caller can be in either mode.
+  if (BuiltinType == SemaARM::ArmStreamingOrHasSVE) {
+    static const FunctionDecl *CachedFD = nullptr;
+    bool SatisfiesSVE = false, SatisfiesSME = false;
+
+    if (FD != CachedFD) {
+      // We know the builtin requires either some combination of SVE flags, or
+      // some combination of SME flags, but we need to figure out which part
+      // of the required features is satisfied by the target features.
+      //
+      // For a builtin with target guard 'sve2p1|sme2', if we compile with
+      // '+sve2p1,+sme', then we know that it satisfies the 'sve2p1' part if we
+      // evaluate the features for '+sve2p1,+sme,+nosme'.
+      //
+      // Similarly, if we compile with '+sve2,+sme2', then we know it satisfies
+      // the 'sme2' part if we evaluate the features for '+sve2,+sme2,+nosve'.
+      llvm::StringMap<bool> CallerFeatureMap;
+      auto DisableFeatures = [&CallerFeatureMap](StringRef S) {
+        for (StringRef K : CallerFeatureMap.keys())
+          if (K.starts_with(S))
+            CallerFeatureMap[K] = false;
+      };
+
+      StringRef BuiltinTargetGuards(
+          S.Context.BuiltinInfo.getRequiredFeatures(BuiltinID));
+
+      S.Context.getFunctionFeatureMap(CallerFeatureMap, FD);
+      DisableFeatures("sme");
+      SatisfiesSVE = Builtin::evaluateRequiredTargetFeatures(
+          BuiltinTargetGuards, CallerFeatureMap);
+
+      S.Context.getFunctionFeatureMap(CallerFeatureMap, FD);
+      DisableFeatures("sve");
+      SatisfiesSME = Builtin::evaluateRequiredTargetFeatures(
+          BuiltinTargetGuards, CallerFeatureMap);
+
+      CachedFD = FD;
+    }
+
+    if (SatisfiesSVE && SatisfiesSME)
       BuiltinType = SemaARM::ArmStreamingCompatible;
-    else
+    else if (SatisfiesSVE)
+      BuiltinType = SemaARM::ArmNonStreaming;
+    else if (SatisfiesSME)
       BuiltinType = SemaARM::ArmStreaming;
+    else
+      // This should be diagnosed by CodeGen
+      return;
   }
 
   if (FnType == SemaARM::ArmStreaming &&
@@ -622,7 +667,7 @@ bool SemaARM::CheckSMEBuiltinFunctionCall(unsigned BuiltinID,
     }
 
     if (BuiltinType)
-      checkArmStreamingBuiltin(SemaRef, TheCall, FD, *BuiltinType);
+      checkArmStreamingBuiltin(SemaRef, TheCall, FD, *BuiltinType, BuiltinID);
 
     if ((getSMEState(BuiltinID) & ArmZAMask) && !hasArmZAState(FD))
       Diag(TheCall->getBeginLoc(),
@@ -660,7 +705,7 @@ bool SemaARM::CheckSVEBuiltinFunctionCall(unsigned BuiltinID,
 #undef GET_SVE_STREAMING_ATTRS
     }
     if (BuiltinType)
-      checkArmStreamingBuiltin(SemaRef, TheCall, FD, *BuiltinType);
+      checkArmStreamingBuiltin(SemaRef, TheCall, FD, *BuiltinType, BuiltinID);
   }
   // Range check SVE intrinsics that take immediate values.
   SmallVector<std::tuple<int, int, int>, 3> ImmChecks;
@@ -688,7 +733,8 @@ bool SemaARM::CheckNeonBuiltinFunctionCall(const TargetInfo &TI,
 #define TARGET_BUILTIN(id, ...) case NEON::BI##id:
 #define BUILTIN(id, ...) case NEON::BI##id:
 #include "clang/Basic/arm_neon.inc"
-      checkArmStreamingBuiltin(SemaRef, TheCall, FD, ArmNonStreaming);
+      checkArmStreamingBuiltin(SemaRef, TheCall, FD, ArmNonStreaming,
+                               BuiltinID);
       break;
 #undef TARGET_BUILTIN
 #undef BUILTIN

clang/lib/Sema/SemaARM.cpp

@@ -0,0 +1,51 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify %s
+
+// REQUIRES: aarch64-registered-target
+
+#include <arm_sve.h>
+
+__attribute__((target("+sve2p1")))
+svfloat32_t good1(svfloat32_t a, svfloat32_t b, svfloat32_t c) {
+  return svclamp(a, b, c);
+}
+
+__attribute__((target("+sme2")))
+svfloat32_t good2(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming {
+  return svclamp(a, b, c);
+}
+
+__attribute__((target("+sve2p1,+sme2")))
+svfloat32_t good3(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible {
+  return svclamp(a, b, c);
+}
+
+// Without '+sme2', the builtin is only valid in non-streaming mode.
+__attribute__((target("+sve2p1,+sme")))
+svfloat32_t bad1(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming {
+  return svclamp(a, b, c); // expected-warning{{builtin call has undefined behaviour when called from a streaming function}}
+}
+
+// Without '+sve2p1', the builtin is only valid in streaming mode.
+__attribute__((target("+sve2,+sme2")))
+svfloat32_t bad2(svfloat32_t a, svfloat32_t b, svfloat32_t c) {
+  return svclamp(a, b, c); // expected-warning{{builtin call has undefined behaviour when called from a non-streaming function}}
+}
+
+// Without '+sme2', the builtin is only valid in non-streaming mode.
+__attribute__((target("+sve2p1,+sme")))
+svfloat32_t bad3(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible {
+  return svclamp(a, b, c); // expected-warning{{builtin call has undefined behaviour when called from a streaming compatible function}}
+}
+
+// Without '+sve2p1', the builtin is only valid in streaming mode.
+__attribute__((target("+sve2,+sme2")))
+svfloat32_t bad4(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible {
+  return svclamp(a, b, c); // expected-warning{{builtin call has undefined behaviour when called from a streaming compatible function}}
+}
+
+// We don't want a warning about undefined behaviour if none of the feature requirements of the builtin are satisfied.
+// (this results in a target-guard error emitted by Clang CodeGen)
+svfloat32_t bad5(svfloat32_t a, svfloat32_t b, svfloat32_t c) {
+  return svclamp(a, b, c);
+}

clang/test/Sema/aarch64-sme2-sve2p1-diagnostics.c

@@ -1778,14 +1778,14 @@ void SVEEmitter::createStreamingAttrs(raw_ostream &OS, ACLEKind Kind) {
   llvm::StringMap<std::set<std::string>> StreamingMap;
 
   uint64_t IsStreamingFlag = getEnumValueForFlag("IsStreaming");
-  uint64_t IsStreamingOrSVE2p1Flag = getEnumValueForFlag("IsStreamingOrSVE2p1");
+  uint64_t IsSVEOrStreamingSVEFlag = getEnumValueForFlag("IsSVEOrStreamingSVE");
   uint64_t IsStreamingCompatibleFlag =
       getEnumValueForFlag("IsStreamingCompatible");
   for (auto &Def : Defs) {
     if (Def->isFlagSet(IsStreamingFlag))
       StreamingMap["ArmStreaming"].insert(Def->getMangledName());
-    else if (Def->isFlagSet(IsStreamingOrSVE2p1Flag))
-      StreamingMap["ArmStreamingOrSVE2p1"].insert(Def->getMangledName());
+    else if (Def->isFlagSet(IsSVEOrStreamingSVEFlag))
+      StreamingMap["ArmStreamingOrHasSVE"].insert(Def->getMangledName());
     else if (Def->isFlagSet(IsStreamingCompatibleFlag))
       StreamingMap["ArmStreamingCompatible"].insert(Def->getMangledName());
     else