[AArch64] Alter arm_sve.h to be target-based, not preprocessor based.

[dmgreen]

Summary

We would like to make the ACLE NEON and SVE intrinsics more useable by gating them on the target, not by ifdef preprocessor macros. See #56480. The arm_neon.h file is quite complex to change, so this patch begins with arm_sve.h. This alters the SVEEmitter for arm_sve.h to remove the #ifdef guards and instead use TARGET_BUILTIN with the correct features so that the existing 'func' needs target feature sve error will be generated when sve is not present.

The ArchGuard containing defines in the SVEEmitter are changed to TargetGuard containing target features. In the arm_neon.h emitter there will likely be existing ArchGuard ifdefs mixed with new TargetGuard target feature guards, so the name is change in the SVE too for consistency. The few functions that are present in arm_sve.h (as opposed to builtin aliases) have __attribute__((target(\"sve\"))) added. Some of the tests needed to be rejigged a little, as well as updating the error message, as the error now happens at a later point.

[simon_tatham]

I love it! I'm generally frustrated by any software that says "what even is this, I've never heard of it" when it could so easily change it to "I have heard of this but it's not allowed in this particular context because reason". If nothing else, it means you get different error messages for "misspelled an intrinsic" and "used one from SVE version n+1".

clang/include/clang/Basic/BuiltinsSVE.def

 // The format of this database matches clang/Basic/Builtins.def.
 
 #define GET_SVE_BUILTINS
 #include "clang/Basic/arm_sve_builtins.inc"
 #include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
 #undef GET_SVE_BUILTINS
 
 #undef BUILTIN
+#undef TARGET_BUILTIN

clang/include/clang/Basic/arm_sve.td

class ImmCheck<int arg, ImmCheckType kind, int eltSizeArg = -1> {
   ImmCheckType Kind = kind;
 }
 
 class Inst<string n, string p, string t, MergeType mt, string i,
            list<FlagType> ft, list<ImmCheck> ch, MemEltType met> {
   string Name = n;
   string Prototype = p;
   string Types = t;
-  string ArchGuard = "";
+  string TargetGuard = "sve";
   int Merge = mt.Value;
   string MergeSuffix = mt.Suffix;
   string LLVMIntrinsic = i;
   list<FlagType> Flags = ft;
   list<ImmCheck> ImmChecks = ch;
   int MemEltType = met.Value;
 }
 

 def SVLD1   : MInst<"svld1[_{2}]", "dPc", "csilUcUsUiUlhfd", [IsLoad],               MemEltTyDefault, "aarch64_sve_ld1">;
 def SVLD1SB : MInst<"svld1sb_{d}", "dPS", "silUsUiUl",       [IsLoad],               MemEltTyInt8,    "aarch64_sve_ld1">;
 def SVLD1UB : MInst<"svld1ub_{d}", "dPW", "silUsUiUl",       [IsLoad, IsZExtReturn], MemEltTyInt8,    "aarch64_sve_ld1">;
 def SVLD1SH : MInst<"svld1sh_{d}", "dPT", "ilUiUl",          [IsLoad],               MemEltTyInt16,   "aarch64_sve_ld1">;
 def SVLD1UH : MInst<"svld1uh_{d}", "dPX", "ilUiUl",          [IsLoad, IsZExtReturn], MemEltTyInt16,   "aarch64_sve_ld1">;
 def SVLD1SW : MInst<"svld1sw_{d}", "dPU", "lUl",             [IsLoad],               MemEltTyInt32,   "aarch64_sve_ld1">;
 def SVLD1UW : MInst<"svld1uw_{d}", "dPY", "lUl",             [IsLoad, IsZExtReturn], MemEltTyInt32,   "aarch64_sve_ld1">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVLD1_BF      : MInst<"svld1[_{2}]",      "dPc",  "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ld1">;
   def SVLD1_VNUM_BF : MInst<"svld1_vnum[_{2}]", "dPcl", "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ld1">;
 }
 
 // Load one vector (scalar base, VL displacement)
 def SVLD1_VNUM   : MInst<"svld1_vnum[_{2}]", "dPcl", "csilUcUsUiUlhfd", [IsLoad],               MemEltTyDefault, "aarch64_sve_ld1">;
 def SVLD1SB_VNUM : MInst<"svld1sb_vnum_{d}", "dPSl", "silUsUiUl",       [IsLoad],               MemEltTyInt8,    "aarch64_sve_ld1">;
 def SVLD1UB_VNUM : MInst<"svld1ub_vnum_{d}", "dPWl", "silUsUiUl",       [IsLoad, IsZExtReturn], MemEltTyInt8,    "aarch64_sve_ld1">;

 def SVLDFF1_VNUM   : MInst<"svldff1_vnum[_{2}]", "dPcl", "csilUcUsUiUlhfd", [IsLoad],               MemEltTyDefault, "aarch64_sve_ldff1">;
 def SVLDFF1SB_VNUM : MInst<"svldff1sb_vnum_{d}", "dPSl", "silUsUiUl",       [IsLoad],               MemEltTyInt8,    "aarch64_sve_ldff1">;
 def SVLDFF1UB_VNUM : MInst<"svldff1ub_vnum_{d}", "dPWl", "silUsUiUl",       [IsLoad, IsZExtReturn], MemEltTyInt8,    "aarch64_sve_ldff1">;
 def SVLDFF1SH_VNUM : MInst<"svldff1sh_vnum_{d}", "dPTl", "ilUiUl",          [IsLoad],               MemEltTyInt16,   "aarch64_sve_ldff1">;
 def SVLDFF1UH_VNUM : MInst<"svldff1uh_vnum_{d}", "dPXl", "ilUiUl",          [IsLoad, IsZExtReturn], MemEltTyInt16,   "aarch64_sve_ldff1">;
 def SVLDFF1SW_VNUM : MInst<"svldff1sw_vnum_{d}", "dPUl", "lUl",             [IsLoad],               MemEltTyInt32,   "aarch64_sve_ldff1">;
 def SVLDFF1UW_VNUM : MInst<"svldff1uw_vnum_{d}", "dPYl", "lUl",             [IsLoad, IsZExtReturn], MemEltTyInt32,   "aarch64_sve_ldff1">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVLDFF1_BF      : MInst<"svldff1[_{2}]",      "dPc",  "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ldff1">;
   def SVLDFF1_VNUM_BF : MInst<"svldff1_vnum[_{2}]", "dPcl", "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ldff1">;
 }
 
 // First-faulting load one vector (vector base)
 def SVLDFF1_GATHER_BASES_U   : MInst<"svldff1_gather[_{2}base]_{d}",   "dPu", "ilUiUlfd", [IsGatherLoad],               MemEltTyDefault, "aarch64_sve_ldff1_gather_scalar_offset">;
 def SVLDFF1SB_GATHER_BASES_U : MInst<"svldff1sb_gather[_{2}base]_{d}", "dPu", "ilUiUl",   [IsGatherLoad],               MemEltTyInt8,    "aarch64_sve_ldff1_gather_scalar_offset">;
 def SVLDFF1UB_GATHER_BASES_U : MInst<"svldff1ub_gather[_{2}base]_{d}", "dPu", "ilUiUl",   [IsGatherLoad, IsZExtReturn], MemEltTyInt8,    "aarch64_sve_ldff1_gather_scalar_offset">;

 def SVLDNF1_VNUM   : MInst<"svldnf1_vnum[_{2}]", "dPcl", "csilUcUsUiUlhfd", [IsLoad],               MemEltTyDefault, "aarch64_sve_ldnf1">;
 def SVLDNF1SB_VNUM : MInst<"svldnf1sb_vnum_{d}", "dPSl", "silUsUiUl",       [IsLoad],               MemEltTyInt8,    "aarch64_sve_ldnf1">;
 def SVLDNF1UB_VNUM : MInst<"svldnf1ub_vnum_{d}", "dPWl", "silUsUiUl",       [IsLoad, IsZExtReturn], MemEltTyInt8,    "aarch64_sve_ldnf1">;
 def SVLDNF1SH_VNUM : MInst<"svldnf1sh_vnum_{d}", "dPTl", "ilUiUl",          [IsLoad],               MemEltTyInt16,   "aarch64_sve_ldnf1">;
 def SVLDNF1UH_VNUM : MInst<"svldnf1uh_vnum_{d}", "dPXl", "ilUiUl",          [IsLoad, IsZExtReturn], MemEltTyInt16,   "aarch64_sve_ldnf1">;
 def SVLDNF1SW_VNUM : MInst<"svldnf1sw_vnum_{d}", "dPUl", "lUl",             [IsLoad],               MemEltTyInt32,   "aarch64_sve_ldnf1">;
 def SVLDNF1UW_VNUM : MInst<"svldnf1uw_vnum_{d}", "dPYl", "lUl",             [IsLoad, IsZExtReturn], MemEltTyInt32,   "aarch64_sve_ldnf1">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVLDNF1_BF      : MInst<"svldnf1[_{2}]",      "dPc",  "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ldnf1">;
   def SVLDNF1_VNUM_BF : MInst<"svldnf1_vnum[_{2}]", "dPcl", "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ldnf1">;
 }
 
 // Load one vector, unextended load, non-temporal (scalar base)
 def SVLDNT1 : MInst<"svldnt1[_{2}]", "dPc", "csilUcUsUiUlhfd", [IsLoad], MemEltTyDefault, "aarch64_sve_ldnt1">;
 
 // Load one vector, unextended load, non-temporal (scalar base, VL displacement)
 def SVLDNT1_VNUM : MInst<"svldnt1_vnum[_{2}]", "dPcl", "csilUcUsUiUlhfd", [IsLoad], MemEltTyDefault, "aarch64_sve_ldnt1">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVLDNT1_BF      : MInst<"svldnt1[_{2}]",      "dPc",  "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ldnt1">;
   def SVLDNT1_VNUM_BF : MInst<"svldnt1_vnum[_{2}]", "dPcl", "b", [IsLoad], MemEltTyDefault, "aarch64_sve_ldnt1">;
 }
 
 // Load one quadword and replicate (scalar base)
 def SVLD1RQ : SInst<"svld1rq[_{2}]", "dPc", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_ld1rq">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVLD1RQ_BF : SInst<"svld1rq[_{2}]", "dPc",  "b", MergeNone, "aarch64_sve_ld1rq">;
 }
 
 multiclass StructLoad<string name, string proto, string i> {
   def : SInst<name, proto, "csilUcUsUiUlhfd", MergeNone, i, [IsStructLoad]>;
-  let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+  let TargetGuard = "sve,bf16" in {
     def: SInst<name, proto, "b", MergeNone, i, [IsStructLoad]>;
   }
 }
 
 // Load N-element structure into N vectors (scalar base)
 defm SVLD2 : StructLoad<"svld2[_{2}]", "2Pc", "aarch64_sve_ld2_sret">;
 defm SVLD3 : StructLoad<"svld3[_{2}]", "3Pc", "aarch64_sve_ld3_sret">;
 defm SVLD4 : StructLoad<"svld4[_{2}]", "4Pc", "aarch64_sve_ld4_sret">;
 
 // Load N-element structure into N vectors (scalar base, VL displacement)
 defm SVLD2_VNUM : StructLoad<"svld2_vnum[_{2}]", "2Pcl", "aarch64_sve_ld2_sret">;
 defm SVLD3_VNUM : StructLoad<"svld3_vnum[_{2}]", "3Pcl", "aarch64_sve_ld3_sret">;
 defm SVLD4_VNUM : StructLoad<"svld4_vnum[_{2}]", "4Pcl", "aarch64_sve_ld4_sret">;
 
 // Load one octoword and replicate (scalar base)
-let ArchGuard = "defined(__ARM_FEATURE_SVE_MATMUL_FP64)" in {
+let TargetGuard = "sve,f64mm" in {
   def SVLD1RO : SInst<"svld1ro[_{2}]", "dPc", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_ld1ro">;
 }
-let ArchGuard = "defined(__ARM_FEATURE_SVE_MATMUL_FP64) && defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,f64mm,bf16" in {
   def SVLD1RO_BF16 : SInst<"svld1ro[_{2}]", "dPc", "b", MergeNone, "aarch64_sve_ld1ro">;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVBFDOT        : SInst<"svbfdot[_{0}]",        "MMdd",  "b", MergeNone, "aarch64_sve_bfdot",        [IsOverloadNone]>;
   def SVBFMLALB      : SInst<"svbfmlalb[_{0}]",      "MMdd",  "b", MergeNone, "aarch64_sve_bfmlalb",      [IsOverloadNone]>;
   def SVBFMLALT      : SInst<"svbfmlalt[_{0}]",      "MMdd",  "b", MergeNone, "aarch64_sve_bfmlalt",      [IsOverloadNone]>;
   def SVBFMMLA       : SInst<"svbfmmla[_{0}]",       "MMdd",  "b", MergeNone, "aarch64_sve_bfmmla",       [IsOverloadNone]>;
   def SVBFDOT_N      : SInst<"svbfdot[_n_{0}]",      "MMda",  "b", MergeNone, "aarch64_sve_bfdot",        [IsOverloadNone]>;
   def SVBFMLAL_N     : SInst<"svbfmlalb[_n_{0}]",    "MMda",  "b", MergeNone, "aarch64_sve_bfmlalb",      [IsOverloadNone]>;
   def SVBFMLALT_N    : SInst<"svbfmlalt[_n_{0}]",    "MMda",  "b", MergeNone, "aarch64_sve_bfmlalt",      [IsOverloadNone]>;
   def SVBFDOT_LANE   : SInst<"svbfdot_lane[_{0}]",   "MMddi", "b", MergeNone, "aarch64_sve_bfdot_lane_v2",   [IsOverloadNone], [ImmCheck<3, ImmCheck0_3>]>;

 def SVST1_VNUM    : MInst<"svst1_vnum[_{d}]",  "vPpld", "csilUcUsUiUlhfd", [IsStore], MemEltTyDefault, "aarch64_sve_st1">;
 def SVST1B_VNUM_S : MInst<"svst1b_vnum[_{d}]", "vPAld", "sil",             [IsStore], MemEltTyInt8,    "aarch64_sve_st1">;
 def SVST1B_VNUM_U : MInst<"svst1b_vnum[_{d}]", "vPEld", "UsUiUl",          [IsStore], MemEltTyInt8,    "aarch64_sve_st1">;
 def SVST1H_VNUM_S : MInst<"svst1h_vnum[_{d}]", "vPBld", "il",              [IsStore], MemEltTyInt16,   "aarch64_sve_st1">;
 def SVST1H_VNUM_U : MInst<"svst1h_vnum[_{d}]", "vPFld", "UiUl",            [IsStore], MemEltTyInt16,   "aarch64_sve_st1">;
 def SVST1W_VNUM_S : MInst<"svst1w_vnum[_{d}]", "vPCld", "l",               [IsStore], MemEltTyInt32,   "aarch64_sve_st1">;
 def SVST1W_VNUM_U : MInst<"svst1w_vnum[_{d}]", "vPGld", "Ul",              [IsStore], MemEltTyInt32,   "aarch64_sve_st1">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVST1_BF      : MInst<"svst1[_{d}]",      "vPpd",  "b", [IsStore], MemEltTyDefault, "aarch64_sve_st1">;
   def SVST1_VNUM_BF : MInst<"svst1_vnum[_{d}]", "vPpld", "b", [IsStore], MemEltTyDefault, "aarch64_sve_st1">;
 }
 
 // Store one vector (vector base)
 def SVST1_SCATTER_BASES_U     : MInst<"svst1_scatter[_{2}base_{d}]",  "vPud",  "ilUiUlfd", [IsScatterStore], MemEltTyDefault, "aarch64_sve_st1_scatter_scalar_offset">;
 def SVST1B_SCATTER_BASES_U    : MInst<"svst1b_scatter[_{2}base_{d}]", "vPud",  "ilUiUl",   [IsScatterStore], MemEltTyInt8,    "aarch64_sve_st1_scatter_scalar_offset">;
 def SVST1H_SCATTER_BASES_U    : MInst<"svst1h_scatter[_{2}base_{d}]", "vPud",  "ilUiUl",   [IsScatterStore], MemEltTyInt16,   "aarch64_sve_st1_scatter_scalar_offset">;

 
 // Store one vector (vector base, signed scalar index)
 def SVST1_SCATTER_INDEX_S     : MInst<"svst1_scatter[_{2}base]_index[_{d}]",  "vPuld", "ilUiUlfd", [IsScatterStore], MemEltTyDefault, "aarch64_sve_st1_scatter_scalar_offset">;
 def SVST1H_SCATTER_INDEX_S    : MInst<"svst1h_scatter[_{2}base]_index[_{d}]", "vPuld", "ilUiUl",   [IsScatterStore], MemEltTyInt16,   "aarch64_sve_st1_scatter_scalar_offset">;
 def SVST1W_SCATTER_INDEX_S    : MInst<"svst1w_scatter[_{2}base]_index[_{d}]", "vPuld", "lUl",      [IsScatterStore], MemEltTyInt32,   "aarch64_sve_st1_scatter_scalar_offset">;
 
 multiclass StructStore<string name, string proto, string i> {
   def : SInst<name, proto, "csilUcUsUiUlhfd", MergeNone, i, [IsStructStore]>;
-  let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+  let TargetGuard = "sve,bf16" in {
     def: SInst<name, proto, "b", MergeNone, i, [IsStructStore]>;
   }
 }
 // Store N vectors into N-element structure (scalar base)
 defm SVST2 : StructStore<"svst2[_{d}]", "vPp2", "aarch64_sve_st2">;
 defm SVST3 : StructStore<"svst3[_{d}]", "vPp3", "aarch64_sve_st3">;
 defm SVST4 : StructStore<"svst4[_{d}]", "vPp4", "aarch64_sve_st4">;
 
 // Store N vectors into N-element structure (scalar base, VL displacement)
 defm SVST2_VNUM : StructStore<"svst2_vnum[_{d}]", "vPpl2", "aarch64_sve_st2">;
 defm SVST3_VNUM : StructStore<"svst3_vnum[_{d}]", "vPpl3", "aarch64_sve_st3">;
 defm SVST4_VNUM : StructStore<"svst4_vnum[_{d}]", "vPpl4", "aarch64_sve_st4">;
 
 // Store one vector, with no truncation, non-temporal (scalar base)
 def SVSTNT1 : MInst<"svstnt1[_{d}]", "vPpd", "csilUcUsUiUlhfd", [IsStore], MemEltTyDefault, "aarch64_sve_stnt1">;
 
 // Store one vector, with no truncation, non-temporal (scalar base, VL displacement)
 def SVSTNT1_VNUM : MInst<"svstnt1_vnum[_{d}]", "vPpld", "csilUcUsUiUlhfd", [IsStore], MemEltTyDefault, "aarch64_sve_stnt1">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVSTNT1_BF      : MInst<"svstnt1[_{d}]",      "vPpd",  "b", [IsStore], MemEltTyDefault, "aarch64_sve_stnt1">;
   def SVSTNT1_VNUM_BF : MInst<"svstnt1_vnum[_{d}]", "vPpld", "b", [IsStore], MemEltTyDefault, "aarch64_sve_stnt1">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Prefetches
 
 // Prefetch (Scalar base)

 def SVADRW : SInst<"svadrw[_{0}base]_[{2}]index",  "uud", "ilUiUl", MergeNone, "aarch64_sve_adrw">;
 def SVADRD : SInst<"svadrd[_{0}base]_[{2}]index",  "uud", "ilUiUl", MergeNone, "aarch64_sve_adrd">;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Scalar to vector
 
 def SVDUPQ_8  : SInst<"svdupq[_n]_{d}", "dssssssssssssssss",  "cUc", MergeNone>;
 def SVDUPQ_16 : SInst<"svdupq[_n]_{d}", "dssssssss",  "sUsh", MergeNone>;
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVDUPQ_BF16 : SInst<"svdupq[_n]_{d}", "dssssssss",  "b", MergeNone>;
 }
 def SVDUPQ_32 : SInst<"svdupq[_n]_{d}", "dssss",  "iUif", MergeNone>;
 def SVDUPQ_64 : SInst<"svdupq[_n]_{d}", "dss",  "lUld", MergeNone>;
 
 multiclass svdup_base<string n, string p, MergeType mt, string i> {
   def NAME : SInst<n, p, "csilUcUsUiUlhfd", mt, i>;
-  let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+  let TargetGuard = "sve,bf16" in {
     def _BF16: SInst<n, p, "b", mt, i>;
   }
 }
 
 defm SVDUP   : svdup_base<"svdup[_n]_{d}", "ds",   MergeNone,    "aarch64_sve_dup_x">;
 defm SVDUP_M : svdup_base<"svdup[_n]_{d}", "ddPs", MergeOp1,     "aarch64_sve_dup">;
 defm SVDUP_X : svdup_base<"svdup[_n]_{d}", "dPs",  MergeAnyExp,  "aarch64_sve_dup">;
 defm SVDUP_Z : svdup_base<"svdup[_n]_{d}", "dPs",  MergeZeroExp, "aarch64_sve_dup">;

 defm SVLSL : SInst_SHIFT<"svlsl", "aarch64_sve_lsl", "csilUcUsUiUl", "csiUcUsUi">;
 defm SVLSR : SInst_SHIFT<"svlsr", "aarch64_sve_lsr", "UcUsUiUl", "UcUsUi">;
 
 def SVASRD_M : SInst<"svasrd[_n_{d}]", "dPdi", "csil",            MergeOp1,  "aarch64_sve_asrd", [], [ImmCheck<2, ImmCheckShiftRight, 1>]>;
 def SVASRD_X : SInst<"svasrd[_n_{d}]", "dPdi", "csil",            MergeAny,  "aarch64_sve_asrd", [], [ImmCheck<2, ImmCheckShiftRight, 1>]>;
 def SVASRD_Z : SInst<"svasrd[_n_{d}]", "dPdi", "csil",            MergeZero, "aarch64_sve_asrd", [], [ImmCheck<2, ImmCheckShiftRight, 1>]>;
 
 def SVINSR : SInst<"svinsr[_n_{d}]", "dds", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_insr">;
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVINSR_BF16 : SInst<"svinsr[_n_{d}]", "dds",  "b", MergeNone, "aarch64_sve_insr">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Integer reductions
 
 def SVADDV_S : SInst<"svaddv[_{d}]", "lPd", "csil",         MergeNone, "aarch64_sve_saddv">;
 def SVADDV_U : SInst<"svaddv[_{d}]", "nPd", "UcUsUiUl",     MergeNone, "aarch64_sve_uaddv">;
multiclass SInstCLS<string name, string types, string intrinsic, list<FlagType> flags=[]> {
   def _X : SInst<name # "[_{d}]", "uPd",  types, MergeAnyExp,  intrinsic, flags>;
   def _Z : SInst<name # "[_{d}]", "uPd",  types, MergeZeroExp, intrinsic, flags>;
 }
 
 defm SVCLS : SInstCLS<"svcls", "csil",            "aarch64_sve_cls">;
 defm SVCLZ : SInstCLS<"svclz", "csilUcUsUiUl",    "aarch64_sve_clz">;
 defm SVCNT : SInstCLS<"svcnt", "csilUcUsUiUlhfd", "aarch64_sve_cnt">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   defm SVCNT_BF16 : SInstCLS<"svcnt", "b", "aarch64_sve_cnt">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Conversion
 
 defm SVEXTB_S : SInstZPZ<"svextb", "sil",    "aarch64_sve_sxtb">;
 defm SVEXTB_U : SInstZPZ<"svextb", "UsUiUl", "aarch64_sve_uxtb">;

 defm SVFCVTZS_S16_F16 : SInstCvtMXZ<"svcvt_s16[_f16]", "ddPO", "dPO", "s",  "aarch64_sve_fcvtzs", [IsOverloadCvt]>;
 defm SVFCVTZS_S32_F16 : SInstCvtMXZ<"svcvt_s32[_f16]", "ddPO", "dPO", "i",  "aarch64_sve_fcvtzs_i32f16">;
 defm SVFCVTZS_S64_F16 : SInstCvtMXZ<"svcvt_s64[_f16]", "ddPO", "dPO", "l",  "aarch64_sve_fcvtzs_i64f16">;
 
 // svcvt_s##_f32
 defm SVFCVTZS_S32_F32 : SInstCvtMXZ<"svcvt_s32[_f32]", "ddPM", "dPM", "i",  "aarch64_sve_fcvtzs", [IsOverloadCvt]>;
 defm SVFCVTZS_S64_F32 : SInstCvtMXZ<"svcvt_s64[_f32]", "ddPM", "dPM", "l",  "aarch64_sve_fcvtzs_i64f32">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   defm SVCVT_BF16_F32   : SInstCvtMXZ<"svcvt_bf16[_f32]",  "ddPM", "dPM", "b",  "aarch64_sve_fcvt_bf16f32">;
   def SVCVTNT_BF16_F32 : SInst<"svcvtnt_bf16[_f32]", "ddPM", "b",  MergeOp1, "aarch64_sve_fcvtnt_bf16f32", [IsOverloadNone]>;
 }
 
 // svcvt_s##_f64
 defm SVFCVTZS_S32_F64 : SInstCvtMXZ<"svcvt_s32[_f64]", "ttPd", "tPd", "d",  "aarch64_sve_fcvtzs_i32f64">;
 defm SVFCVTZS_S64_F64 : SInstCvtMXZ<"svcvt_s64[_f64]", "ddPN", "dPN", "l",  "aarch64_sve_fcvtzs", [IsOverloadCvt]>;
 

 // svcvt_f32_f##
 defm SVFCVT_F32_F16   : SInstCvtMXZ<"svcvt_f32[_f16]", "ddPO", "dPO", "f", "aarch64_sve_fcvt_f32f16">;
 defm SVFCVT_F32_F64   : SInstCvtMXZ<"svcvt_f32[_f64]", "MMPd", "MPd", "d", "aarch64_sve_fcvt_f32f64">;
 
 // svcvt_f64_f##
 defm SVFCVT_F64_F16   : SInstCvtMXZ<"svcvt_f64[_f16]", "ddPO", "dPO", "d", "aarch64_sve_fcvt_f64f16">;
 defm SVFCVT_F64_F32   : SInstCvtMXZ<"svcvt_f64[_f32]", "ddPM", "dPM", "d", "aarch64_sve_fcvt_f64f32">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 defm SVCVTLT_F32    : SInstCvtMX<"svcvtlt_f32[_f16]",  "ddPh", "dPh", "f", "aarch64_sve_fcvtlt_f32f16">;
 defm SVCVTLT_F64    : SInstCvtMX<"svcvtlt_f64[_f32]",  "ddPh", "dPh", "d", "aarch64_sve_fcvtlt_f64f32">;
 
 defm SVCVTX_F32     : SInstCvtMXZ<"svcvtx_f32[_f64]",  "MMPd", "MPd", "d", "aarch64_sve_fcvtx_f32f64">;
 
 def SVCVTNT_F32     : SInst<"svcvtnt_f16[_f32]",  "hhPd", "f", MergeOp1, "aarch64_sve_fcvtnt_f16f32", [IsOverloadNone]>;
 def SVCVTNT_F64     : SInst<"svcvtnt_f32[_f64]",  "hhPd", "d", MergeOp1, "aarch64_sve_fcvtnt_f32f64", [IsOverloadNone]>;
 //  SVCVTNT_X       : Implemented as macro by SveEmitter.cpp
 
 def SVCVTXNT_F32    : SInst<"svcvtxnt_f32[_f64]", "MMPd", "d", MergeOp1, "aarch64_sve_fcvtxnt_f32f64", [IsOverloadNone]>;
 //  SVCVTXNT_X_F32  : Implemented as macro by SveEmitter.cpp
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Permutations and selection
 
 multiclass SVEPerm<string name, string proto, string i> {
   def : SInst<name, proto, "csilUcUsUiUlhfd", MergeNone, i>;
-  let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+  let TargetGuard = "sve,bf16" in {
     def: SInst<name, proto, "b", MergeNone, i>;
   }
 }
 
 defm SVCLASTA    : SVEPerm<"svclasta[_{d}]",   "dPdd", "aarch64_sve_clasta">;
 defm SVCLASTA_N  : SVEPerm<"svclasta[_n_{d}]", "sPsd", "aarch64_sve_clasta_n">;
 defm SVCLASTB    : SVEPerm<"svclastb[_{d}]",   "dPdd", "aarch64_sve_clastb">;
 defm SVCLASTB_N  : SVEPerm<"svclastb[_n_{d}]", "sPsd", "aarch64_sve_clastb_n">;
 
 def SVCOMPACT    : SInst<"svcompact[_{d}]",   "dPd",  "ilUiUlfd",        MergeNone, "aarch64_sve_compact">;
 // Note: svdup_lane is implemented using the intrinsic for TBL to represent a
 // splat of any possible lane. It is upto LLVM to pick a more efficient
 // instruction such as DUP (indexed) if the lane index fits the range of the
 // instruction's immediate.
 def SVDUP_LANE   : SInst<"svdup_lane[_{d}]",  "ddL",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_tbl">;
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
 def SVDUP_LANE_BF16 :
                    SInst<"svdup_lane[_{d}]",  "ddL",  "b",               MergeNone, "aarch64_sve_tbl">;
 }
 
 def SVDUPQ_LANE  : SInst<"svdupq_lane[_{d}]", "ddn",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_dupq_lane">;
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVDUPQ_LANE_BF16  : SInst<"svdupq_lane[_{d}]", "ddn",  "b", MergeNone, "aarch64_sve_dupq_lane">;
 }
 def SVEXT        : SInst<"svext[_{d}]",       "dddi", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_ext", [], [ImmCheck<2, ImmCheckExtract, 1>]>;
 defm SVLASTA     : SVEPerm<"svlasta[_{d}]",   "sPd",  "aarch64_sve_lasta">;
 defm SVLASTB     : SVEPerm<"svlastb[_{d}]",   "sPd",  "aarch64_sve_lastb">;
 def SVREV        : SInst<"svrev[_{d}]",       "dd",   "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_rev">;
 def SVSEL        : SInst<"svsel[_{d}]",       "dPdd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_sel">;
 def SVSPLICE     : SInst<"svsplice[_{d}]",    "dPdd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_splice">;
 def SVTBL        : SInst<"svtbl[_{d}]",       "ddu",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_tbl">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
   def SVTBL_BF16 : SInst<"svtbl[_{d}]",       "ddu",  "b",               MergeNone, "aarch64_sve_tbl">;
 }
 
 def SVTRN1       : SInst<"svtrn1[_{d}]",      "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_trn1">;
 def SVTRN2       : SInst<"svtrn2[_{d}]",      "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_trn2">;
 def SVUNPKHI_S   : SInst<"svunpkhi[_{d}]",    "dh",   "sil",             MergeNone, "aarch64_sve_sunpkhi">;
 def SVUNPKHI_U   : SInst<"svunpkhi[_{d}]",    "dh",   "UsUiUl",          MergeNone, "aarch64_sve_uunpkhi">;
 def SVUNPKLO_S   : SInst<"svunpklo[_{d}]",    "dh",   "sil",             MergeNone, "aarch64_sve_sunpklo">;
 def SVUNPKLO_U   : SInst<"svunpklo[_{d}]",    "dh",   "UsUiUl",          MergeNone, "aarch64_sve_uunpklo">;
 def SVUZP1       : SInst<"svuzp1[_{d}]",      "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_uzp1">;
 def SVUZP2       : SInst<"svuzp2[_{d}]",      "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_uzp2">;
 def SVZIP1       : SInst<"svzip1[_{d}]",      "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_zip1">;
 def SVZIP2       : SInst<"svzip2[_{d}]",      "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_zip2">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
 def SVEXT_BF16    : SInst<"svext[_{d}]",    "dddi", "b", MergeNone, "aarch64_sve_ext", [], [ImmCheck<2, ImmCheckExtract, 1>]>;
 def SVREV_BF16    : SInst<"svrev[_{d}]",    "dd",   "b", MergeNone, "aarch64_sve_rev">;
 def SVSEL_BF16    : SInst<"svsel[_{d}]",    "dPdd", "b", MergeNone, "aarch64_sve_sel">;
 def SVSPLICE_BF16 : SInst<"svsplice[_{d}]", "dPdd", "b", MergeNone, "aarch64_sve_splice">;
 def SVTRN1_BF16   : SInst<"svtrn1[_{d}]",   "ddd",  "b", MergeNone, "aarch64_sve_trn1">;
 def SVTRN2_BF16   : SInst<"svtrn2[_{d}]",   "ddd",  "b", MergeNone, "aarch64_sve_trn2">;
 def SVUZP1_BF16   : SInst<"svuzp1[_{d}]",   "ddd",  "b", MergeNone, "aarch64_sve_uzp1">;
 def SVUZP2_BF16   : SInst<"svuzp2[_{d}]",   "ddd",  "b", MergeNone, "aarch64_sve_uzp2">;

 def SVCNTB : SInst<"svcntb", "nv", "", MergeNone, "aarch64_sve_cntb", [IsAppendSVALL, IsOverloadNone]>;
 def SVCNTH : SInst<"svcnth", "nv", "", MergeNone, "aarch64_sve_cnth", [IsAppendSVALL, IsOverloadNone]>;
 def SVCNTW : SInst<"svcntw", "nv", "", MergeNone, "aarch64_sve_cntw", [IsAppendSVALL, IsOverloadNone]>;
 def SVCNTD : SInst<"svcntd", "nv", "", MergeNone, "aarch64_sve_cntd", [IsAppendSVALL, IsOverloadNone]>;
 
 def SVCNTP : SInst<"svcntp_{d}",  "nPP", "PcPsPiPl",        MergeNone, "aarch64_sve_cntp">;
 def SVLEN  : SInst<"svlen[_{d}]", "nd",  "csilUcUsUiUlhfd", MergeNone>;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
 def SVLEN_BF16 : SInst<"svlen[_{d}]", "nd", "b", MergeNone>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Saturating scalar arithmetic
 
 class sat_type<string u, string t> { string U = u; string T = t; }
 def SignedByte         : sat_type<"",  "c">;

 def SVQDECP_N_S64 : SInst<"svqdecp[_n_s64]_{d}", "llP", "PcPsPiPl", MergeNone, "aarch64_sve_sqdecp_n64">;
 def SVQDECP_N_U32 : SInst<"svqdecp[_n_u32]_{d}", "mmP", "PcPsPiPl", MergeNone, "aarch64_sve_uqdecp_n32">;
 def SVQDECP_N_U64 : SInst<"svqdecp[_n_u64]_{d}", "nnP", "PcPsPiPl", MergeNone, "aarch64_sve_uqdecp_n64">;
 def SVQINCP_N_S32 : SInst<"svqincp[_n_s32]_{d}", "kkP", "PcPsPiPl", MergeNone, "aarch64_sve_sqincp_n32">;
 def SVQINCP_N_S64 : SInst<"svqincp[_n_s64]_{d}", "llP", "PcPsPiPl", MergeNone, "aarch64_sve_sqincp_n64">;
 def SVQINCP_N_U32 : SInst<"svqincp[_n_u32]_{d}", "mmP", "PcPsPiPl", MergeNone, "aarch64_sve_uqincp_n32">;
 def SVQINCP_N_U64 : SInst<"svqincp[_n_u64]_{d}", "nnP", "PcPsPiPl", MergeNone, "aarch64_sve_uqincp_n64">;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_MATMUL_INT8)" in {
+let TargetGuard = "sve,i8mm" in {
 def SVMLLA_S32   : SInst<"svmmla[_s32]",   "ddqq","i",  MergeNone, "aarch64_sve_smmla">;
 def SVMLLA_U32   : SInst<"svmmla[_u32]",   "ddqq","Ui", MergeNone, "aarch64_sve_ummla">;
 def SVUSMLLA_S32 : SInst<"svusmmla[_s32]", "ddbq","i",  MergeNone, "aarch64_sve_usmmla">;
 
 def SVUSDOT_S    : SInst<"svusdot[_s32]",    "ddbq", "i",       MergeNone, "aarch64_sve_usdot">;
 def SVUSDOT_N_S  : SInst<"svusdot[_n_s32]",  "ddbr", "i",       MergeNone, "aarch64_sve_usdot">;
 def SVSUDOT_S    : SInst<"svsudot[_s32]",    "ddqb", "i",       MergeNone, "aarch64_sve_usdot", [ReverseUSDOT]>;
 def SVSUDOT_N_S  : SInst<"svsudot[_n_s32]",  "ddq@", "i",       MergeNone, "aarch64_sve_usdot", [ReverseUSDOT]>;
 
 def SVUSDOT_LANE_S : SInst<"svusdot_lane[_s32]",  "ddbqi",  "i",   MergeNone, "aarch64_sve_usdot_lane", [], [ImmCheck<3, ImmCheckLaneIndexDot, 2>]>;
 def SVSUDOT_LANE_S : SInst<"svsudot_lane[_s32]",  "ddqbi",  "i",   MergeNone, "aarch64_sve_sudot_lane", [], [ImmCheck<3, ImmCheckLaneIndexDot, 2>]>;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_MATMUL_FP32)" in {
+let TargetGuard = "sve,f32mm" in {
 def SVMLLA_F32 : SInst<"svmmla[_f32]", "dddd","f", MergeNone, "aarch64_sve_fmmla">;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_MATMUL_FP64)" in {
+let TargetGuard = "sve,f64mm" in {
 def SVMLLA_F64 : SInst<"svmmla[_f64]", "dddd","d", MergeNone, "aarch64_sve_fmmla">;
 def SVTRN1Q      : SInst<"svtrn1q[_{d}]",     "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_trn1q">;
 def SVTRN2Q      : SInst<"svtrn2q[_{d}]",     "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_trn2q">;
 def SVUZP1Q      : SInst<"svuzp1q[_{d}]",     "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_uzp1q">;
 def SVUZP2Q      : SInst<"svuzp2q[_{d}]",     "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_uzp2q">;
 def SVZIP1Q      : SInst<"svzip1q[_{d}]",     "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_zip1q">;
 def SVZIP2Q      : SInst<"svzip2q[_{d}]",     "ddd",  "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_zip2q">;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_MATMUL_FP64) && defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16,f64mm" in {
 def SVTRN1Q_BF16      : SInst<"svtrn1q[_{d}]",     "ddd",  "b", MergeNone, "aarch64_sve_trn1q">;
 def SVTRN2Q_BF16      : SInst<"svtrn2q[_{d}]",     "ddd",  "b", MergeNone, "aarch64_sve_trn2q">;
 def SVUZP1Q_BF16      : SInst<"svuzp1q[_{d}]",     "ddd",  "b", MergeNone, "aarch64_sve_uzp1q">;
 def SVUZP2Q_BF16      : SInst<"svuzp2q[_{d}]",     "ddd",  "b", MergeNone, "aarch64_sve_uzp2q">;
 def SVZIP1Q_BF16      : SInst<"svzip1q[_{d}]",     "ddd",  "b", MergeNone, "aarch64_sve_zip1q">;
 def SVZIP2Q_BF16      : SInst<"svzip2q[_{d}]",     "ddd",  "b", MergeNone, "aarch64_sve_zip2q">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Vector creation
 def SVUNDEF_1 : SInst<"svundef_{d}",  "dv", "csilUcUsUiUlhfd", MergeNone, "", [IsUndef]>;
 def SVUNDEF_2 : SInst<"svundef2_{d}", "2v", "csilUcUsUiUlhfd", MergeNone, "", [IsUndef]>;
 def SVUNDEF_3 : SInst<"svundef3_{d}", "3v", "csilUcUsUiUlhfd", MergeNone, "", [IsUndef]>;
 def SVUNDEF_4 : SInst<"svundef4_{d}", "4v", "csilUcUsUiUlhfd", MergeNone, "", [IsUndef]>;
 
 def SVCREATE_2 : SInst<"svcreate2[_{d}]", "2dd",   "csilUcUsUiUlhfd", MergeNone, "", [IsTupleCreate]>;
 def SVCREATE_3 : SInst<"svcreate3[_{d}]", "3ddd",  "csilUcUsUiUlhfd", MergeNone, "", [IsTupleCreate]>;
 def SVCREATE_4 : SInst<"svcreate4[_{d}]", "4dddd", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleCreate]>;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
 def SVUNDEF_1_BF16 : SInst<"svundef_{d}",  "dv", "b", MergeNone, "", [IsUndef]>;
 def SVUNDEF_2_BF16 : SInst<"svundef2_{d}", "2v", "b", MergeNone, "", [IsUndef]>;
 def SVUNDEF_3_BF16 : SInst<"svundef3_{d}", "3v", "b", MergeNone, "", [IsUndef]>;
 def SVUNDEF_4_BF16 : SInst<"svundef4_{d}", "4v", "b", MergeNone, "", [IsUndef]>;
 
 def SVCREATE_2_BF16 : SInst<"svcreate2[_{d}]", "2dd",   "b", MergeNone, "", [IsTupleCreate]>;
 def SVCREATE_3_BF16 : SInst<"svcreate3[_{d}]", "3ddd",  "b", MergeNone, "", [IsTupleCreate]>;
 def SVCREATE_4_BF16 : SInst<"svcreate4[_{d}]", "4dddd", "b", MergeNone, "", [IsTupleCreate]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Vector insertion and extraction
 def SVGET_2 : SInst<"svget2[_{d}]", "d2i", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleGet], [ImmCheck<1, ImmCheck0_1>]>;
 def SVGET_3 : SInst<"svget3[_{d}]", "d3i", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleGet], [ImmCheck<1, ImmCheck0_2>]>;
 def SVGET_4 : SInst<"svget4[_{d}]", "d4i", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleGet], [ImmCheck<1, ImmCheck0_3>]>;
 
 def SVSET_2 : SInst<"svset2[_{d}]", "22id", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleSet], [ImmCheck<1, ImmCheck0_1>]>;
 def SVSET_3 : SInst<"svset3[_{d}]", "33id", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleSet], [ImmCheck<1, ImmCheck0_2>]>;
 def SVSET_4 : SInst<"svset4[_{d}]", "44id", "csilUcUsUiUlhfd", MergeNone, "", [IsTupleSet], [ImmCheck<1, ImmCheck0_3>]>;
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve,bf16" in {
 def SVGET_2_BF16 : SInst<"svget2[_{d}]", "d2i", "b", MergeNone, "", [IsTupleGet], [ImmCheck<1, ImmCheck0_1>]>;
 def SVGET_3_BF16 : SInst<"svget3[_{d}]", "d3i", "b", MergeNone, "", [IsTupleGet], [ImmCheck<1, ImmCheck0_2>]>;
 def SVGET_4_BF16 : SInst<"svget4[_{d}]", "d4i", "b", MergeNone, "", [IsTupleGet], [ImmCheck<1, ImmCheck0_3>]>;
 
 def SVSET_2_BF16 : SInst<"svset2[_{d}]", "22id", "b", MergeNone, "", [IsTupleSet], [ImmCheck<1, ImmCheck0_1>]>;
 def SVSET_3_BF16 : SInst<"svset3[_{d}]", "33id", "b", MergeNone, "", [IsTupleSet], [ImmCheck<1, ImmCheck0_2>]>;
 def SVSET_4_BF16 : SInst<"svset4[_{d}]", "44id", "b", MergeNone, "", [IsTupleSet], [ImmCheck<1, ImmCheck0_3>]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 WhileGE/GT
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVWHILEGE_S32 : SInst<"svwhilege_{d}[_{1}]", "Pkk", "PcPsPiPl",     MergeNone, "aarch64_sve_whilege", [IsOverloadWhile]>;
 def SVWHILEGE_S64 : SInst<"svwhilege_{d}[_{1}]", "Pll", "PcPsPiPl",     MergeNone, "aarch64_sve_whilege", [IsOverloadWhile]>;
 def SVWHILEGT_S32 : SInst<"svwhilegt_{d}[_{1}]", "Pkk", "PcPsPiPl",     MergeNone, "aarch64_sve_whilegt", [IsOverloadWhile]>;
 def SVWHILEGT_S64 : SInst<"svwhilegt_{d}[_{1}]", "Pll", "PcPsPiPl",     MergeNone, "aarch64_sve_whilegt", [IsOverloadWhile]>;
 def SVWHILEHI_U32 : SInst<"svwhilegt_{d}[_{1}]", "Pmm", "PUcPUsPUiPUl", MergeNone, "aarch64_sve_whilehi", [IsOverloadWhile]>;
 def SVWHILEHI_U64 : SInst<"svwhilegt_{d}[_{1}]", "Pnn", "PUcPUsPUiPUl", MergeNone, "aarch64_sve_whilehi", [IsOverloadWhile]>;
 def SVWHILEHS_U32 : SInst<"svwhilege_{d}[_{1}]", "Pmm", "PUcPUsPUiPUl", MergeNone, "aarch64_sve_whilehs", [IsOverloadWhile]>;
 def SVWHILEHS_U64 : SInst<"svwhilege_{d}[_{1}]", "Pnn", "PUcPUsPUiPUl", MergeNone, "aarch64_sve_whilehs", [IsOverloadWhile]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Uniform DSP operations
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 defm SVQADD_S  : SInstZPZZ<"svqadd",  "csli",     "aarch64_sve_sqadd">;
 defm SVQADD_U  : SInstZPZZ<"svqadd",  "UcUsUiUl", "aarch64_sve_uqadd">;
 defm SVHADD_S  : SInstZPZZ<"svhadd",  "csli",     "aarch64_sve_shadd">;
 defm SVHADD_U  : SInstZPZZ<"svhadd",  "UcUsUiUl", "aarch64_sve_uhadd">;
 defm SVRHADD_S : SInstZPZZ<"svrhadd", "csli",     "aarch64_sve_srhadd">;
 defm SVRHADD_U : SInstZPZZ<"svrhadd", "UcUsUiUl", "aarch64_sve_urhadd">;
 
 defm SVQSUB_S  : SInstZPZZ<"svqsub",  "csli",     "aarch64_sve_sqsub">;
multiclass SInstZPZxZ<string name, string types, string pat_v, string pat_n, string intrinsic, list<FlagType> flags=[]> {
   def _X   : SInst<name # "[_{d}]", pat_v, types, MergeAny,  intrinsic, flags>;
   def _Z   : SInst<name # "[_{d}]", pat_v, types, MergeZero, intrinsic, flags>;
 
   def _N_M : SInst<name # "[_n_{d}]", pat_n, types, MergeOp1,  intrinsic, flags>;
   def _N_X : SInst<name # "[_n_{d}]", pat_n, types, MergeAny,  intrinsic, flags>;
   def _N_Z : SInst<name # "[_n_{d}]", pat_n, types, MergeZero, intrinsic, flags>;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 defm SVQRSHL_S : SInstZPZxZ<"svqrshl", "csil",     "dPdx", "dPdK", "aarch64_sve_sqrshl">;
 defm SVQRSHL_U : SInstZPZxZ<"svqrshl", "UcUsUiUl", "dPdx", "dPdK", "aarch64_sve_uqrshl">;
 defm SVQSHL_S  : SInstZPZxZ<"svqshl",  "csil",     "dPdx", "dPdK", "aarch64_sve_sqshl">;
 defm SVQSHL_U  : SInstZPZxZ<"svqshl",  "UcUsUiUl", "dPdx", "dPdK", "aarch64_sve_uqshl">;
 defm SVRSHL_S  : SInstZPZxZ<"svrshl",  "csil",     "dPdx", "dPdK", "aarch64_sve_srshl">;
 defm SVRSHL_U  : SInstZPZxZ<"svrshl",  "UcUsUiUl", "dPdx", "dPdK", "aarch64_sve_urshl">;
 defm SVSQADD   : SInstZPZxZ<"svsqadd", "UcUsUiUl", "dPdx", "dPdK", "aarch64_sve_usqadd">;
 defm SVUQADD   : SInstZPZxZ<"svuqadd", "csil",     "dPdu", "dPdL", "aarch64_sve_suqadd">;

 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Non-widening pairwise arithmetic
 
 multiclass SInstPairwise<string name, string types, string intrinsic, list<FlagType> flags=[]> {
   def _M   : SInst<name # "[_{d}]", "dPdd", types, MergeOp1, intrinsic, flags>;
   def _X   : SInst<name # "[_{d}]", "dPdd", types, MergeAny, intrinsic, flags>;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 defm SVADDP   : SInstPairwise<"svaddp",   "csliUcUsUiUl", "aarch64_sve_addp">;
 defm SVADDP_F : SInstPairwise<"svaddp",   "hfd",          "aarch64_sve_faddp">;
 defm SVMAXNMP : SInstPairwise<"svmaxnmp", "hfd",          "aarch64_sve_fmaxnmp">;
 defm SVMAXP_F : SInstPairwise<"svmaxp",   "hfd",          "aarch64_sve_fmaxp">;
 defm SVMAXP_S : SInstPairwise<"svmaxp",   "csli",         "aarch64_sve_smaxp">;
 defm SVMAXP_U : SInstPairwise<"svmaxp",   "UcUsUiUl",     "aarch64_sve_umaxp">;
 defm SVMINNMP : SInstPairwise<"svminnmp", "hfd",          "aarch64_sve_fminnmp">;
 defm SVMINP_F : SInstPairwise<"svminp",   "hfd",          "aarch64_sve_fminp">;
 defm SVMINP_S : SInstPairwise<"svminp",   "csli",         "aarch64_sve_sminp">;
 defm SVMINP_U : SInstPairwise<"svminp",   "UcUsUiUl",     "aarch64_sve_uminp">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Widening pairwise arithmetic
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVADALP_S_M : SInst<"svadalp[_{d}]", "dPdh", "sil",    MergeOp1,  "aarch64_sve_sadalp">;
 def SVADALP_S_X : SInst<"svadalp[_{d}]", "dPdh", "sil",    MergeAny,  "aarch64_sve_sadalp">;
 def SVADALP_S_Z : SInst<"svadalp[_{d}]", "dPdh", "sil",    MergeZero, "aarch64_sve_sadalp">;
 
 def SVADALP_U_M : SInst<"svadalp[_{d}]", "dPdh", "UsUiUl", MergeOp1,  "aarch64_sve_uadalp">;
 def SVADALP_U_X : SInst<"svadalp[_{d}]", "dPdh", "UsUiUl", MergeAny,  "aarch64_sve_uadalp">;
 def SVADALP_U_Z : SInst<"svadalp[_{d}]", "dPdh", "UsUiUl", MergeZero, "aarch64_sve_uadalp">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Bitwise ternary logical instructions
 //
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVBCAX  : SInst<"svbcax[_{d}]",  "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bcax">;
 def SVBSL   : SInst<"svbsl[_{d}]",   "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl">;
 def SVBSL1N : SInst<"svbsl1n[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl1n">;
 def SVBSL2N : SInst<"svbsl2n[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl2n">;
 def SVEOR3  : SInst<"sveor3[_{d}]",  "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eor3">;
 def SVNBSL  : SInst<"svnbsl[_{d}]",  "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_nbsl">;
 
 def SVBCAX_N  : SInst<"svbcax[_n_{d}]",  "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_bcax">;
 def SVBSL_N   : SInst<"svbsl[_n_{d}]",   "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl">;
 def SVBSL1N_N : SInst<"svbsl1n[_n_{d}]", "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl1n">;
 def SVBSL2N_N : SInst<"svbsl2n[_n_{d}]", "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl2n">;
 def SVEOR3_N  : SInst<"sveor3[_n_{d}]",  "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_eor3">;
 def SVNBSL_N  : SInst<"svnbsl[_n_{d}]",  "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_nbsl">;
 def SVXAR_N   : SInst<"svxar[_n_{d}]",   "dddi", "csilUcUsUiUl", MergeNone, "aarch64_sve_xar", [], [ImmCheck<2, ImmCheckShiftRight, 1>]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Large integer arithmetic
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVADCLB : SInst<"svadclb[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_adclb">;
 def SVADCLT : SInst<"svadclt[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_adclt">;
 def SVSBCLB : SInst<"svsbclb[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_sbclb">;
 def SVSBCLT : SInst<"svsbclt[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_sbclt">;
 
 def SVADCLB_N : SInst<"svadclb[_n_{d}]", "ddda", "UiUl", MergeNone, "aarch64_sve_adclb">;
 def SVADCLT_N : SInst<"svadclt[_n_{d}]", "ddda", "UiUl", MergeNone, "aarch64_sve_adclt">;
 def SVSBCLB_N : SInst<"svsbclb[_n_{d}]", "ddda", "UiUl", MergeNone, "aarch64_sve_sbclb">;
 def SVSBCLT_N : SInst<"svsbclt[_n_{d}]", "ddda", "UiUl", MergeNone, "aarch64_sve_sbclt">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Multiplication by indexed elements
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVMLA_LANE_2 : SInst<"svmla_lane[_{d}]", "ddddi", "silUsUiUl", MergeNone, "aarch64_sve_mla_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 def SVMLS_LANE_2 : SInst<"svmls_lane[_{d}]", "ddddi", "silUsUiUl", MergeNone, "aarch64_sve_mls_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 def SVMUL_LANE_2 : SInst<"svmul_lane[_{d}]", "dddi",  "silUsUiUl", MergeNone, "aarch64_sve_mul_lane", [], [ImmCheck<2, ImmCheckLaneIndex, 1>]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Uniform complex integer arithmetic
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVCADD             : SInst<"svcadd[_{d}]",          "dddi",   "csilUcUsUiUl", MergeNone, "aarch64_sve_cadd_x",           [], [ImmCheck<2, ImmCheckComplexRot90_270>]>;
 def SVSQCADD           : SInst<"svqcadd[_{d}]",         "dddi",   "csil",         MergeNone, "aarch64_sve_sqcadd_x",         [], [ImmCheck<2, ImmCheckComplexRot90_270>]>;
 def SVCMLA             : SInst<"svcmla[_{d}]",          "ddddi",  "csilUcUsUiUl", MergeNone, "aarch64_sve_cmla_x",           [], [ImmCheck<3, ImmCheckComplexRotAll90>]>;
 def SVCMLA_LANE_X      : SInst<"svcmla_lane[_{d}]",     "ddddii", "siUsUi",       MergeNone, "aarch64_sve_cmla_lane_x",      [], [ImmCheck<3, ImmCheckLaneIndexCompRotate, 2>,
                                                                                                                                   ImmCheck<4, ImmCheckComplexRotAll90>]>;
 def SVSQRDCMLAH_X      : SInst<"svqrdcmlah[_{d}]",      "ddddi",  "csil",         MergeNone, "aarch64_sve_sqrdcmlah_x",      [], [ImmCheck<3, ImmCheckComplexRotAll90>]>;
 def SVSQRDCMLAH_LANE_X : SInst<"svqrdcmlah_lane[_{d}]", "ddddii", "si",           MergeNone, "aarch64_sve_sqrdcmlah_lane_x", [], [ImmCheck<3, ImmCheckLaneIndexCompRotate, 2>,
                                                                                                                                   ImmCheck<4, ImmCheckComplexRotAll90>]>;
multiclass SInstWideDSPLong<string name, string types, string intrinsic> {
   def _N : SInst<name # "[_n_{d}]", "dhR", types, MergeNone, intrinsic>;
 }
 
 multiclass SInstWideDSPWide<string name, string types, string intrinsic> {
   def    : SInst<name # "[_{d}]",   "ddh", types, MergeNone, intrinsic>;
   def _N : SInst<name # "[_n_{d}]", "ddR", types, MergeNone, intrinsic>;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 defm SVABALB_S : SInstWideDSPAcc<"svabalb",   "sil",    "aarch64_sve_sabalb">;
 defm SVABALB_U : SInstWideDSPAcc<"svabalb",   "UsUiUl", "aarch64_sve_uabalb">;
 defm SVABALT_S : SInstWideDSPAcc<"svabalt",   "sil",    "aarch64_sve_sabalt">;
 defm SVABALT_U : SInstWideDSPAcc<"svabalt",   "UsUiUl", "aarch64_sve_uabalt">;
 defm SVMLALB_S : SInstWideDSPAcc<"svmlalb",   "sil",    "aarch64_sve_smlalb">;
 defm SVMLALB_U : SInstWideDSPAcc<"svmlalb",   "UsUiUl", "aarch64_sve_umlalb">;
 defm SVMLALT_S : SInstWideDSPAcc<"svmlalt",   "sil",    "aarch64_sve_smlalt">;
 defm SVMLALT_U : SInstWideDSPAcc<"svmlalt",   "UsUiUl", "aarch64_sve_umlalt">;

 def SVQDMLSLT_LANE : SInst<"svqdmlslt_lane[_{d}]", "ddhhi", "il",   MergeNone, "aarch64_sve_sqdmlslt_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 def SVQDMULLB_LANE : SInst<"svqdmullb_lane[_{d}]", "dhhi",  "il",   MergeNone, "aarch64_sve_sqdmullb_lane", [], [ImmCheck<2, ImmCheckLaneIndex, 1>]>;
 def SVQDMULLT_LANE : SInst<"svqdmullt_lane[_{d}]", "dhhi",  "il",   MergeNone, "aarch64_sve_sqdmullt_lane", [], [ImmCheck<2, ImmCheckLaneIndex, 1>]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Narrowing DSP operations
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVADDHNB   : SInst<"svaddhnb[_{d}]",     "hdd",  "silUsUiUl", MergeNone, "aarch64_sve_addhnb">;
 def SVADDHNT   : SInst<"svaddhnt[_{d}]",     "hhdd", "silUsUiUl", MergeNone, "aarch64_sve_addhnt">;
 def SVRADDHNB  : SInst<"svraddhnb[_{d}]",    "hdd",  "silUsUiUl", MergeNone, "aarch64_sve_raddhnb">;
 def SVRADDHNT  : SInst<"svraddhnt[_{d}]",    "hhdd", "silUsUiUl", MergeNone, "aarch64_sve_raddhnt">;
 def SVRSUBHNB  : SInst<"svrsubhnb[_{d}]",    "hdd",  "silUsUiUl", MergeNone, "aarch64_sve_rsubhnb">;
 def SVRSUBHNT  : SInst<"svrsubhnt[_{d}]",    "hhdd", "silUsUiUl", MergeNone, "aarch64_sve_rsubhnt">;
 def SVSUBHNB   : SInst<"svsubhnb[_{d}]",     "hdd",  "silUsUiUl", MergeNone, "aarch64_sve_subhnb">;
 def SVSUBHNT   : SInst<"svsubhnt[_{d}]",     "hhdd", "silUsUiUl", MergeNone, "aarch64_sve_subhnt">;

 def SVQSHRNT_S   : SInst<"svqshrnt[_n_{d}]",   "hhdi", "sil",       MergeNone, "aarch64_sve_sqshrnt",   [], [ImmCheck<2, ImmCheckShiftRightNarrow, 1>]>;
 def SVQSHRNT_U   : SInst<"svqshrnt[_n_{d}]",   "hhdi", "UsUiUl",    MergeNone, "aarch64_sve_uqshrnt",   [], [ImmCheck<2, ImmCheckShiftRightNarrow, 1>]>;
 def SVQRSHRNT_S  : SInst<"svqrshrnt[_n_{d}]",  "hhdi", "sil",       MergeNone, "aarch64_sve_sqrshrnt",  [], [ImmCheck<2, ImmCheckShiftRightNarrow, 1>]>;
 def SVQRSHRNT_U  : SInst<"svqrshrnt[_n_{d}]",  "hhdi", "UsUiUl",    MergeNone, "aarch64_sve_uqrshrnt",  [], [ImmCheck<2, ImmCheckShiftRightNarrow, 1>]>;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Unary narrowing operations
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVQXTNB_S  : SInst<"svqxtnb[_{d}]",  "hd",  "sil",     MergeNone, "aarch64_sve_sqxtnb">;
 def SVQXTNB_U  : SInst<"svqxtnb[_{d}]",  "hd",  "UsUiUl",  MergeNone, "aarch64_sve_uqxtnb">;
 def SVQXTUNB_S : SInst<"svqxtunb[_{d}]", "ed",  "sil",     MergeNone, "aarch64_sve_sqxtunb">;
 
 def SVQXTNT_S  : SInst<"svqxtnt[_{d}]",  "hhd", "sil",     MergeNone, "aarch64_sve_sqxtnt">;
 def SVQXTNT_U  : SInst<"svqxtnt[_{d}]",  "hhd", "UsUiUl",  MergeNone, "aarch64_sve_uqxtnt">;
 def SVQXTUNT_S : SInst<"svqxtunt[_{d}]", "eed", "sil",     MergeNone, "aarch64_sve_sqxtunt">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Widening complex integer arithmetic
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 defm SVADDLBT : SInstWideDSPLong<"svaddlbt", "sil", "aarch64_sve_saddlbt">;
 defm SVSUBLBT : SInstWideDSPLong<"svsublbt", "sil", "aarch64_sve_ssublbt">;
 defm SVSUBLTB : SInstWideDSPLong<"svsubltb", "sil", "aarch64_sve_ssubltb">;
 
 defm SVQDMLALBT : SInstWideDSPAcc<"svqdmlalbt", "sil", "aarch64_sve_sqdmlalbt">;
 defm SVQDMLSLBT : SInstWideDSPAcc<"svqdmlslbt", "sil", "aarch64_sve_sqdmlslbt">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Non-temporal gather/scatter
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 // Non-temporal gather load one vector (vector base)
 def SVLDNT1_GATHER_BASES_U   : MInst<"svldnt1_gather[_{2}base]_{0}",   "dPu", "ilUiUlfd", [IsGatherLoad],               MemEltTyDefault, "aarch64_sve_ldnt1_gather_scalar_offset">;
 def SVLDNT1SB_GATHER_BASES_U : MInst<"svldnt1sb_gather[_{2}base]_{0}", "dPu", "ilUiUl",   [IsGatherLoad],               MemEltTyInt8,    "aarch64_sve_ldnt1_gather_scalar_offset">;
 def SVLDNT1UB_GATHER_BASES_U : MInst<"svldnt1ub_gather[_{2}base]_{0}", "dPu", "ilUiUl",   [IsGatherLoad, IsZExtReturn], MemEltTyInt8,    "aarch64_sve_ldnt1_gather_scalar_offset">;
 def SVLDNT1SH_GATHER_BASES_U : MInst<"svldnt1sh_gather[_{2}base]_{0}", "dPu", "ilUiUl",   [IsGatherLoad],               MemEltTyInt16,   "aarch64_sve_ldnt1_gather_scalar_offset">;
 def SVLDNT1UH_GATHER_BASES_U : MInst<"svldnt1uh_gather[_{2}base]_{0}", "dPu", "ilUiUl",   [IsGatherLoad, IsZExtReturn], MemEltTyInt16,   "aarch64_sve_ldnt1_gather_scalar_offset">;
 def SVLDNT1SW_GATHER_BASES_U : MInst<"svldnt1sw_gather[_{2}base]_{0}", "dPu", "lUl",      [IsGatherLoad],               MemEltTyInt32,   "aarch64_sve_ldnt1_gather_scalar_offset">;
 def SVLDNT1UW_GATHER_BASES_U : MInst<"svldnt1uw_gather[_{2}base]_{0}", "dPu", "lUl",      [IsGatherLoad, IsZExtReturn], MemEltTyInt32,   "aarch64_sve_ldnt1_gather_scalar_offset">;

 def SVSTNT1_SCATTER_INDEX_S  : MInst<"svstnt1_scatter[_{2}base]_index[_{d}]",  "vPuld", "ilUiUlfd", [IsScatterStore], MemEltTyDefault, "aarch64_sve_stnt1_scatter_scalar_offset">;
 def SVSTNT1H_SCATTER_INDEX_S : MInst<"svstnt1h_scatter[_{2}base]_index[_{d}]", "vPuld", "ilUiUl",   [IsScatterStore], MemEltTyInt16,   "aarch64_sve_stnt1_scatter_scalar_offset">;
 def SVSTNT1W_SCATTER_INDEX_S : MInst<"svstnt1w_scatter[_{2}base]_index[_{d}]", "vPuld", "lUl",      [IsScatterStore], MemEltTyInt32,   "aarch64_sve_stnt1_scatter_scalar_offset">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Polynomial arithmetic
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVEORBT         : SInst<"sveorbt[_{d}]",         "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eorbt">;
 def SVEORBT_N       : SInst<"sveorbt[_n_{d}]",       "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_eorbt">;
 def SVEORTB         : SInst<"sveortb[_{d}]",         "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eortb">;
 def SVEORTB_N       : SInst<"sveortb[_n_{d}]",       "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_eortb">;
 def SVPMUL          : SInst<"svpmul[_{d}]",          "ddd",  "Uc",           MergeNone, "aarch64_sve_pmul">;
 def SVPMUL_N        : SInst<"svpmul[_n_{d}]",        "dda",  "Uc",           MergeNone, "aarch64_sve_pmul">;
 def SVPMULLB        : SInst<"svpmullb[_{d}]",        "dhh",  "UsUl",         MergeNone>;
 def SVPMULLB_N      : SInst<"svpmullb[_n_{d}]",      "dhR",  "UsUl",         MergeNone>;
 def SVPMULLB_PAIR   : SInst<"svpmullb_pair[_{d}]",   "ddd",  "UcUi",         MergeNone, "aarch64_sve_pmullb_pair">;
 def SVPMULLB_PAIR_N : SInst<"svpmullb_pair[_n_{d}]", "dda",  "UcUi",         MergeNone, "aarch64_sve_pmullb_pair">;
 def SVPMULLT        : SInst<"svpmullt[_{d}]",        "dhh",  "UsUl",         MergeNone>;
 def SVPMULLT_N      : SInst<"svpmullt[_n_{d}]",      "dhR",  "UsUl",         MergeNone>;
 def SVPMULLT_PAIR   : SInst<"svpmullt_pair[_{d}]",   "ddd",  "UcUi",         MergeNone, "aarch64_sve_pmullt_pair">;
 def SVPMULLT_PAIR_N : SInst<"svpmullt_pair[_n_{d}]", "dda",  "UcUi",         MergeNone, "aarch64_sve_pmullt_pair">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Complex integer dot product
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVCDOT      : SInst<"svcdot[_{d}]",      "ddqqi",  "il",   MergeNone, "aarch64_sve_cdot",      [], [ImmCheck<3, ImmCheckComplexRotAll90>]>;
 def SVCDOT_LANE : SInst<"svcdot_lane[_{d}]", "ddqqii", "il",   MergeNone, "aarch64_sve_cdot_lane", [], [ImmCheck<4, ImmCheckComplexRotAll90>,
                                                                                                         ImmCheck<3, ImmCheckLaneIndexDot, 2>]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Floating-point widening multiply-accumulate
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVMLALB_F      : SInst<"svmlalb[_{d}]",      "ddhh",  "f",   MergeNone, "aarch64_sve_fmlalb">;
 def SVMLALB_F_N    : SInst<"svmlalb[_n_{d}]",    "ddhR",  "f",   MergeNone, "aarch64_sve_fmlalb">;
 def SVMLALB_F_LANE : SInst<"svmlalb_lane[_{d}]", "ddhhi", "f",   MergeNone, "aarch64_sve_fmlalb_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 def SVMLALT_F      : SInst<"svmlalt[_{d}]",      "ddhh",  "f",   MergeNone, "aarch64_sve_fmlalt">;
 def SVMLALT_F_N    : SInst<"svmlalt[_n_{d}]",    "ddhR",  "f",   MergeNone, "aarch64_sve_fmlalt">;
 def SVMLALT_F_LANE : SInst<"svmlalt_lane[_{d}]", "ddhhi", "f",   MergeNone, "aarch64_sve_fmlalt_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 def SVMLSLB_F      : SInst<"svmlslb[_{d}]",      "ddhh",  "f",   MergeNone, "aarch64_sve_fmlslb">;
 def SVMLSLB_F_N    : SInst<"svmlslb[_n_{d}]",    "ddhR",  "f",   MergeNone, "aarch64_sve_fmlslb">;
 def SVMLSLB_F_LANE : SInst<"svmlslb_lane[_{d}]", "ddhhi", "f",   MergeNone, "aarch64_sve_fmlslb_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 def SVMLSLT_F      : SInst<"svmlslt[_{d}]",      "ddhh",  "f",   MergeNone, "aarch64_sve_fmlslt">;
 def SVMLSLT_F_N    : SInst<"svmlslt[_n_{d}]",    "ddhR",  "f",   MergeNone, "aarch64_sve_fmlslt">;
 def SVMLSLT_F_LANE : SInst<"svmlslt_lane[_{d}]", "ddhhi", "f",   MergeNone, "aarch64_sve_fmlslt_lane", [], [ImmCheck<3, ImmCheckLaneIndex, 2>]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Floating-point integer binary logarithm
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVLOGB_M  : SInst<"svlogb[_{d}]", "xxPd", "hfd", MergeOp1,     "aarch64_sve_flogb">;
 def SVLOGB_X  : SInst<"svlogb[_{d}]", "xPd",  "hfd", MergeAnyExp,  "aarch64_sve_flogb">;
 def SVLOGB_Z  : SInst<"svlogb[_{d}]", "xPd",  "hfd", MergeZeroExp, "aarch64_sve_flogb">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Vector Histogram count
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVHISTCNT  : SInst<"svhistcnt[_{d}]_z", "uPdd", "ilUiUl", MergeNone, "aarch64_sve_histcnt">;
 def SVHISTSEG  : SInst<"svhistseg[_{d}]",   "udd",  "cUc",    MergeNone, "aarch64_sve_histseg">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Character match
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVMATCH  : SInst<"svmatch[_{d}]",  "PPdd", "csUcUs", MergeNone, "aarch64_sve_match">;
 def SVNMATCH : SInst<"svnmatch[_{d}]", "PPdd", "csUcUs", MergeNone, "aarch64_sve_nmatch">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Contiguous conflict detection
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVWHILERW_B : SInst<"svwhilerw[_{1}]", "Pcc", "cUc",  MergeNone, "aarch64_sve_whilerw_b", [IsOverloadWhileRW]>;
 def SVWHILERW_H : SInst<"svwhilerw[_{1}]", "Pcc", "sUsh", MergeNone, "aarch64_sve_whilerw_h", [IsOverloadWhileRW]>;
 def SVWHILERW_S : SInst<"svwhilerw[_{1}]", "Pcc", "iUif", MergeNone, "aarch64_sve_whilerw_s", [IsOverloadWhileRW]>;
 def SVWHILERW_D : SInst<"svwhilerw[_{1}]", "Pcc", "lUld", MergeNone, "aarch64_sve_whilerw_d", [IsOverloadWhileRW]>;
 
 def SVWHILEWR_B : SInst<"svwhilewr[_{1}]", "Pcc", "cUc",  MergeNone, "aarch64_sve_whilewr_b", [IsOverloadWhileRW]>;
 def SVWHILEWR_H : SInst<"svwhilewr[_{1}]", "Pcc", "sUsh", MergeNone, "aarch64_sve_whilewr_h", [IsOverloadWhileRW]>;
 def SVWHILEWR_S : SInst<"svwhilewr[_{1}]", "Pcc", "iUif", MergeNone, "aarch64_sve_whilewr_s", [IsOverloadWhileRW]>;
 def SVWHILEWR_D : SInst<"svwhilewr[_{1}]", "Pcc", "lUld", MergeNone, "aarch64_sve_whilewr_d", [IsOverloadWhileRW]>;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2) && defined(__ARM_FEATURE_BF16_SCALAR_ARITHMETIC)" in {
+let TargetGuard = "sve2,bf16" in {
 def SVWHILERW_H_BF16 : SInst<"svwhilerw[_{1}]", "Pcc", "b", MergeNone, "aarch64_sve_whilerw_h", [IsOverloadWhileRW]>;
 def SVWHILEWR_H_BF16 : SInst<"svwhilewr[_{1}]", "Pcc", "b", MergeNone, "aarch64_sve_whilewr_h", [IsOverloadWhileRW]>;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Extended table lookup/permute
-let ArchGuard = "defined(__ARM_FEATURE_SVE2)" in {
+let TargetGuard = "sve2" in {
 def SVTBL2 : SInst<"svtbl2[_{d}]", "d2u",  "csilUcUsUiUlhfd", MergeNone>;
 def SVTBX  : SInst<"svtbx[_{d}]",  "dddu", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_tbx">;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2) && defined(__ARM_FEATURE_SVE_BF16)" in {
+let TargetGuard = "sve2,bf16" in {
 def SVTBL2_BF16 : SInst<"svtbl2[_{d}]", "d2u",  "b", MergeNone>;
 def SVTBX_BF16  : SInst<"svtbx[_{d}]",  "dddu", "b", MergeNone, "aarch64_sve_tbx">;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SVE2 - Optional
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2_AES)" in {
+let TargetGuard = "sve2-aes" in {
 def SVAESD   : SInst<"svaesd[_{d}]",   "ddd", "Uc", MergeNone, "aarch64_sve_aesd", [IsOverloadNone]>;
 def SVAESIMC : SInst<"svaesimc[_{d}]", "dd",  "Uc", MergeNone, "aarch64_sve_aesimc", [IsOverloadNone]>;
 def SVAESE   : SInst<"svaese[_{d}]",   "ddd", "Uc", MergeNone, "aarch64_sve_aese", [IsOverloadNone]>;
 def SVAESMC  : SInst<"svaesmc[_{d}]",  "dd",  "Uc", MergeNone, "aarch64_sve_aesmc", [IsOverloadNone]>;
 
 def SVPMULLB_PAIR_U64   : SInst<"svpmullb_pair[_{d}]",   "ddd", "Ul", MergeNone, "aarch64_sve_pmullb_pair">;
 def SVPMULLB_PAIR_N_U64 : SInst<"svpmullb_pair[_n_{d}]", "dda", "Ul", MergeNone, "aarch64_sve_pmullb_pair">;
 
 def SVPMULLT_PAIR_U64   : SInst<"svpmullt_pair[_{d}]",   "ddd", "Ul", MergeNone, "aarch64_sve_pmullt_pair">;
 def SVPMULLT_PAIR_N_U64 : SInst<"svpmullt_pair[_n_{d}]", "dda", "Ul", MergeNone, "aarch64_sve_pmullt_pair">;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2_SHA3)" in {
+let TargetGuard = "sve2-sha3" in {
 def SVRAX1   : SInst<"svrax1[_{d}]",   "ddd", "lUl", MergeNone, "aarch64_sve_rax1", [IsOverloadNone]>;
 }
 
-let ArchGuard = "defined(__ARM_FEATURE_SVE2_SM4)" in {
+let TargetGuard = "sve2-sm4" in {
 def SVSM4E    : SInst<"svsm4e[_{d}]",    "ddd", "Ui", MergeNone, "aarch64_sve_sm4e", [IsOverloadNone]>;
 def SVSM4EKEY : SInst<"svsm4ekey[_{d}]", "ddd", "Ui", MergeNone, "aarch64_sve_sm4ekey", [IsOverloadNone]>;
 }
 
-let ArchGuard = "defined (__ARM_FEATURE_SVE2_BITPERM)" in {
+let TargetGuard = "sve2-bitperm" in {
 def SVBDEP   : SInst<"svbdep[_{d}]",   "ddd", "UcUsUiUl", MergeNone, "aarch64_sve_bdep_x">;
 def SVBDEP_N : SInst<"svbdep[_n_{d}]", "dda", "UcUsUiUl", MergeNone, "aarch64_sve_bdep_x">;
 def SVBEXT   : SInst<"svbext[_{d}]",   "ddd", "UcUsUiUl", MergeNone, "aarch64_sve_bext_x">;
 def SVBEXT_N : SInst<"svbext[_n_{d}]", "dda", "UcUsUiUl", MergeNone, "aarch64_sve_bext_x">;
 def SVBGRP   : SInst<"svbgrp[_{d}]",   "ddd", "UcUsUiUl", MergeNone, "aarch64_sve_bgrp_x">;
 def SVBGRP_N : SInst<"svbgrp[_n_{d}]", "dda", "UcUsUiUl", MergeNone, "aarch64_sve_bgrp_x">;
 }

clang/lib/Basic/Targets/AArch64.cpp

 static constexpr Builtin::Info BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
    {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE},
 #include "clang/Basic/BuiltinsNEON.def"
 
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
-   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
+#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
+  {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE},
 #include "clang/Basic/BuiltinsSVE.def"
 
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
    {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
 #define LANGBUILTIN(ID, TYPE, ATTRS, LANG)                                     \
   {#ID, TYPE, ATTRS, nullptr, LANG, nullptr},
 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE},

clang/test/Sema/aarch64-sve-intrinsics/acle_sve_bfloat.cpp

 // REQUIRES: aarch64-registered-target
 
-// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify -verify-ignore-unexpected=error,note %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify -verify-ignore-unexpected=error,note -emit-llvm -o - %s
 
 #include <arm_sve.h>
 
-void test_bfloat(svbool_t pg, uint64_t u64, int64_t i64, const bfloat16_t *const_bf16_ptr, svbfloat16_t bf16, svbfloat16x2_t bf16x2, svbfloat16x3_t bf16x3, svbfloat16x4_t bf16x4)
+void test_bfloat(svbool_t pg, uint64_t u64, int64_t i64, const bfloat16_t *const_bf16_ptr, bfloat16_t *bf16_ptr, svbfloat16_t bf16, svbfloat16x2_t bf16x2, svbfloat16x3_t bf16x3, svbfloat16x4_t bf16x4)
 {
-  // expected-error@+1 {{use of undeclared identifier 'svcreate2_bf16'}}
+  // expected-error@+1 {{'svcreate2_bf16' needs target feature sve,bf16}}
   svcreate2_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svcreate3_bf16'}}
+  // expected-error@+1 {{'svcreate3_bf16' needs target feature sve,bf16}}
   svcreate3_bf16(bf16, bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svcreate4_bf16'}}
+  // expected-error@+1 {{'svcreate4_bf16' needs target feature sve,bf16}}
   svcreate4_bf16(bf16, bf16, bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svget2_bf16'}}
-  svget2_bf16(bf16x2, u64);
-  // expected-error@+1 {{use of undeclared identifier 'svget3_bf16'}}
-  svget3_bf16(bf16x3, u64);
-  // expected-error@+1 {{use of undeclared identifier 'svget4_bf16'}}
-  svget4_bf16(bf16x4, u64);
-  // expected-error@+1 {{use of undeclared identifier 'svld1_bf16'}}
+  // expected-error@+1 {{'svget2_bf16' needs target feature sve,bf16}}
+  svget2_bf16(bf16x2, 1);
+  // expected-error@+1 {{'svget3_bf16' needs target feature sve,bf16}}
+  svget3_bf16(bf16x3, 1);
+  // expected-error@+1 {{'svget4_bf16' needs target feature sve,bf16}}
+  svget4_bf16(bf16x4, 1);
+  // expected-error@+1 {{'svld1_bf16' needs target feature sve,bf16}}
   svld1_bf16(pg, const_bf16_ptr);
-  // expected-error@+1 {{use of undeclared identifier 'svld1_vnum_bf16'}}
+  // expected-error@+1 {{'svld1_vnum_bf16' needs target feature sve,bf16}}
   svld1_vnum_bf16(pg, const_bf16_ptr, i64);
-  // expected-error@+1 {{use of undeclared identifier 'svld1rq_bf16'}}
+  // expected-error@+1 {{'svld1rq_bf16' needs target feature sve,bf16}}
   svld1rq_bf16(pg, const_bf16_ptr);
-  // expected-error@+1 {{use of undeclared identifier 'svldff1_bf16'}}
+  // expected-error@+1 {{'svldff1_bf16' needs target feature sve,bf16}}
   svldff1_bf16(pg, const_bf16_ptr);
-  // expected-error@+1 {{use of undeclared identifier 'svldff1_vnum_bf16'}}
+  // expected-error@+1 {{'svldff1_vnum_bf16' needs target feature sve,bf16}}
   svldff1_vnum_bf16(pg, const_bf16_ptr, i64);
-  // expected-error@+1 {{use of undeclared identifier 'svldnf1_bf16'}}
+  // expected-error@+1 {{'svldnf1_bf16' needs target feature sve,bf16}}
   svldnf1_bf16(pg, const_bf16_ptr);
-  // expected-error@+1 {{use of undeclared identifier 'svldnf1_vnum_bf16'}}
+  // expected-error@+1 {{'svldnf1_vnum_bf16' needs target feature sve,bf16}}
   svldnf1_vnum_bf16(pg, const_bf16_ptr, i64);
-  // expected-error@+1 {{use of undeclared identifier 'svldnt1_bf16'}}
+  // expected-error@+1 {{'svldnt1_bf16' needs target feature sve,bf16}}
   svldnt1_bf16(pg, const_bf16_ptr);
-  // expected-error@+1 {{use of undeclared identifier 'svldnt1_vnum_bf16'}}
+  // expected-error@+1 {{'svldnt1_vnum_bf16' needs target feature sve,bf16}}
   svldnt1_vnum_bf16(pg, const_bf16_ptr, i64);
-  // expected-error@+1 {{use of undeclared identifier 'svrev_bf16'}}
+  // expected-error@+1 {{'svrev_bf16' needs target feature sve,bf16}}
   svrev_bf16(bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svset2_bf16'}}
-  svset2_bf16(bf16x2, u64, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svset3_bf16'}}
-  svset3_bf16(bf16x3, u64, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svset4_bf16'}}
-  svset4_bf16(bf16x4, u64, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svst1_bf16'}}
-  svst1_bf16(pg, const_bf16_ptr, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svst1_vnum_bf16'}}
-  svst1_vnum_bf16(pg, const_bf16_ptr, i64, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svstnt1_bf16'}}
-  svstnt1_bf16(pg, const_bf16_ptr, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svstnt1_vnum_bf16'}}
-  svstnt1_vnum_bf16(pg, const_bf16_ptr, i64, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svtrn1_bf16'}}
+  // expected-error@+1 {{'svset2_bf16' needs target feature sve,bf16}}
+  svset2_bf16(bf16x2, 1, bf16);
+  // expected-error@+1 {{'svset3_bf16' needs target feature sve,bf16}}
+  svset3_bf16(bf16x3, 1, bf16);
+  // expected-error@+1 {{'svset4_bf16' needs target feature sve,bf16}}
+  svset4_bf16(bf16x4, 1, bf16);
+  // expected-error@+1 {{'svst1_bf16' needs target feature sve,bf16}}
+  svst1_bf16(pg, bf16_ptr, bf16);
+  // expected-error@+1 {{'svst1_vnum_bf16' needs target feature sve,bf16}}
+  svst1_vnum_bf16(pg, bf16_ptr, i64, bf16);
+  // expected-error@+1 {{'svstnt1_bf16' needs target feature sve,bf16}}
+  svstnt1_bf16(pg, bf16_ptr, bf16);
+  // expected-error@+1 {{'svstnt1_vnum_bf16' needs target feature sve,bf16}}
+  svstnt1_vnum_bf16(pg, bf16_ptr, i64, bf16);
+  // expected-error@+1 {{'svtrn1_bf16' needs target feature sve,bf16}}
   svtrn1_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svtrn1q_bf16'}}
+  // expected-error@+1 {{'svtrn1q_bf16' needs target feature sve,bf16}}
   svtrn1q_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svtrn2_bf16'}}
+  // expected-error@+1 {{'svtrn2_bf16' needs target feature sve,bf16}}
   svtrn2_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svtrn2q_bf16'}}
+  // expected-error@+1 {{'svtrn2q_bf16' needs target feature sve,bf16}}
   svtrn2q_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svundef_bf16'}}
+  // expected-error@+1 {{'svundef_bf16' needs target feature sve,bf16}}
   svundef_bf16();
-  // expected-error@+1 {{use of undeclared identifier 'svundef2_bf16'}}
+  // expected-error@+1 {{'svundef2_bf16' needs target feature sve,bf16}}
   svundef2_bf16();
-  // expected-error@+1 {{use of undeclared identifier 'svundef3_bf16'}}
+  // expected-error@+1 {{'svundef3_bf16' needs target feature sve,bf16}}
   svundef3_bf16();
-  // expected-error@+1 {{use of undeclared identifier 'svundef4_bf16'}}
+  // expected-error@+1 {{'svundef4_bf16' needs target feature sve,bf16}}
   svundef4_bf16();
-  // expected-error@+1 {{use of undeclared identifier 'svuzp1_bf16'}}
+  // expected-error@+1 {{'svuzp1_bf16' needs target feature sve,bf16}}
   svuzp1_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svuzp1q_bf16'}}
+  // expected-error@+1 {{'svuzp1q_bf16' needs target feature sve,bf16}}
   svuzp1q_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svuzp2_bf16'}}
+  // expected-error@+1 {{'svuzp2_bf16' needs target feature sve,bf16}}
   svuzp2_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svuzp2q_bf16'}}
+  // expected-error@+1 {{'svuzp2q_bf16' needs target feature sve,bf16}}
   svuzp2q_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svzip1_bf16'}}
+  // expected-error@+1 {{'svzip1_bf16' needs target feature sve,bf16}}
   svzip1_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svzip1q_bf16'}}
+  // expected-error@+1 {{'svzip1q_bf16' needs target feature sve,bf16}}
   svzip1q_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svzip2_bf16'}}
+  // expected-error@+1 {{'svzip2_bf16' needs target feature sve,bf16}}
   svzip2_bf16(bf16, bf16);
-  // expected-error@+1 {{use of undeclared identifier 'svzip2q_bf16'}}
+  // expected-error@+1 {{'svzip2q_bf16' needs target feature sve,bf16}}
   svzip2q_bf16(bf16, bf16);
 }

clang/test/Sema/aarch64-sve-intrinsics/acle_sve_target.cpp

+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -fsyntax-only -verify -emit-llvm -o - -ferror-limit 100 %s
+// REQUIRES: aarch64-registered-target
+
+// Test that functions with the correct target attributes can use the correct SVE intrinsics.
+// expected-no-diagnostics
+
+#include <arm_sve.h>
+
+void __attribute__((target("sve"))) test_sve(svint64_t x, svint64_t y)
+{
+  svzip2(x, y);
+}
+
+void __attribute__((target("sve,bf16"))) test_bfloat(svfloat32_t x, svbfloat16_t y, bfloat16_t z)
+{
+  svbfdot_n_f32(x, y, z);
+}
+
+void __attribute__((target("sve2"))) test_sve2(svbool_t pg)
+{
+  svlogb_f16_z(pg, svundef_f16());
+}
+
+void __attribute__((target("sve2-sha3"))) test_sve2_sha3()
+{
+  svrax1_s64(svundef_s64(), svundef_s64());
+}
+
+void __attribute__((target("sve2"))) test_f16(svbool_t pg)
+{
+  svlogb_f16_z(pg, svundef_f16());
+}
 No newline at end of file

clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp

 // REQUIRES: aarch64-registered-target
 
-// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify -verify-ignore-unexpected=error,note %s
-// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify=overload -verify-ignore-unexpected=error,note %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify -verify-ignore-unexpected=error,note -emit-llvm -o - %s
+// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify=overload -verify-ignore-unexpected=error,note -emit-llvm -o - %s
 
 #ifdef SVE_OVERLOADED_FORMS
 // A simple used,unused... macro, long enough to represent any SVE builtin.
 #define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
 #else
 #define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
 #endif
 

 int32_t *i32_ptr;
 uint32_t *u32_ptr;
 float32_t *f32_ptr;
 int16_t *i16_ptr;
 uint16_t *u16_ptr;
 int8_t *i8_ptr;
 uint8_t *u8_ptr;
 
-void test_s8(svbool_t pg, const int8_t *const_i8_ptr)
+void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr,
+          const int16_t *const_i16_ptr, const uint16_t *const_u16_ptr,
+          const int32_t *const_i32_ptr, const uint32_t *const_u32_ptr,
+          const int64_t *const_i64_ptr, const uint64_t *const_u64_ptr,
+          const float16_t *const_f16_ptr, const float32_t *const_f32_ptr, const float64_t *const_f64_ptr)
 {
-  // expected-error@+2 {{use of undeclared identifier 'svhistseg_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhistseg'}}
+  // expected-error@+2 {{'svhistseg_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svhistseg' needs target feature sve2}}
   SVE_ACLE_FUNC(svhistseg,_s8,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_s8,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_n_s8,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_s8,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_n_s8,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsra_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsra'}}
-  SVE_ACLE_FUNC(svsra,_n_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svsra_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svsra' needs target feature sve2}}
+  SVE_ACLE_FUNC(svsra,_n_s8,,)(svundef_s8(), svundef_s8(), 1);
+  // expected-error@+2 {{'svnbsl_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_z'}}
+  // expected-error@+2 {{'svqabs_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s8,_z,)(pg, svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_m'}}
+  // expected-error@+2 {{'svqabs_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s8,_m,)(svundef_s8(), pg, svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_x'}}
+  // expected-error@+2 {{'svqabs_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s8,_x,)(pg, svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svcadd_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcadd'}}
-  SVE_ACLE_FUNC(svcadd,_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svcadd_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svcadd' needs target feature sve2}}
+  SVE_ACLE_FUNC(svcadd,_s8,,)(svundef_s8(), svundef_s8(), 90);
+  // expected-error@+2 {{'svtbl2_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_s8,,)(svundef2_s8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_s8' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshlu_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshlu_z'}}
-  SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqshlu_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshlu_z' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, svundef_s8(), 1);
+  // expected-error@+2 {{'svqrshl_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svcmla_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcmla'}}
-  SVE_ACLE_FUNC(svcmla,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svcmla_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svcmla' needs target feature sve2}}
+  SVE_ACLE_FUNC(svcmla,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 90);
+  // expected-error@+2 {{'svqsubr_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshr_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshr_z'}}
-  SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svrshr_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshr_z' needs target feature sve2}}
+  SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, svundef_s8(), 1);
+  // expected-error@+2 {{'svaddp_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_s8,,)(svundef_s8(), svundef_s8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdcmlah_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdcmlah'}}
-  SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svqrdcmlah_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdcmlah' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 90);
+  // expected-error@+2 {{'svminp_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrsra_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsra'}}
-  SVE_ACLE_FUNC(svrsra,_n_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'svrsra_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svrsra' needs target feature sve2}}
+  SVE_ACLE_FUNC(svrsra,_n_s8,,)(svundef_s8(), svundef_s8(), 1);
+  // expected-error@+2 {{'sveor3_s8' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmatch_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmatch'}}
+  // expected-error@+2 {{'svmatch_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svmatch,_s8,,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_s8,,)(const_i8_ptr, const_i8_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svqcadd_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqcadd'}}
-  SVE_ACLE_FUNC(svqcadd,_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svqcadd_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqcadd' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqcadd,_s8,,)(svundef_s8(), svundef_s8(), 90);
+  // expected-error@+2 {{'svrhadd_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_s8,,)(const_i8_ptr, const_i8_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svsli_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsli'}}
-  SVE_ACLE_FUNC(svsli,_n_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svnmatch_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnmatch'}}
+  // expected-error@+2 {{'svsli_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svsli' needs target feature sve2}}
+  SVE_ACLE_FUNC(svsli,_n_s8,,)(svundef_s8(), svundef_s8(), 1);
+  // expected-error@+2 {{'svnmatch_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svnmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svnmatch,_s8,,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s8,_m,)(pg, svundef_s8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s8,_m,)(pg, svundef_s8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s8,_z,)(pg, svundef_s8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s8,_z,)(pg, svundef_s8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s8,_x,)(pg, svundef_s8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s8,_x,)(pg, svundef_s8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_s8' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsri_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsri'}}
-  SVE_ACLE_FUNC(svsri,_n_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svsri_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svsri' needs target feature sve2}}
+  SVE_ACLE_FUNC(svsri,_n_s8,,)(svundef_s8(), svundef_s8(), 1);
+  // expected-error@+2 {{'svbsl1n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_s8,,)(svundef_s8(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s8,_x,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_z'}}
+  // expected-error@+2 {{'svqneg_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s8,_z,)(pg, svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_m'}}
+  // expected-error@+2 {{'svqneg_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s8,_m,)(svundef_s8(), pg, svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_x'}}
+  // expected-error@+2 {{'svqneg_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s8,_x,)(pg, svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svxar_n_s8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svxar'}}
-  SVE_ACLE_FUNC(svxar,_n_s8,,)(svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svxar_n_s8' needs target feature sve2}}
+  // overload-error@+1 {{'svxar' needs target feature sve2}}
+  SVE_ACLE_FUNC(svxar,_n_s8,,)(svundef_s8(), svundef_s8(), 1);
+  // expected-error@+2 {{'svqshl_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s8,_z,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s8,_m,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s8,_x,)(pg, svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_s8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s8,_z,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_s8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s8,_m,)(pg, svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_s8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s8,_x,)(pg, svundef_s8(), i8);
-}
 
-void test_s16(svbool_t pg, const int16_t *const_i16_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshrunb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshrunb'}}
-  SVE_ACLE_FUNC(svqrshrunb,_n_s16,,)(svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalbt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalbt'}}
+  // expected-error@+2 {{'svqrshrunb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshrunb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrshrunb,_n_s16,,)(svundef_s16(), 1);
+  // expected-error@+2 {{'svqdmlalbt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalbt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalbt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalbt'}}
+  // expected-error@+2 {{'svqdmlalbt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalbt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_s16,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_n_s16,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_lane_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh_lane'}}
-  SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svqrdmulh_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svaddwb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_s16,,)(svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_n_s16,,)(svundef_s16(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_s16,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_n_s16,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_s16,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_n_s16,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_lane_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh_lane'}}
-  SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshrunt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshrunt'}}
-  SVE_ACLE_FUNC(svqshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svqdmulh_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqshrunt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqshrunt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 1);
+  // expected-error@+2 {{'svrsubhnt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb'}}
+  // expected-error@+2 {{'svqdmlslb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb'}}
+  // expected-error@+2 {{'svqdmlslb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslb,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_z'}}
+  // expected-error@+2 {{'svqabs_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s16,_z,)(pg, svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_m'}}
+  // expected-error@+2 {{'svqabs_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s16,_m,)(svundef_s16(), pg, svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_x'}}
+  // expected-error@+2 {{'svqabs_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s16,_x,)(pg, svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlbt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlbt'}}
+  // expected-error@+2 {{'svaddlbt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlbt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlbt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlbt'}}
+  // expected-error@+2 {{'svaddlbt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlbt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_s16,,)(svundef2_s16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svshrnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svshrnt'}}
-  SVE_ACLE_FUNC(svshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svshrnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svshrnt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1);
+  // expected-error@+2 {{'svhsubr_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnb'}}
+  // expected-error@+2 {{'svqxtnb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnb,_s16,,)(svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svshrnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svshrnb'}}
-  SVE_ACLE_FUNC(svshrnb,_n_s16,,)(svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svshrnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svshrnb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svshrnb,_n_s16,,)(svundef_s16(), 1);
+  // expected-error@+2 {{'svaddhnt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmls_lane_s16'}}
-  // overload-error@+1 {{no matching function for call to 'svmls_lane'}}
-  SVE_ACLE_FUNC(svmls_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt'}}
+  // expected-error@+2 {{'svmls_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmls_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmls_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqdmlalt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt'}}
+  // expected-error@+2 {{'svqdmlalt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnt'}}
+  // expected-error@+2 {{'svqxtnt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnt,_s16,,)(svundef_s8(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb'}}
+  // expected-error@+2 {{'svqdmlalb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb'}}
+  // expected-error@+2 {{'svqdmlalb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svsublbt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublbt'}}
+  // expected-error@+2 {{'svsublbt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublbt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsublbt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublbt'}}
+  // expected-error@+2 {{'svsublbt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublbt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshrnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshrnt'}}
-  SVE_ACLE_FUNC(svqshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt'}}
+  // expected-error@+2 {{'svqshrnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqshrnt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqdmullt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt'}}
+  // expected-error@+2 {{'svqdmullt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslbt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslbt'}}
+  // expected-error@+2 {{'svqdmlslbt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslbt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslbt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslbt'}}
+  // expected-error@+2 {{'svqdmlslbt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslbt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_z'}}
+  // expected-error@+2 {{'svadalp_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s16,_z,)(pg, svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_m'}}
+  // expected-error@+2 {{'svadalp_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s16,_m,)(pg, svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_x'}}
+  // expected-error@+2 {{'svadalp_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s16,_x,)(pg, svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmul_lane_s16'}}
-  // overload-error@+1 {{no matching function for call to 'svmul_lane'}}
-  SVE_ACLE_FUNC(svmul_lane,_s16,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svmul_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmul_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmul_lane,_s16,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svsubwt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_s16,,)(svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_n_s16,,)(svundef_s16(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshrnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshrnt'}}
-  SVE_ACLE_FUNC(svqrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svqrshrnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshrnt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1);
+  // expected-error@+2 {{'svaddp_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_s16,,)(svundef_s16(), svundef_s16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshrnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshrnb'}}
-  SVE_ACLE_FUNC(svqrshrnb,_n_s16,,)(svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svqrshrnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshrnb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrshrnb,_n_s16,,)(svundef_s16(), 1);
+  // expected-error@+2 {{'svminp_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_s16,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_n_s16,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_s16,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_n_s16,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshrnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshrnb'}}
-  SVE_ACLE_FUNC(svqshrnb,_n_s16,,)(svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'svqshrnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqshrnb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqshrnb,_n_s16,,)(svundef_s16(), 1);
+  // expected-error@+2 {{'sveor3_s16' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqshrunb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshrunb'}}
-  SVE_ACLE_FUNC(svqshrunb,_n_s16,,)(svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlb'}}
+  // expected-error@+2 {{'svqshrunb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqshrunb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqshrunb,_n_s16,,)(svundef_s16(), 1);
+  // expected-error@+2 {{'svmovlb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlb,_s16,,)(svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_lane_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh_lane'}}
-  SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt'}}
+  // expected-error@+2 {{'svqrdmlsh_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqdmlslt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt'}}
+  // expected-error@+2 {{'svqdmlslt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svmatch_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmatch'}}
+  // expected-error@+2 {{'svmatch_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svmatch,_s16,,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqxtunb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtunb'}}
+  // expected-error@+2 {{'svqxtunb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtunb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtunb,_s16,,)(svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmla_lane_s16'}}
-  // overload-error@+1 {{no matching function for call to 'svmla_lane'}}
-  SVE_ACLE_FUNC(svmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshrnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshrnb'}}
-  SVE_ACLE_FUNC(svrshrnb,_n_s16,,)(svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svmla_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmla_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svrshrnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svrshrnb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svrshrnb,_n_s16,,)(svundef_s16(), 1);
+  // expected-error@+2 {{'svwhilerw_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_s16,,)(const_i16_ptr, const_i16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svshllb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svshllb'}}
-  SVE_ACLE_FUNC(svshllb,_n_s16,,)(svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svshllb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svshllb' needs target feature sve2}}
+  SVE_ACLE_FUNC(svshllb,_n_s16,,)(svundef_s8(), 2);
+  // expected-error@+2 {{'svrhadd_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_s16,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_n_s16,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_s16,,)(const_i16_ptr, const_i16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_s16,,)(svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_n_s16,,)(svundef_s16(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svnmatch_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnmatch'}}
+  // expected-error@+2 {{'svnmatch_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svnmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svnmatch,_s16,,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s16,_m,)(pg, svundef_s16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s16,_m,)(pg, svundef_s16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s16,_z,)(pg, svundef_s16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s16,_z,)(pg, svundef_s16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s16,_x,)(pg, svundef_s16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s16,_x,)(pg, svundef_s16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svshllt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svshllt'}}
-  SVE_ACLE_FUNC(svshllt,_n_s16,,)(svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubltb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubltb'}}
+  // expected-error@+2 {{'svshllt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svshllt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svshllt,_n_s16,,)(svundef_s8(), 2);
+  // expected-error@+2 {{'svsubltb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubltb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubltb,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsubltb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubltb'}}
+  // expected-error@+2 {{'svsubltb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubltb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubltb,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_lane_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah_lane'}}
-  SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb'}}
+  // expected-error@+2 {{'svqrdmlah_lane_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqdmullb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullb,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb'}}
+  // expected-error@+2 {{'svqdmullb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullb,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtunt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtunt'}}
+  // expected-error@+2 {{'svqxtunt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtunt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtunt,_s16,,)(svundef_u8(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshrunt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshrunt'}}
-  SVE_ACLE_FUNC(svqrshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svqrshrunt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshrunt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqrshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 1);
+  // expected-error@+2 {{'svabalb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_s16,,)(svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_n_s16,,)(svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_s16,,)(svundef_s16(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s16,_x,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_s16,,)(svundef_s16(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_n_s16,,)(svundef_s16(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_n_s16,,)(svundef_s16(), svundef_s8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_z'}}
+  // expected-error@+2 {{'svqneg_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s16,_z,)(pg, svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_m'}}
+  // expected-error@+2 {{'svqneg_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s16,_m,)(svundef_s16(), pg, svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_x'}}
+  // expected-error@+2 {{'svqneg_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s16,_x,)(pg, svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmovlt_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlt'}}
+  // expected-error@+2 {{'svmovlt_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlt,_s16,,)(svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshrnt_n_s16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshrnt'}}
-  SVE_ACLE_FUNC(svrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svrshrnt_n_s16' needs target feature sve2}}
+  // overload-error@+1 {{'svrshrnt' needs target feature sve2}}
+  SVE_ACLE_FUNC(svrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqshl_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s16,_z,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s16,_m,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s16,_x,)(pg, svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_s16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s16,_z,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_s16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s16,_m,)(pg, svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_s16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s16,_x,)(pg, svundef_s16(), i16);
-}
 
-void test_s32(svbool_t pg, const uint16_t *const_u16_ptr, const int16_t *const_i16_ptr, const int32_t *const_i32_ptr, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb_lane'}}
-  SVE_ACLE_FUNC(svmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalbt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalbt'}}
+  // expected-error@+2 {{'svmullb_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqdmlalbt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalbt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalbt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalbt'}}
+  // expected-error@+2 {{'svqdmlalbt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalbt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_s32,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_n_s32,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_s32,,)(svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_n_s32,,)(svundef_s32(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_s32,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_n_s32,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_s32,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_n_s32,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb'}}
+  // expected-error@+2 {{'svqdmlslb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb'}}
+  // expected-error@+2 {{'svqdmlslb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslb,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb_lane'}}
-  SVE_ACLE_FUNC(svqdmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svqdmlslb_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svsubhnt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_z'}}
+  // expected-error@+2 {{'svqabs_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s32,_z,)(pg, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_m'}}
+  // expected-error@+2 {{'svqabs_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s32,_m,)(svundef_s32(), pg, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_x'}}
+  // expected-error@+2 {{'svqabs_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s32,_x,)(pg, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b8_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b8'}}
+  // expected-error@+2 {{'svwhilegt_b8_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b8,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b16_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b16'}}
+  // expected-error@+2 {{'svwhilegt_b16_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b16,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b32_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b32'}}
+  // expected-error@+2 {{'svwhilegt_b32_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b32,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b64_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b64'}}
+  // expected-error@+2 {{'svwhilegt_b64_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b64,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlbt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlbt'}}
+  // expected-error@+2 {{'svaddlbt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlbt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlbt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlbt'}}
+  // expected-error@+2 {{'svaddlbt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlbt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_s32,,)(svundef2_s32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhistcnt_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhistcnt_z'}}
+  // expected-error@+2 {{'svhistcnt_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhistcnt_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhistcnt,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnb'}}
+  // expected-error@+2 {{'svqxtnb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnb,_s32,,)(svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt_lane'}}
-  SVE_ACLE_FUNC(svmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svmlalt_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svaddhnt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_s32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _s32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, u32, offset_s32, )(pg, const_u16_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32base_index_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_s32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32base_index_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt'}}
+  // expected-error@+2 {{'svqdmlalt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt'}}
+  // expected-error@+2 {{'svqdmlalt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt_lane'}}
-  SVE_ACLE_FUNC(svqdmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svqdmlalt_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svbcax_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnt'}}
+  // expected-error@+2 {{'svqxtnt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnt,_s32,,)(svundef_s16(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb'}}
+  // expected-error@+2 {{'svqdmlalb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb'}}
+  // expected-error@+2 {{'svqdmlalb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb_lane'}}
-  SVE_ACLE_FUNC(svqdmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqdmlalb_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqrshl_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svcdot_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcdot'}}
-  SVE_ACLE_FUNC(svcdot,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svsublbt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublbt'}}
+  // expected-error@+2 {{'svcdot_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svcdot' needs target feature sve2}}
+  SVE_ACLE_FUNC(svcdot,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), 90);
+  // expected-error@+2 {{'svsublbt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublbt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsublbt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublbt'}}
+  // expected-error@+2 {{'svsublbt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublbt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt'}}
+  // expected-error@+2 {{'svqdmullt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt'}}
+  // expected-error@+2 {{'svqdmullt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt_lane'}}
-  SVE_ACLE_FUNC(svqdmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svqdmullt_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svsublt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslbt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslbt'}}
+  // expected-error@+2 {{'svqdmlslbt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslbt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslbt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslbt'}}
+  // expected-error@+2 {{'svqdmlslbt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslbt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_z'}}
+  // expected-error@+2 {{'svadalp_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s32,_z,)(pg, svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_m'}}
+  // expected-error@+2 {{'svadalp_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s32,_m,)(pg, svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_x'}}
+  // expected-error@+2 {{'svadalp_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s32,_x,)(pg, svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b8_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b8'}}
+  // expected-error@+2 {{'svwhilege_b8_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b8,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b16_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b16'}}
+  // expected-error@+2 {{'svwhilege_b16_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b16,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b32_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b32'}}
+  // expected-error@+2 {{'svwhilege_b32_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b32,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b64_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b64'}}
+  // expected-error@+2 {{'svwhilege_b64_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b64,_s32,,)(i32, i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_s32,,)(svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_n_s32,,)(svundef_s32(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_s32,,)(svundef_s32(), svundef_s32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_s32,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_n_s32,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_s32,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_n_s32,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_s32' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlb'}}
+  // expected-error@+2 {{'svmovlb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlb,_s32,,)(svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, , _s32)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u32, offset, _s32)(pg, i32_ptr, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _offset, _s32)(pg, svundef_u32(), i64, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_index_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_index_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _s32)(pg, svundef_u32(), i64, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt'}}
+  // expected-error@+2 {{'svqdmlslt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt'}}
+  // expected-error@+2 {{'svqdmlslt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt_lane'}}
-  SVE_ACLE_FUNC(svqdmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svqdmlslt_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svmaxp_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt_lane'}}
-  SVE_ACLE_FUNC(svmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_s32'}}
+  // expected-error@+2 {{'svmullt_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svldnt1sh_gather_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _s32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, u32, offset_s32, )(pg, const_i16_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32base_index_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_s32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32base_index_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtunb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtunb'}}
+  // expected-error@+2 {{'svqxtunb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtunb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtunb,_s32,,)(svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_s32,,)(const_i32_ptr, const_i32_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_s32,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_n_s32,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_s32,,)(const_i32_ptr, const_i32_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb_lane'}}
-  SVE_ACLE_FUNC(svmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_s32'}}
+  // expected-error@+2 {{'svmlalb_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svldnt1sb_gather_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _s32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather_, u32, offset_s32, )(pg, const_i8_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_s32,,)(svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_n_s32,,)(svundef_s32(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_s32'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _s32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather_, u32, offset_s32, )(pg, const_u8_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaba_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s32,_m,)(pg, svundef_s32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s32,_m,)(pg, svundef_s32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s32,_z,)(pg, svundef_s32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s32,_z,)(pg, svundef_s32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s32,_x,)(pg, svundef_s32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s32,_x,)(pg, svundef_s32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubltb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubltb'}}
+  // expected-error@+2 {{'svsubltb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubltb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubltb,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubltb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubltb'}}
+  // expected-error@+2 {{'svsubltb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubltb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubltb,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_s32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _s32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u32, offset, _s32)(pg, const_i32_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset_s32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_index_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index_s32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_index_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index_s32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb'}}
+  // expected-error@+2 {{'svqdmullb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullb,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb'}}
+  // expected-error@+2 {{'svqdmullb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullb,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb_lane'}}
-  SVE_ACLE_FUNC(svqdmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter'}}
+  // expected-error@+2 {{'svqdmullb_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svqdmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svstnt1h_scatter_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u32base, , _s32)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, u32, offset, _s32)(pg, i16_ptr, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u32base, _offset, _s32)(pg, svundef_u32(), i64, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32base_index_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32base_index_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u32base, _index, _s32)(pg, svundef_u32(), i64, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u32base_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u32base_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, , _s32)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u32offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u32offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter_, u32, offset, _s32)(pg, i8_ptr, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u32base_offset_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u32base_offset_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, _offset, _s32)(pg, svundef_u32(), i64, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtunt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtunt'}}
+  // expected-error@+2 {{'svqxtunt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtunt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtunt,_s32,,)(svundef_u16(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_s32,,)(svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_n_s32,,)(svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_s32,,)(svundef_s32(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s32,_x,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_s32,,)(svundef_s32(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_n_s32,,)(svundef_s32(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb_lane'}}
-  SVE_ACLE_FUNC(svmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslb_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svmlslt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_n_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_n_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_n_s32,,)(svundef_s32(), svundef_s16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_lane_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt_lane'}}
-  SVE_ACLE_FUNC(svmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_z'}}
+  // expected-error@+2 {{'svmlslt_lane_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt_lane' needs target feature sve2}}
+  SVE_ACLE_FUNC(svmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1);
+  // expected-error@+2 {{'svqneg_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s32,_z,)(pg, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_m'}}
+  // expected-error@+2 {{'svqneg_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s32,_m,)(svundef_s32(), pg, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_x'}}
+  // expected-error@+2 {{'svqneg_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s32,_x,)(pg, svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmovlt_s32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlt'}}
+  // expected-error@+2 {{'svmovlt_s32' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlt,_s32,,)(svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s32,_z,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s32,_m,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s32,_x,)(pg, svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_s32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s32,_z,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_s32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s32,_m,)(pg, svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_s32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s32,_x,)(pg, svundef_s32(), i32);
-}
 
-void test_s64(svbool_t pg, const uint16_t *const_u16_ptr, const int16_t *const_i16_ptr, const int64_t *const_i64_ptr, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, const int32_t *const_i32_ptr, const uint32_t *const_u32_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalbt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalbt'}}
+  // expected-error@+2 {{'svqdmlalbt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalbt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalbt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalbt'}}
+  // expected-error@+2 {{'svqdmlalbt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalbt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_s64,,)(svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmulh_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmulh'}}
+  // expected-error@+2 {{'svqrdmulh_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmulh,_n_s64,,)(svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_s64,,)(svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_n_s64,,)(svundef_s64(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_s64,,)(svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_n_s64,,)(svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_s64,,)(svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmulh_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmulh'}}
+  // expected-error@+2 {{'svqdmulh_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmulh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmulh,_n_s64,,)(svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb'}}
+  // expected-error@+2 {{'svqdmlslb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslb'}}
+  // expected-error@+2 {{'svqdmlslb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslb,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_z'}}
+  // expected-error@+2 {{'svqabs_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s64,_z,)(pg, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_m'}}
+  // expected-error@+2 {{'svqabs_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s64,_m,)(svundef_s64(), pg, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqabs_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqabs_x'}}
+  // expected-error@+2 {{'svqabs_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqabs_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqabs,_s64,_x,)(pg, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b8_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b8'}}
+  // expected-error@+2 {{'svwhilegt_b8_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b8,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b16_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b16'}}
+  // expected-error@+2 {{'svwhilegt_b16_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b16,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b32_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b32'}}
+  // expected-error@+2 {{'svwhilegt_b32_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b32,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b64_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b64'}}
+  // expected-error@+2 {{'svwhilegt_b64_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b64,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlbt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlbt'}}
+  // expected-error@+2 {{'svaddlbt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlbt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlbt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlbt'}}
+  // expected-error@+2 {{'svaddlbt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlbt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_s64,,)(svundef2_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhistcnt_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhistcnt_z'}}
+  // expected-error@+2 {{'svhistcnt_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhistcnt_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhistcnt,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnb'}}
+  // expected-error@+2 {{'svqxtnb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnb,_s64,,)(svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, s64, offset_s64, )(pg, const_u16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, u64, offset_s64, )(pg, const_u16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, s64, index_s64, )(pg, const_u16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, u64, index_s64, )(pg, const_u16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt'}}
+  // expected-error@+2 {{'svqdmlalt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalt'}}
+  // expected-error@+2 {{'svqdmlalt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnt'}}
+  // expected-error@+2 {{'svqxtnt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnt,_s64,,)(svundef_s32(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb'}}
+  // expected-error@+2 {{'svqdmlalb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlalb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlalb'}}
+  // expected-error@+2 {{'svqdmlalb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsublbt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublbt'}}
+  // expected-error@+2 {{'svsublbt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublbt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsublbt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublbt'}}
+  // expected-error@+2 {{'svsublbt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublbt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt'}}
+  // expected-error@+2 {{'svqdmullt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullt'}}
+  // expected-error@+2 {{'svqdmullt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslbt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslbt'}}
+  // expected-error@+2 {{'svqdmlslbt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslbt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslbt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslbt'}}
+  // expected-error@+2 {{'svqdmlslbt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslbt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslbt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_z'}}
+  // expected-error@+2 {{'svadalp_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s64,_z,)(pg, svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_m'}}
+  // expected-error@+2 {{'svadalp_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s64,_m,)(pg, svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_x'}}
+  // expected-error@+2 {{'svadalp_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_s64,_x,)(pg, svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b8_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b8'}}
+  // expected-error@+2 {{'svwhilege_b8_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b8,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b16_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b16'}}
+  // expected-error@+2 {{'svwhilege_b16_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b16,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b32_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b32'}}
+  // expected-error@+2 {{'svwhilege_b32_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b32,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b64_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b64'}}
+  // expected-error@+2 {{'svwhilege_b64_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b64,_s64,,)(i64, i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_s64,,)(svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_n_s64,,)(svundef_s64(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_s64,,)(svundef_s64(), svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_s64,,)(svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_n_s64,,)(svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_s64,,)(svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_n_s64,,)(svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_s64' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlb'}}
+  // expected-error@+2 {{'svmovlb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlb,_s64,,)(svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, , _s64)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, s64, offset, _s64)(pg, i64_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u64, offset, _s64)(pg, i64_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _offset, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, s64, index, _s64)(pg, i64_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u64, index, _s64)(pg, i64_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlsh_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlsh'}}
+  // expected-error@+2 {{'svqrdmlsh_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlsh' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlsh,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt'}}
+  // expected-error@+2 {{'svqdmlslt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmlslt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmlslt'}}
+  // expected-error@+2 {{'svqdmlslt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmlslt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, s64, offset_s64, )(pg, const_i16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, u64, offset_s64, )(pg, const_i16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, s64, index_s64, )(pg, const_i16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, u64, index_s64, )(pg, const_i16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtunb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtunb'}}
+  // expected-error@+2 {{'svqxtunb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtunb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtunb,_s64,,)(svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_s64,,)(const_i64_ptr, const_i64_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_s64,,)(svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_n_s64,,)(svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_s64,,)(const_i64_ptr, const_i64_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_s64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather_, s64, offset_s64, )(pg, const_i8_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather_, u64, offset_s64, )(pg, const_i8_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_s64,,)(svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_n_s64,,)(svundef_s64(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_s64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather_, s64, offset_s64, )(pg, const_u8_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather_, u64, offset_s64, )(pg, const_u8_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaba_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s64,_m,)(pg, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_m'}}
+  // expected-error@+2 {{'svuqadd_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s64,_m,)(pg, svundef_s64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s64,_z,)(pg, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_z'}}
+  // expected-error@+2 {{'svuqadd_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s64,_z,)(pg, svundef_s64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_s64,_x,)(pg, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svuqadd_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svuqadd_x'}}
+  // expected-error@+2 {{'svuqadd_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svuqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svuqadd,_n_s64,_x,)(pg, svundef_s64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, s64, offset_s64, )(pg, const_i32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, u64, offset_s64, )(pg, const_i32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, s64, index_s64, )(pg, const_i32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, u64, index_s64, )(pg, const_i32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubltb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubltb'}}
+  // expected-error@+2 {{'svsubltb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubltb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubltb,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubltb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubltb'}}
+  // expected-error@+2 {{'svsubltb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubltb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubltb,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_s64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, s64, offset, _s64)(pg, const_i64_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u64, offset, _s64)(pg, const_i64_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index'}}
+  // expected-error@+2 {{'svldnt1_gather_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, s64, index, _s64)(pg, const_i64_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index'}}
+  // expected-error@+2 {{'svldnt1_gather_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u64, index, _s64)(pg, const_i64_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrdmlah_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrdmlah'}}
+  // expected-error@+2 {{'svqrdmlah_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqrdmlah' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrdmlah,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb'}}
+  // expected-error@+2 {{'svqdmullb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullb,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqdmullb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqdmullb'}}
+  // expected-error@+2 {{'svqdmullb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqdmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqdmullb,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather, _u64base, _s64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, s64, offset_s64, )(pg, const_u32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, u64, offset_s64, )(pg, const_u32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_offset_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_offset_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, s64, index_s64, )(pg, const_u32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, u64, index_s64, )(pg, const_u32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_index_s64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_index_s64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u64base, , _s64)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, s64, offset, _s64)(pg, i16_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, u64, offset, _s64)(pg, i16_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u64base, _offset, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, s64, index, _s64)(pg, i16_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, u64, index, _s64)(pg, i16_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, , _s64)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter_, s64, offset, _s64)(pg, i8_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter_, u64, offset, _s64)(pg, i8_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, _offset, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64base_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64base_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, , _s64)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_s64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1w_scatter_s64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, s64, offset, _s64)(pg, i32_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, u64, offset, _s64)(pg, i32_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64base_offset_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64base_offset_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _offset, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_s64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_index'}}
+  // expected-error@+2 {{'svstnt1w_scatter_s64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, s64, index, _s64)(pg, i32_ptr, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_index'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, u64, index, _s64)(pg, i32_ptr, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64base_index_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_index'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64base_index_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqxtunt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtunt'}}
+  // expected-error@+2 {{'svqxtunt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtunt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtunt,_s64,,)(svundef_u32(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_s64,,)(svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_n_s64,,)(svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_s64,,)(svundef_s64(), svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_s64,_x,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_s64,,)(svundef_s64(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_n_s64,,)(svundef_s64(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_n_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_n_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_n_s64,,)(svundef_s64(), svundef_s32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_z'}}
+  // expected-error@+2 {{'svqneg_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s64,_z,)(pg, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_m'}}
+  // expected-error@+2 {{'svqneg_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s64,_m,)(svundef_s64(), pg, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqneg_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqneg_x'}}
+  // expected-error@+2 {{'svqneg_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqneg_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqneg,_s64,_x,)(pg, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svmovlt_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlt'}}
+  // expected-error@+2 {{'svmovlt_s64' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlt,_s64,,)(svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s64,_z,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s64,_m,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_s64,_x,)(pg, svundef_s64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_s64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s64,_z,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_s64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s64,_m,)(pg, svundef_s64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_s64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_s64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_s64,_x,)(pg, svundef_s64(), i64);
-}
 
-void test_u8(svbool_t pg, const uint8_t *const_u8_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svhistseg_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhistseg'}}
+  // expected-error@+2 {{'svhistseg_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svhistseg' needs target feature sve2}}
   SVE_ACLE_FUNC(svhistseg,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_pair_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb_pair'}}
+  // expected-error@+2 {{'svpmullb_pair_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb_pair,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_pair_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb_pair'}}
+  // expected-error@+2 {{'svpmullb_pair_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb_pair,_n_u8,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_u8,,)(svundef2_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svpmul_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmul'}}
+  // expected-error@+2 {{'svpmul_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svpmul' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmul,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmul_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmul'}}
+  // expected-error@+2 {{'svpmul_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svpmul' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmul,_n_u8,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_u8' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u8,_z,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u8,_m,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u8,_x,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u8,_z,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u8,_m,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u8,_x,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_pair_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt_pair'}}
+  // expected-error@+2 {{'svpmullt_pair_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt_pair,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_pair_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt_pair'}}
+  // expected-error@+2 {{'svpmullt_pair_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt_pair,_n_u8,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u8,_m,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u8,_m,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u8,_z,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u8,_z,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u8,_x,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u8,_x,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_u8' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmatch_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmatch'}}
+  // expected-error@+2 {{'svmatch_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svmatch,_u8,,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_u8,,)(const_u8_ptr, const_u8_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_u8,,)(const_u8_ptr, const_u8_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svnmatch_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnmatch'}}
+  // expected-error@+2 {{'svnmatch_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svnmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svnmatch,_u8,,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_u8' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u8,_z,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u8,_m,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u8,_x,)(pg, svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u8,_z,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u8,_m,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u8,_x,)(pg, svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_u8' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_u8,,)(svundef_u8(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u8,_z,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u8,_m,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u8,_x,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u8,_z,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u8,_m,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u8,_x,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u8,_z,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u8,_m,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u8,_x,)(pg, svundef_u8(), svundef_s8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u8_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_u8_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u8,_z,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u8_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_u8_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u8,_m,)(pg, svundef_u8(), i8);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u8_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_u8_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u8,_x,)(pg, svundef_u8(), i8);
-}
 
-void test_u16(svbool_t pg, const uint16_t *const_u16_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb'}}
+  // expected-error@+2 {{'svpmullb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb'}}
+  // expected-error@+2 {{'svpmullb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_u16,,)(svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_n_u16,,)(svundef_u16(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_n_u16,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_u16,,)(svundef2_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnb'}}
+  // expected-error@+2 {{'svqxtnb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnb,_u16,,)(svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_n_u16,,)(svundef_u16(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnt'}}
+  // expected-error@+2 {{'svqxtnt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnt,_u16,,)(svundef_u8(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u16,_z,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u16,_m,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u16,_x,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u16,_z,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u16,_m,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u16,_x,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_z'}}
+  // expected-error@+2 {{'svadalp_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u16,_z,)(pg, svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_m'}}
+  // expected-error@+2 {{'svadalp_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u16,_m,)(pg, svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_x'}}
+  // expected-error@+2 {{'svadalp_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u16,_x,)(pg, svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt'}}
+  // expected-error@+2 {{'svpmullt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt'}}
+  // expected-error@+2 {{'svpmullt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_u16,,)(svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_n_u16,,)(svundef_u16(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u16,_m,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u16,_m,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u16,_z,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u16,_z,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u16,_x,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u16,_x,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_n_u16,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_n_u16,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_n_u16,,)(svundef_u16(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_u16' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlb'}}
+  // expected-error@+2 {{'svmovlb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlb,_u16,,)(svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svmatch_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmatch'}}
+  // expected-error@+2 {{'svmatch_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svmatch,_u16,,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_u16,,)(const_u16_ptr, const_u16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_n_u16,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_u16,,)(const_u16_ptr, const_u16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_n_u16,,)(svundef_u16(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_u16,,)(svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_n_u16,,)(svundef_u16(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svnmatch_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnmatch'}}
+  // expected-error@+2 {{'svnmatch_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svnmatch' needs target feature sve2}}
   SVE_ACLE_FUNC(svnmatch,_u16,,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u16,_z,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u16,_m,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u16,_x,)(pg, svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u16,_z,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u16,_m,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u16,_x,)(pg, svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_n_u16,,)(svundef_u16(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_u16,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_n_u16,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_u16,,)(svundef_u16(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u16,_z,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u16,_m,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u16,_x,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u16,_z,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u16,_m,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u16,_x,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_u16,,)(svundef_u16(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_n_u16,,)(svundef_u16(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_n_u16,,)(svundef_u16(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_n_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_n_u16,,)(svundef_u16(), svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlt_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlt'}}
+  // expected-error@+2 {{'svmovlt_u16' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlt,_u16,,)(svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u16,_z,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u16,_m,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u16,_x,)(pg, svundef_u16(), svundef_s16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_u16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u16,_z,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_u16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u16,_m,)(pg, svundef_u16(), i16);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_u16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u16,_x,)(pg, svundef_u16(), i16);
-}
 
-void test_u32(svbool_t pg, const uint16_t *const_u16_ptr, const int16_t *const_i16_ptr, const uint32_t *const_u32_ptr, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_pair_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb_pair'}}
+  // expected-error@+2 {{'svpmullb_pair_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb_pair,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_pair_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb_pair'}}
+  // expected-error@+2 {{'svpmullb_pair_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb_pair,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_u32,,)(svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_n_u32,,)(svundef_u32(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b8_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b8'}}
+  // expected-error@+2 {{'svwhilegt_b8_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b8,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b16_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b16'}}
+  // expected-error@+2 {{'svwhilegt_b16_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b16,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b32_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b32'}}
+  // expected-error@+2 {{'svwhilegt_b32_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b32,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b64_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b64'}}
+  // expected-error@+2 {{'svwhilegt_b64_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b64,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_u32,,)(svundef2_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhistcnt_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhistcnt_z'}}
+  // expected-error@+2 {{'svhistcnt_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhistcnt_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhistcnt,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnb'}}
+  // expected-error@+2 {{'svqxtnb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnb,_u32,,)(svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_n_u32,,)(svundef_u32(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_u32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _u32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, u32, offset_u32, )(pg, const_u16_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u32base_index_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_u32'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u32base_index_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnt'}}
+  // expected-error@+2 {{'svqxtnt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnt,_u32,,)(svundef_u16(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u32,_z,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u32,_m,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u32,_x,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u32,_z,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u32,_m,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u32,_x,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_z'}}
+  // expected-error@+2 {{'svadalp_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u32,_z,)(pg, svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_m'}}
+  // expected-error@+2 {{'svadalp_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u32,_m,)(pg, svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_x'}}
+  // expected-error@+2 {{'svadalp_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u32,_x,)(pg, svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b8_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b8'}}
+  // expected-error@+2 {{'svwhilege_b8_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b8,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b16_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b16'}}
+  // expected-error@+2 {{'svwhilege_b16_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b16,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b32_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b32'}}
+  // expected-error@+2 {{'svwhilege_b32_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b32,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b64_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b64'}}
+  // expected-error@+2 {{'svwhilege_b64_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b64,_u32,,)(u32, u32);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_pair_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt_pair'}}
+  // expected-error@+2 {{'svpmullt_pair_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt_pair,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_pair_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt_pair'}}
+  // expected-error@+2 {{'svpmullt_pair_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt_pair' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt_pair,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_u32,,)(svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_n_u32,,)(svundef_u32(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svadclt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclt'}}
+  // expected-error@+2 {{'svadclt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svadclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svadclt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclt'}}
+  // expected-error@+2 {{'svadclt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svadclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclt,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrecpe_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrecpe_z'}}
+  // expected-error@+2 {{'svrecpe_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrecpe_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrecpe,_u32,_z,)(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrecpe_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrecpe_m'}}
+  // expected-error@+2 {{'svrecpe_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrecpe_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrecpe,_u32,_m,)(svundef_u32(), pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrecpe_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrecpe_x'}}
+  // expected-error@+2 {{'svrecpe_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrecpe_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrecpe,_u32,_x,)(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u32,_m,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u32,_m,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u32,_z,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u32,_z,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u32,_x,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u32,_x,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_n_u32,,)(svundef_u32(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_u32' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlb'}}
+  // expected-error@+2 {{'svmovlb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlb,_u32,,)(svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, , _u32)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u32, offset, _u32)(pg, u32_ptr, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _offset, _u32)(pg, svundef_u32(), i64, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_index_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_index_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _u32)(pg, svundef_u32(), i64, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsbclt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclt'}}
+  // expected-error@+2 {{'svsbclt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsbclt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclt'}}
+  // expected-error@+2 {{'svsbclt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclt,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_u32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _u32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, u32, offset_u32, )(pg, const_i16_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u32base_index_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_u32'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u32base_index_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_u32,,)(const_u32_ptr, const_u32_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_u32,,)(const_u32_ptr, const_u32_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_n_u32,,)(svundef_u32(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_u32'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _u32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather_, u32, offset_u32, )(pg, const_i8_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_u32,,)(svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_n_u32,,)(svundef_u32(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_u32'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _u32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather_, u32, offset_u32, )(pg, const_u8_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaba_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svadclb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclb'}}
+  // expected-error@+2 {{'svadclb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svadclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svadclb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclb'}}
+  // expected-error@+2 {{'svadclb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svadclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclb,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u32,_z,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u32,_m,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u32,_x,)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u32,_z,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u32,_m,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u32,_x,)(pg, svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_u32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _u32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u32, offset, _u32)(pg, const_u32_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset_u32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_index_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index_u32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_index_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index_u32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u32base, , _u32)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, u32, offset, _u32)(pg, u16_ptr, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u32base, _offset, _u32)(pg, svundef_u32(), i64, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u32base_index_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u32base_index_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u32base, _index, _u32)(pg, svundef_u32(), i64, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u32base_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u32base_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, , _u32)(pg, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u32offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u32offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter_, u32, offset, _u32)(pg, u8_ptr, svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u32base_offset_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u32base_offset_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, _offset, _u32)(pg, svundef_u32(), i64, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_n_u32,,)(svundef_u32(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_u32,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_n_u32,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svsbclb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclb'}}
+  // expected-error@+2 {{'svsbclb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsbclb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclb'}}
+  // expected-error@+2 {{'svsbclb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclb,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_u32,,)(svundef_u32(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u32,_z,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u32,_m,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u32,_x,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u32,_z,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u32,_m,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u32,_x,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svrsqrte_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsqrte_z'}}
+  // expected-error@+2 {{'svrsqrte_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrsqrte_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsqrte,_u32,_z,)(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrsqrte_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsqrte_m'}}
+  // expected-error@+2 {{'svrsqrte_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrsqrte_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsqrte,_u32,_m,)(svundef_u32(), pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svrsqrte_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsqrte_x'}}
+  // expected-error@+2 {{'svrsqrte_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrsqrte_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsqrte,_u32,_x,)(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_u32,,)(svundef_u32(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_n_u32,,)(svundef_u32(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_n_u32,,)(svundef_u32(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_n_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_n_u32,,)(svundef_u32(), svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlt_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlt'}}
+  // expected-error@+2 {{'svmovlt_u32' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlt,_u32,,)(svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u32,_z,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u32,_m,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u32,_x,)(pg, svundef_u32(), svundef_s32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_u32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u32,_z,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_u32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u32,_m,)(pg, svundef_u32(), i32);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_u32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u32,_x,)(pg, svundef_u32(), i32);
-}
 
-void test_u64(svbool_t pg, const uint16_t *const_u16_ptr, const int16_t *const_i16_ptr, const uint64_t *const_u64_ptr, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, const int32_t *const_i32_ptr, const uint32_t *const_u32_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmullb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullb'}}
+  // expected-error@+2 {{'svmullb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullb,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb'}}
+  // expected-error@+2 {{'svpmullb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullb'}}
+  // expected-error@+2 {{'svpmullb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullb' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullb,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_u64,,)(svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwb'}}
+  // expected-error@+2 {{'svaddwb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwb,_n_u64,,)(svundef_u64(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnb'}}
+  // expected-error@+2 {{'svsubhnb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnb,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnt'}}
+  // expected-error@+2 {{'svrsubhnt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svnbsl_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svnbsl'}}
+  // expected-error@+2 {{'svnbsl_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svnbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svnbsl,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svsubhnt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubhnt'}}
+  // expected-error@+2 {{'svsubhnt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b8_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b8'}}
+  // expected-error@+2 {{'svwhilegt_b8_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b8,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b16_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b16'}}
+  // expected-error@+2 {{'svwhilegt_b16_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b16,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b32_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b32'}}
+  // expected-error@+2 {{'svwhilegt_b32_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b32,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilegt_b64_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilegt_b64'}}
+  // expected-error@+2 {{'svwhilegt_b64_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilegt_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilegt_b64,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_u64,,)(svundef2_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_z'}}
+  // expected-error@+2 {{'svhsubr_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_m'}}
+  // expected-error@+2 {{'svhsubr_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsubr_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsubr_x'}}
+  // expected-error@+2 {{'svhsubr_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsubr,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhistcnt_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhistcnt_z'}}
+  // expected-error@+2 {{'svhistcnt_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhistcnt_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhistcnt,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'sveortb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveortb'}}
+  // expected-error@+2 {{'sveortb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'sveortb' needs target feature sve2}}
   SVE_ACLE_FUNC(sveortb,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnb'}}
+  // expected-error@+2 {{'svqxtnb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnb,_u64,,)(svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalt'}}
+  // expected-error@+2 {{'svmlalt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalt,_n_u64,,)(svundef_u64(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnt'}}
+  // expected-error@+2 {{'svaddhnt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, s64, offset_u64, )(pg, const_u16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, u64, offset_u64, )(pg, const_u16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, s64, index_u64, )(pg, const_u16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather_, u64, index_u64, )(pg, const_u16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uh_gather_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uh_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1uh_gather_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uh_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbcax_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbcax'}}
+  // expected-error@+2 {{'svbcax_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbcax' needs target feature sve2}}
   SVE_ACLE_FUNC(svbcax,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqxtnt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqxtnt'}}
+  // expected-error@+2 {{'svqxtnt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svqxtnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svqxtnt,_u64,,)(svundef_u32(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u64,_z,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u64,_m,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_u64,_x,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_z'}}
+  // expected-error@+2 {{'svqrshl_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u64,_z,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_m'}}
+  // expected-error@+2 {{'svqrshl_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u64,_m,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqrshl_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqrshl_x'}}
+  // expected-error@+2 {{'svqrshl_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqrshl,_n_u64,_x,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsublt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublt'}}
+  // expected-error@+2 {{'svsublt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublt,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_z'}}
+  // expected-error@+2 {{'svadalp_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u64,_z,)(pg, svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_m'}}
+  // expected-error@+2 {{'svadalp_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u64,_m,)(pg, svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svadalp_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadalp_x'}}
+  // expected-error@+2 {{'svadalp_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svadalp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svadalp,_u64,_x,)(pg, svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b8_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b8'}}
+  // expected-error@+2 {{'svwhilege_b8_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b8' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b8,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b16_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b16'}}
+  // expected-error@+2 {{'svwhilege_b16_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b16' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b16,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b32_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b32'}}
+  // expected-error@+2 {{'svwhilege_b32_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b32' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b32,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilege_b64_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilege_b64'}}
+  // expected-error@+2 {{'svwhilege_b64_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilege_b64' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilege_b64,_u64,,)(u64, u64);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt'}}
+  // expected-error@+2 {{'svpmullt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svpmullt'}}
+  // expected-error@+2 {{'svpmullt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svpmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svpmullt,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_u64,,)(svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwt'}}
+  // expected-error@+2 {{'svsubwt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwt,_n_u64,,)(svundef_u64(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_z'}}
+  // expected-error@+2 {{'svqsubr_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_m'}}
+  // expected-error@+2 {{'svqsubr_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsubr_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsubr_x'}}
+  // expected-error@+2 {{'svqsubr_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsubr_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsubr,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svadclt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclt'}}
+  // expected-error@+2 {{'svadclt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svadclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svadclt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclt'}}
+  // expected-error@+2 {{'svadclt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svadclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclt,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_m'}}
+  // expected-error@+2 {{'svqadd_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_z'}}
+  // expected-error@+2 {{'svqadd_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqadd_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqadd_x'}}
+  // expected-error@+2 {{'svqadd_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqadd,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlb'}}
+  // expected-error@+2 {{'svabdlb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlb,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svabdlt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabdlt'}}
+  // expected-error@+2 {{'svabdlt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabdlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabdlt,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u64,_m,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_m'}}
+  // expected-error@+2 {{'svsqadd_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u64,_m,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u64,_z,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_z'}}
+  // expected-error@+2 {{'svsqadd_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u64,_z,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_u64,_x,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svsqadd_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsqadd_x'}}
+  // expected-error@+2 {{'svsqadd_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svsqadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svsqadd,_n_u64,_x,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_z'}}
+  // expected-error@+2 {{'svqsub_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_m'}}
+  // expected-error@+2 {{'svqsub_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svqsub_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqsub_x'}}
+  // expected-error@+2 {{'svqsub_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqsub,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svrsubhnb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrsubhnb'}}
+  // expected-error@+2 {{'svrsubhnb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svrsubhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svrsubhnb,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddhnb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddhnb'}}
+  // expected-error@+2 {{'svaddhnb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddhnb,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svabalt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalt'}}
+  // expected-error@+2 {{'svabalt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalt' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalt,_n_u64,,)(svundef_u64(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_u64' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'sveor3_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveor3'}}
+  // expected-error@+2 {{'sveor3_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'sveor3' needs target feature sve2}}
   SVE_ACLE_FUNC(sveor3,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_m'}}
+  // expected-error@+2 {{'svhadd_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_z'}}
+  // expected-error@+2 {{'svhadd_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhadd_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhadd_x'}}
+  // expected-error@+2 {{'svhadd_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhadd,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlb'}}
+  // expected-error@+2 {{'svmovlb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlb,_u64,,)(svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, , _u64)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, s64, offset, _u64)(pg, u64_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u64, offset, _u64)(pg, u64_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _offset, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, s64, index, _u64)(pg, u64_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u64, index, _u64)(pg, u64_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svsbclt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclt'}}
+  // expected-error@+2 {{'svsbclt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svsbclt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclt'}}
+  // expected-error@+2 {{'svsbclt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclt' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclt,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmullt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmullt'}}
+  // expected-error@+2 {{'svmullt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmullt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmullt,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, s64, offset_u64, )(pg, const_i16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, u64, offset_u64, )(pg, const_i16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, s64, index_u64, )(pg, const_i16_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather_, u64, index_u64, )(pg, const_i16_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sh_gather_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sh_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1sh_gather_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sh_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_u64,,)(const_u64_ptr, const_u64_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_m'}}
+  // expected-error@+2 {{'svrhadd_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_z'}}
+  // expected-error@+2 {{'svrhadd_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svrhadd_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrhadd_x'}}
+  // expected-error@+2 {{'svrhadd_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrhadd_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrhadd,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnb'}}
+  // expected-error@+2 {{'svraddhnb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnb' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnb,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_u64,,)(const_u64_ptr, const_u64_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlalb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlalb'}}
+  // expected-error@+2 {{'svmlalb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlalb,_n_u64,,)(svundef_u64(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_u64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather_, s64, offset_u64, )(pg, const_i8_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather_, u64, offset_u64, )(pg, const_i8_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sb_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sb_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sb_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sb_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_u64,,)(svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsubwb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsubwb'}}
+  // expected-error@+2 {{'svsubwb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsubwb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsubwb,_n_u64,,)(svundef_u64(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_u64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather_, s64, offset_u64, )(pg, const_u8_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather_, u64, offset_u64, )(pg, const_u8_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1ub_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1ub_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1ub_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1ub_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaba_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svaba_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaba'}}
+  // expected-error@+2 {{'svaba_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaba' needs target feature sve2}}
   SVE_ACLE_FUNC(svaba,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svraddhnt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svraddhnt'}}
+  // expected-error@+2 {{'svraddhnt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svraddhnt' needs target feature sve2}}
   SVE_ACLE_FUNC(svraddhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'sveorbt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'sveorbt'}}
+  // expected-error@+2 {{'sveorbt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'sveorbt' needs target feature sve2}}
   SVE_ACLE_FUNC(sveorbt,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, s64, offset_u64, )(pg, const_i32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, u64, offset_u64, )(pg, const_i32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, s64, index_u64, )(pg, const_i32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather_, u64, index_u64, )(pg, const_i32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1sw_gather_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1sw_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1sw_gather_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1sw_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl'}}
+  // expected-error@+2 {{'svbsl_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svadclb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclb'}}
+  // expected-error@+2 {{'svadclb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svadclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svadclb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svadclb'}}
+  // expected-error@+2 {{'svadclb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svadclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svadclb,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u64,_z,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u64,_m,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_u64,_x,)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_z'}}
+  // expected-error@+2 {{'svhsub_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u64,_z,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_m'}}
+  // expected-error@+2 {{'svhsub_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u64,_m,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svhsub_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svhsub_x'}}
+  // expected-error@+2 {{'svhsub_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svhsub_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svhsub,_n_u64,_x,)(pg, svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_u64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, s64, offset, _u64)(pg, const_u64_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u64, offset, _u64)(pg, const_u64_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index'}}
+  // expected-error@+2 {{'svldnt1_gather_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, s64, index, _u64)(pg, const_u64_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index'}}
+  // expected-error@+2 {{'svldnt1_gather_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u64, index, _u64)(pg, const_u64_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlb'}}
+  // expected-error@+2 {{'svaddlb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlb' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlb,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather, _u64base, _u64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, s64, offset_u64, )(pg, const_u32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, u64, offset_u64, )(pg, const_u32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_offset_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_offset_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, s64, index_u64, )(pg, const_u32_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather_, u64, index_u64, )(pg, const_u32_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1uw_gather_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1uw_gather_index_u64'}}
+  // expected-error@+2 {{'svldnt1uw_gather_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1uw_gather_index_u64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1uw_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u64base, , _u64)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, s64, offset, _u64)(pg, u16_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, u64, offset, _u64)(pg, u16_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u64base, _offset, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, s64, index, _u64)(pg, u16_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter_, u64, index, _u64)(pg, u16_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1h_scatter_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1h_scatter_index'}}
+  // expected-error@+2 {{'svstnt1h_scatter_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1h_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1h_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, , _u64)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter_, s64, offset, _u64)(pg, u8_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter_, u64, offset, _u64)(pg, u8_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1b_scatter_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1b_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1b_scatter_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, _offset, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl2n_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl2n'}}
+  // expected-error@+2 {{'svbsl2n_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl2n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl2n,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddlt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddlt'}}
+  // expected-error@+2 {{'svaddlt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddlt,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64base_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64base_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, , _u64)(pg, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_s64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1w_scatter_s64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, s64, offset, _u64)(pg, u32_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, u64, offset, _u64)(pg, u32_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64base_offset_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64base_offset_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _offset, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_s64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_index'}}
+  // expected-error@+2 {{'svstnt1w_scatter_s64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, s64, index, _u64)(pg, u32_ptr, svundef_s64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_index'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter_, u64, index, _u64)(pg, u32_ptr, svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1w_scatter_u64base_index_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1w_scatter_index'}}
+  // expected-error@+2 {{'svstnt1w_scatter_u64base_index_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svabalb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svabalb'}}
+  // expected-error@+2 {{'svabalb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svabalb' needs target feature sve2}}
   SVE_ACLE_FUNC(svabalb,_n_u64,,)(svundef_u64(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_u64,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsublb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsublb'}}
+  // expected-error@+2 {{'svsublb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsublb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsublb,_n_u64,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsbclb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclb'}}
+  // expected-error@+2 {{'svsbclb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svsbclb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsbclb'}}
+  // expected-error@+2 {{'svsbclb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svsbclb' needs target feature sve2}}
   SVE_ACLE_FUNC(svsbclb,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbsl1n_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbsl1n'}}
+  // expected-error@+2 {{'svbsl1n_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svbsl1n' needs target feature sve2}}
   SVE_ACLE_FUNC(svbsl1n,_n_u64,,)(svundef_u64(), svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u64,_z,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u64,_m,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_u64,_x,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_z'}}
+  // expected-error@+2 {{'svrshl_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u64,_z,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_m'}}
+  // expected-error@+2 {{'svrshl_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u64,_m,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svrshl_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrshl_x'}}
+  // expected-error@+2 {{'svrshl_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svrshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svrshl,_n_u64,_x,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_u64,,)(svundef_u64(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddwt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddwt'}}
+  // expected-error@+2 {{'svaddwt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svaddwt' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddwt,_n_u64,,)(svundef_u64(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslb_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslb'}}
+  // expected-error@+2 {{'svmlslb_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslb' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslb,_n_u64,,)(svundef_u64(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svmlslt_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmlslt'}}
+  // expected-error@+2 {{'svmlslt_n_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmlslt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmlslt,_n_u64,,)(svundef_u64(), svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svmovlt_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmovlt'}}
+  // expected-error@+2 {{'svmovlt_u64' needs target feature sve2}}
+  // overload-error@+1 {{'svmovlt' needs target feature sve2}}
   SVE_ACLE_FUNC(svmovlt,_u64,,)(svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u64,_z,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u64,_m,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_u64,_x,)(pg, svundef_u64(), svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_z'}}
+  // expected-error@+2 {{'svqshl_n_u64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u64,_z,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_m'}}
+  // expected-error@+2 {{'svqshl_n_u64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u64,_m,)(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svqshl_n_u64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svqshl_x'}}
+  // expected-error@+2 {{'svqshl_n_u64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svqshl_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svqshl,_n_u64,_x,)(pg, svundef_u64(), i64);
-}
 
-void test_f16(svbool_t pg, const float16_t *const_f16_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f16_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_z'}}
+  // expected-error@+2 {{'svlogb_f16_z' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f16,_z,)(pg, svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_m'}}
+  // expected-error@+2 {{'svlogb_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f16,_m,)(svundef_s16(), pg, svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_x'}}
+  // expected-error@+2 {{'svlogb_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f16,_x,)(pg, svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svminnmp_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminnmp_m'}}
+  // expected-error@+2 {{'svminnmp_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminnmp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminnmp,_f16,_m,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svminnmp_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminnmp_x'}}
+  // expected-error@+2 {{'svminnmp_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminnmp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminnmp,_f16,_x,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_f16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_f16' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_f16,,)(svundef2_f16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_f16,_m,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_f16,_x,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_f16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_f16' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_f16,,)(svundef_f16(), svundef_f16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_f16,_m,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_f16,_x,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_f16,_m,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_f16,_x,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxnmp_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxnmp_m'}}
+  // expected-error@+2 {{'svmaxnmp_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxnmp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxnmp,_f16,_m,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxnmp_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxnmp_x'}}
+  // expected-error@+2 {{'svmaxnmp_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxnmp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxnmp,_f16,_x,)(pg, svundef_f16(), svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_f16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_f16' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_f16,,)(const_f16_ptr, const_f16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_f16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_f16' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_f16,,)(const_f16_ptr, const_f16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svcvtlt_f32_f16_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtlt_f32_m'}}
+  // expected-error@+2 {{'svcvtlt_f32_f16_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtlt_f32_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtlt_f32,_f16,_m,)(svundef_f32(), pg, svundef_f16());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtlt_f32_f16_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtlt_f32_x'}}
+  // expected-error@+2 {{'svcvtlt_f32_f16_x' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtlt_f32_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtlt_f32,_f16,_x,)(pg, svundef_f16());
-}
 
-void test_f32(svbool_t pg, const float32_t *const_f32_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f32_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_z'}}
+  // expected-error@+2 {{'svlogb_f32_z' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f32,_z,)(pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_m'}}
+  // expected-error@+2 {{'svlogb_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f32,_m,)(svundef_s32(), pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_x'}}
+  // expected-error@+2 {{'svlogb_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f32,_x,)(pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svminnmp_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminnmp_m'}}
+  // expected-error@+2 {{'svminnmp_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminnmp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminnmp,_f32,_m,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svminnmp_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminnmp_x'}}
+  // expected-error@+2 {{'svminnmp_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminnmp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminnmp,_f32,_x,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_f32,,)(svundef2_f32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_f32,_m,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_f32,_x,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_f32,,)(svundef_f32(), svundef_f32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_f32,_m,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_f32,_x,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, , _f32)(pg, svundef_u32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32offset_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32offset_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u32, offset, _f32)(pg, f32_ptr, svundef_u32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_offset_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_offset_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _offset, _f32)(pg, svundef_u32(), i64, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u32base_index_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u32base_index_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _f32)(pg, svundef_u32(), i64, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_f32,_m,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_f32,_x,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxnmp_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxnmp_m'}}
+  // expected-error@+2 {{'svmaxnmp_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxnmp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxnmp,_f32,_m,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxnmp_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxnmp_x'}}
+  // expected-error@+2 {{'svmaxnmp_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxnmp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxnmp,_f32,_x,)(pg, svundef_f32(), svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_f32,,)(const_f32_ptr, const_f32_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svcvtnt_f16_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtnt_f16_m'}}
+  // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtnt_f16_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtnt_f16,_f32,_m,)(svundef_f16(), pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtnt_f16_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtnt_f16_x'}}
+  // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtnt_f16_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtnt_f16,_f32,_x,)(svundef_f16(), pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_f32,,)(const_f32_ptr, const_f32_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svcvtlt_f64_f32_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtlt_f64_m'}}
+  // expected-error@+2 {{'svcvtlt_f64_f32_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtlt_f64_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtlt_f64,_f32,_m,)(svundef_f64(), pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtlt_f64_f32_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtlt_f64_x'}}
+  // expected-error@+2 {{'svcvtlt_f64_f32_x' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtlt_f64_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtlt_f64,_f32,_x,)(pg, svundef_f32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_f32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_f32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _f32, )(pg, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32offset_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_u32offset_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u32, offset, _f32)(pg, const_f32_ptr, svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_offset_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset_f32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_offset_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset_f32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _offset_f32, )(pg, svundef_u32(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u32base_index_f32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index_f32'}}
+  // expected-error@+2 {{'svldnt1_gather_u32base_index_f32' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index_f32' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_f32, )(pg, svundef_u32(), i64);
-}
 
-void test_f64(svbool_t pg, const float64_t *const_f64_ptr)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_z'}}
+  // expected-error@+2 {{'svlogb_f64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f64,_z,)(pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_m'}}
+  // expected-error@+2 {{'svlogb_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f64,_m,)(svundef_s64(), pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svlogb_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svlogb_x'}}
+  // expected-error@+2 {{'svlogb_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svlogb_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svlogb,_f64,_x,)(pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svminnmp_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminnmp_m'}}
+  // expected-error@+2 {{'svminnmp_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminnmp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminnmp,_f64,_m,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svminnmp_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminnmp_x'}}
+  // expected-error@+2 {{'svminnmp_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminnmp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminnmp,_f64,_x,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbl2,_f64,,)(svundef2_f64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_m'}}
+  // expected-error@+2 {{'svaddp_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_f64,_m,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svaddp_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaddp_x'}}
+  // expected-error@+2 {{'svaddp_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svaddp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svaddp,_f64,_x,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2}}
   SVE_ACLE_FUNC(svtbx,_f64,,)(svundef_f64(), svundef_f64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_m'}}
+  // expected-error@+2 {{'svminp_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_f64,_m,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svminp_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svminp_x'}}
+  // expected-error@+2 {{'svminp_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svminp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svminp,_f64,_x,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, , _f64)(pg, svundef_u64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_s64offset_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_s64offset_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, s64, offset, _f64)(pg, f64_ptr, svundef_s64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64offset_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64offset_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u64, offset, _f64)(pg, f64_ptr, svundef_u64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_offset_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_offset'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_offset_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _offset, _f64)(pg, svundef_u64(), i64, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_s64index_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_s64index_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, s64, index, _f64)(pg, f64_ptr, svundef_s64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64index_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64index_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter_, u64, index, _f64)(pg, f64_ptr, svundef_u64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svstnt1_scatter_u64base_index_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svstnt1_scatter_index'}}
+  // expected-error@+2 {{'svstnt1_scatter_u64base_index_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _f64)(pg, svundef_u64(), i64, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_m'}}
+  // expected-error@+2 {{'svmaxp_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_f64,_m,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxp_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxp_x'}}
+  // expected-error@+2 {{'svmaxp_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxp,_f64,_x,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxnmp_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxnmp_m'}}
+  // expected-error@+2 {{'svmaxnmp_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxnmp_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxnmp,_f64,_m,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svmaxnmp_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svmaxnmp_x'}}
+  // expected-error@+2 {{'svmaxnmp_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svmaxnmp_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svmaxnmp,_f64,_x,)(pg, svundef_f64(), svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilerw,_f64,,)(const_f64_ptr, const_f64_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svcvtnt_f32_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtnt_f32_m'}}
+  // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtnt_f32_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtnt_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtnt_f32_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtnt_f32_x'}}
+  // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtnt_f32_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtnt_f32,_f64,_x,)(svundef_f32(), pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2}}
   SVE_ACLE_FUNC(svwhilewr,_f64,,)(const_f64_ptr, const_f64_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svcvtx_f32_f64_z'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtx_f32_z'}}
+  // expected-error@+2 {{'svcvtx_f32_f64_z' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtx_f32_z' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtx_f32,_f64,_z,)(pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtx_f32_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtx_f32_m'}}
+  // expected-error@+2 {{'svcvtx_f32_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtx_f32_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtx_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtx_f32_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtx_f32_x'}}
+  // expected-error@+2 {{'svcvtx_f32_f64_x' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtx_f32_x' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtx_f32,_f64,_x,)(pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_f64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_f64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _f64, )(pg, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_s64offset_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_s64offset_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, s64, offset, _f64)(pg, const_f64_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64offset_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset'}}
+  // expected-error@+2 {{'svldnt1_gather_u64offset_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u64, offset, _f64)(pg, const_f64_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_offset_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_offset_f64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_offset_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_offset_f64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _offset_f64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_s64index_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index'}}
+  // expected-error@+2 {{'svldnt1_gather_s64index_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, s64, index, _f64)(pg, const_f64_ptr, svundef_s64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64index_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index'}}
+  // expected-error@+2 {{'svldnt1_gather_u64index_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather_, u64, index, _f64)(pg, const_f64_ptr, svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svldnt1_gather_u64base_index_f64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svldnt1_gather_index_f64'}}
+  // expected-error@+2 {{'svldnt1_gather_u64base_index_f64' needs target feature sve2}}
+  // overload-error@+1 {{'svldnt1_gather_index_f64' needs target feature sve2}}
   SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_f64, )(pg, svundef_u64(), i64);
-  // expected-error@+2 {{use of undeclared identifier 'svcvtxnt_f32_f64_m'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtxnt_f32_m'}}
+  // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtxnt_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64());
-  // expected-error@+2 {{use of undeclared identifier 'svcvtxnt_f32_f64_x'}}
-  // overload-error@+1 {{use of undeclared identifier 'svcvtxnt_f32_x'}}
+  // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature sve2}}
+  // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature sve2}}
   SVE_ACLE_FUNC(svcvtxnt_f32,_f64,_x,)(svundef_f32(), pg, svundef_f64());
 }

clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp

 // REQUIRES: aarch64-registered-target
 
-// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fsyntax-only -verify -verify-ignore-unexpected=error,note %s
-// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fsyntax-only -verify=overload -verify-ignore-unexpected=error,note %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fsyntax-only -verify -verify-ignore-unexpected=error,note -emit-llvm -o - %s
+// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fsyntax-only -verify=overload -verify-ignore-unexpected=error,note -emit-llvm -o - %s
 
 #ifdef SVE_OVERLOADED_FORMS
 // A simple used,unused... macro, long enough to represent any SVE builtin.
 #define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
 #else
 #define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
 #endif
 
 #include <arm_sve.h>
 
-void test_u8(uint8_t u8)
+void test(uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64)
 {
-  // expected-error@+2 {{use of undeclared identifier 'svaesd_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaesd'}}
+  // expected-error@+2 {{'svaesd_u8' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svaesd' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svaesd,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaese_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaese'}}
+  // expected-error@+2 {{'svaese_u8' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svaese' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svaese,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaesimc_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaesimc'}}
+  // expected-error@+2 {{'svaesimc_u8' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svaesimc' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svaesimc,_u8,,)(svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svaesmc_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svaesmc'}}
+  // expected-error@+2 {{'svaesmc_u8' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svaesmc' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svaesmc,_u8,,)(svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_u8' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
-  SVE_ACLE_FUNC(svbdep,_n_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbext_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbdep_n_u8' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
+  SVE_ACLE_FUNC(svbdep,_n_u8,,)(svundef_u8(), u8);
+  // expected-error@+2 {{'svbext_u8' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbext_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_n_u8' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_n_u8,,)(svundef_u8(), u8);
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_u8' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_u8,,)(svundef_u8(), svundef_u8());
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_n_u8'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_n_u8' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_n_u8,,)(svundef_u8(), u8);
-}
   
-void test_u16(uint16_t u16)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_u16' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_n_u16' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_n_u16,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svbext_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_u16' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbext_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_n_u16' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_n_u16,,)(svundef_u16(), u16);
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_u16' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_u16,,)(svundef_u16(), svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_n_u16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_n_u16' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_n_u16,,)(svundef_u16(), u16);
-}
   
-void test_u32(uint32_t u32)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_u32' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_n_u32' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svbext_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_u32' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbext_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_n_u32' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_u32' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_n_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_n_u32' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_n_u32,,)(svundef_u32(), u32);
-  // expected-error@+2 {{use of undeclared identifier 'svsm4e_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsm4e'}}
+  // expected-error@+2 {{'svsm4e_u32' needs target feature sve2-sm4}}
+  // overload-error@+1 {{'svsm4e' needs target feature sve2-sm4}}
   SVE_ACLE_FUNC(svsm4e,_u32,,)(svundef_u32(), svundef_u32());
-  // expected-error@+2 {{use of undeclared identifier 'svsm4ekey_u32'}}
-  // overload-error@+1 {{use of undeclared identifier 'svsm4ekey'}}
+  // expected-error@+2 {{'svsm4ekey_u32' needs target feature sve2-sm4}}
+  // overload-error@+1 {{'svsm4ekey' needs target feature sve2-sm4}}
   SVE_ACLE_FUNC(svsm4ekey,_u32,,)(svundef_u32(), svundef_u32());
-}
   
-void test_u64(uint64_t u64)
-{
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_u64' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbdep_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbdep'}}
+  // expected-error@+2 {{'svbdep_n_u64' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbdep' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbdep,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svbext_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_u64' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbext_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbext'}}
+  // expected-error@+2 {{'svbext_n_u64' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbext' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbext,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_u64' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svbgrp_n_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svbgrp'}}
+  // expected-error@+2 {{'svbgrp_n_u64' needs target feature sve2-bitperm}}
+  // overload-error@+1 {{'svbgrp' needs target feature sve2-bitperm}}
   SVE_ACLE_FUNC(svbgrp,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_pair_u64'}}
-  // overload-error@+1 {{no matching function for call to 'svpmullb_pair'}}
+  // expected-error@+2 {{'svpmullb_pair_u64' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svpmullb_pair' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svpmullb_pair,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullb_pair_n_u64'}}
-  // overload-error@+1 {{no matching function for call to 'svpmullb_pair'}}
+  // expected-error@+2 {{'svpmullb_pair_n_u64' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svpmullb_pair' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svpmullb_pair,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_pair_u64'}}
-  // overload-error@+1 {{no matching function for call to 'svpmullt_pair'}}
+  // expected-error@+2 {{'svpmullt_pair_u64' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svpmullt_pair' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svpmullt_pair,_u64,,)(svundef_u64(), svundef_u64());
-  // expected-error@+2 {{use of undeclared identifier 'svpmullt_pair_n_u64'}}
-  // overload-error@+1 {{no matching function for call to 'svpmullt_pair'}}
+  // expected-error@+2 {{'svpmullt_pair_n_u64' needs target feature sve2-aes}}
+  // overload-error@+1 {{'svpmullt_pair' needs target feature sve2-aes}}
   SVE_ACLE_FUNC(svpmullt_pair,_n_u64,,)(svundef_u64(), u64);
-  // expected-error@+2 {{use of undeclared identifier 'svrax1_u64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrax1'}}
+  // expected-error@+2 {{'svrax1_u64' needs target feature sve2-sha3}}
+  // overload-error@+1 {{'svrax1' needs target feature sve2-sha3}}
   SVE_ACLE_FUNC(svrax1,_u64,,)(svundef_u64(), svundef_u64());
-}
 
-void test_s64()
-{
-  // expected-error@+2 {{use of undeclared identifier 'svrax1_s64'}}
-  // overload-error@+1 {{use of undeclared identifier 'svrax1'}}
+  // expected-error@+2 {{'svrax1_s64' needs target feature sve2-sha3}}
+  // overload-error@+1 {{'svrax1' needs target feature sve2-sha3}}
   SVE_ACLE_FUNC(svrax1,_s64,,)(svundef_s64(), svundef_s64());
 }

clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_bfloat.cpp

 // REQUIRES: aarch64-registered-target
 
-// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fsyntax-only -verify -verify-ignore-unexpected=error,note %s
-// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +bf16 -fsyntax-only -verify=overload -verify-ignore-unexpected=error,note %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fsyntax-only -verify -verify-ignore-unexpected=error,note -emit-llvm -o - %s
+// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +bf16 -fsyntax-only -verify=overload -verify-ignore-unexpected=error,note -emit-llvm -o - %s
 
 #ifdef SVE_OVERLOADED_FORMS
 // A simple used,unused... macro, long enough to represent any SVE builtin.
 #define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
 #else
 #define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
 #endif
 
 #include <arm_sve.h>
 
 void test_bfloat(const bfloat16_t *const_bf16_ptr, svbfloat16_t bf16, svbfloat16x2_t bf16x2)
 {
-  // expected-error@+2 {{use of undeclared identifier 'svwhilerw_bf16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilerw'}}
+  // expected-error@+2 {{'svwhilerw_bf16' needs target feature sve2,bf16}}
+  // overload-error@+1 {{'svwhilerw' needs target feature sve2,bf16}}
   SVE_ACLE_FUNC(svwhilerw,_bf16,,)(const_bf16_ptr, const_bf16_ptr);
-  // expected-error@+2 {{use of undeclared identifier 'svtbx_bf16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbx'}}
+  // expected-error@+2 {{'svtbx_bf16' needs target feature sve2,bf16}}
+  // overload-error@+1 {{'svtbx' needs target feature sve2,bf16}}
   SVE_ACLE_FUNC(svtbx,_bf16,,)(bf16, bf16, svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svtbl2_bf16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svtbl2'}}
+  // expected-error@+2 {{'svtbl2_bf16' needs target feature sve2,bf16}}
+  // overload-error@+1 {{'svtbl2' needs target feature sve2,bf16}}
   SVE_ACLE_FUNC(svtbl2,_bf16,,)(bf16x2, svundef_u16());
-  // expected-error@+2 {{use of undeclared identifier 'svwhilewr_bf16'}}
-  // overload-error@+1 {{use of undeclared identifier 'svwhilewr'}}
+  // expected-error@+2 {{'svwhilewr_bf16' needs target feature sve2,bf16}}
+  // overload-error@+1 {{'svwhilewr' needs target feature sve2,bf16}}
   SVE_ACLE_FUNC(svwhilewr,_bf16,,)(const_bf16_ptr, const_bf16_ptr);
 }

clang/utils/TableGen/SveEmitter.cpp

uint64_t SVEEmitter::encodeTypeFlags(const SVEType &T) {
   }
 }
 
 void SVEEmitter::createIntrinsic(
     Record *R, SmallVectorImpl<std::unique_ptr<Intrinsic>> &Out) {
   StringRef Name = R->getValueAsString("Name");
   StringRef Proto = R->getValueAsString("Prototype");
   StringRef Types = R->getValueAsString("Types");
-  StringRef Guard = R->getValueAsString("ArchGuard");
+  StringRef Guard = R->getValueAsString("TargetGuard");
   StringRef LLVMName = R->getValueAsString("LLVMIntrinsic");
   uint64_t Merge = R->getValueAsInt("Merge");
   StringRef MergeSuffix = R->getValueAsString("MergeSuffix");
   uint64_t MemEltType = R->getValueAsInt("MemEltType");
   std::vector<Record*> FlagsList = R->getValueAsListOfDefs("Flags");
   std::vector<Record*> ImmCheckList = R->getValueAsListOfDefs("ImmChecks");
 
   int64_t Flags = 0;
OS << "/*===---- arm_sve.h - ARM SVE intrinsics "
         " *\n"
         " *===-----------------------------------------------------------------"
         "------===\n"
         " */\n\n";
 
   OS << "#ifndef __ARM_SVE_H\n";
   OS << "#define __ARM_SVE_H\n\n";
 
-  OS << "#if !defined(__ARM_FEATURE_SVE)\n";
-  OS << "#error \"SVE support not enabled\"\n";
-  OS << "#else\n\n";
-
   OS << "#if !defined(__LITTLE_ENDIAN__)\n";
   OS << "#error \"Big endian is currently not supported for arm_sve.h\"\n";
   OS << "#endif\n";
 
   OS << "#include <stdint.h>\n\n";
   OS << "#ifdef  __cplusplus\n";
   OS << "extern \"C\" {\n";
   OS << "#else\n";
void SVEEmitter::createHeader(raw_ostream &OS) {
   OS << "typedef __SVInt32_t svint32_t;\n";
   OS << "typedef __SVInt64_t svint64_t;\n";
   OS << "typedef __SVUint8_t svuint8_t;\n";
   OS << "typedef __SVUint16_t svuint16_t;\n";
   OS << "typedef __SVUint32_t svuint32_t;\n";
   OS << "typedef __SVUint64_t svuint64_t;\n";
   OS << "typedef __SVFloat16_t svfloat16_t;\n\n";
 
-  OS << "#if defined(__ARM_FEATURE_SVE_BF16) && "
-        "!defined(__ARM_FEATURE_BF16_SCALAR_ARITHMETIC)\n";
-  OS << "#error \"__ARM_FEATURE_BF16_SCALAR_ARITHMETIC must be defined when "
-        "__ARM_FEATURE_SVE_BF16 is defined\"\n";
-  OS << "#endif\n\n";
-
-  OS << "#if defined(__ARM_FEATURE_SVE_BF16)\n";
   OS << "typedef __SVBFloat16_t svbfloat16_t;\n";
-  OS << "#endif\n\n";
 
-  OS << "#if defined(__ARM_FEATURE_BF16_SCALAR_ARITHMETIC)\n";
   OS << "#include <arm_bf16.h>\n";
   OS << "typedef __bf16 bfloat16_t;\n";
-  OS << "#endif\n\n";
 
   OS << "typedef __SVFloat32_t svfloat32_t;\n";
   OS << "typedef __SVFloat64_t svfloat64_t;\n";
   OS << "typedef __clang_svint8x2_t svint8x2_t;\n";
   OS << "typedef __clang_svint16x2_t svint16x2_t;\n";
   OS << "typedef __clang_svint32x2_t svint32x2_t;\n";
   OS << "typedef __clang_svint64x2_t svint64x2_t;\n";
   OS << "typedef __clang_svuint8x2_t svuint8x2_t;\n";
void SVEEmitter::createHeader(raw_ostream &OS) {
   OS << "typedef __clang_svuint16x4_t svuint16x4_t;\n";
   OS << "typedef __clang_svuint32x4_t svuint32x4_t;\n";
   OS << "typedef __clang_svuint64x4_t svuint64x4_t;\n";
   OS << "typedef __clang_svfloat16x4_t svfloat16x4_t;\n";
   OS << "typedef __clang_svfloat32x4_t svfloat32x4_t;\n";
   OS << "typedef __clang_svfloat64x4_t svfloat64x4_t;\n";
   OS << "typedef __SVBool_t  svbool_t;\n\n";
 
-  OS << "#ifdef __ARM_FEATURE_SVE_BF16\n";
   OS << "typedef __clang_svbfloat16x2_t svbfloat16x2_t;\n";
   OS << "typedef __clang_svbfloat16x3_t svbfloat16x3_t;\n";
   OS << "typedef __clang_svbfloat16x4_t svbfloat16x4_t;\n";
-  OS << "#endif\n";
 
   OS << "enum svpattern\n";
   OS << "{\n";
   OS << "  SV_POW2 = 0,\n";
   OS << "  SV_VL1 = 1,\n";
   OS << "  SV_VL2 = 2,\n";
   OS << "  SV_VL3 = 3,\n";
   OS << "  SV_VL4 = 4,\n";
OS << "#define __ai static __inline__ __attribute__((__always_inline__, "
         "__nodebug__))\n\n";
   OS << "#define __aio static __inline__ __attribute__((__always_inline__, "
         "__nodebug__, __overloadable__))\n\n";
 
   // Add reinterpret functions.
   for (auto ShortForm : { false, true } )
     for (const ReinterpretTypeInfo &From : Reinterprets)
       for (const ReinterpretTypeInfo &To : Reinterprets) {
-        const bool IsBFloat = StringRef(From.Suffix).equals("bf16") ||
-                              StringRef(To.Suffix).equals("bf16");
-        if (IsBFloat)
-          OS << "#if defined(__ARM_FEATURE_SVE_BF16)\n";
         if (ShortForm) {
-          OS << "__aio " << From.Type << " svreinterpret_" << From.Suffix;
+          OS << "__aio __attribute__((target(\"sve\"))) " << From.Type
+             << " svreinterpret_" << From.Suffix;
           OS << "(" << To.Type << " op) {\n";
           OS << "  return __builtin_sve_reinterpret_" << From.Suffix << "_"
              << To.Suffix << "(op);\n";
           OS << "}\n\n";
         } else
           OS << "#define svreinterpret_" << From.Suffix << "_" << To.Suffix
              << "(...) __builtin_sve_reinterpret_" << From.Suffix << "_"
              << To.Suffix << "(__VA_ARGS__)\n";
-        if (IsBFloat)
-          OS << "#endif /* #if defined(__ARM_FEATURE_SVE_BF16) */\n";
       }
 
   SmallVector<std::unique_ptr<Intrinsic>, 128> Defs;
   std::vector<Record *> RV = Records.getAllDerivedDefinitions("Inst");
   for (auto *R : RV)
     createIntrinsic(R, Defs);
 
   // Sort intrinsics in header file by following order/priority:
   // - Architectural guard (i.e. does it require SVE2 or SVE2_AES)
   // - Class (is intrinsic overloaded or not)
   // - Intrinsic name
   std::stable_sort(
       Defs.begin(), Defs.end(), [](const std::unique_ptr<Intrinsic> &A,
                                    const std::unique_ptr<Intrinsic> &B) {
         auto ToTuple = [](const std::unique_ptr<Intrinsic> &I) {
           return std::make_tuple(I->getGuard(), (unsigned)I->getClassKind(), I->getName());
         };
         return ToTuple(A) < ToTuple(B);
       });
 
-  StringRef InGuard = "";
-  for (auto &I : Defs) {
-    // Emit #endif/#if pair if needed.
-    if (I->getGuard() != InGuard) {
-      if (!InGuard.empty())
-        OS << "#endif  //" << InGuard << "\n";
-      InGuard = I->getGuard();
-      if (!InGuard.empty())
-        OS << "\n#if " << InGuard << "\n";
-    }
-
-    // Actually emit the intrinsic declaration.
+  // Actually emit the intrinsic declarations.
+  for (auto &I : Defs)
     I->emitIntrinsic(OS);
-  }
 
-  if (!InGuard.empty())
-    OS << "#endif  //" << InGuard << "\n";
-
-  OS << "#if defined(__ARM_FEATURE_SVE_BF16)\n";
   OS << "#define svcvtnt_bf16_x      svcvtnt_bf16_m\n";
   OS << "#define svcvtnt_bf16_f32_x  svcvtnt_bf16_f32_m\n";
-  OS << "#endif /*__ARM_FEATURE_SVE_BF16 */\n\n";
 
-  OS << "#if defined(__ARM_FEATURE_SVE2)\n";
   OS << "#define svcvtnt_f16_x      svcvtnt_f16_m\n";
   OS << "#define svcvtnt_f16_f32_x  svcvtnt_f16_f32_m\n";
   OS << "#define svcvtnt_f32_x      svcvtnt_f32_m\n";
   OS << "#define svcvtnt_f32_f64_x  svcvtnt_f32_f64_m\n\n";
 
   OS << "#define svcvtxnt_f32_x     svcvtxnt_f32_m\n";
   OS << "#define svcvtxnt_f32_f64_x svcvtxnt_f32_f64_m\n\n";
 
-  OS << "#endif /*__ARM_FEATURE_SVE2 */\n\n";
-
   OS << "#ifdef __cplusplus\n";
   OS << "} // extern \"C\"\n";
   OS << "#endif\n\n";
   OS << "#undef __ai\n\n";
   OS << "#undef __aio\n\n";
-  OS << "#endif /*__ARM_FEATURE_SVE */\n\n";
   OS << "#endif /* __ARM_SVE_H */\n";
 }
 
 void SVEEmitter::createBuiltins(raw_ostream &OS) {
   std::vector<Record *> RV = Records.getAllDerivedDefinitions("Inst");
   SmallVector<std::unique_ptr<Intrinsic>, 128> Defs;
   for (auto *R : RV)
     createIntrinsic(R, Defs);
 
   // The mappings must be sorted based on BuiltinID.
   llvm::sort(Defs, [](const std::unique_ptr<Intrinsic> &A,
                       const std::unique_ptr<Intrinsic> &B) {
     return A->getMangledName() < B->getMangledName();
   });
 
   OS << "#ifdef GET_SVE_BUILTINS\n";
   for (auto &Def : Defs) {
     // Only create BUILTINs for non-overloaded intrinsics, as overloaded
     // declarations only live in the header file.
     if (Def->getClassKind() != ClassG)
-      OS << "BUILTIN(__builtin_sve_" << Def->getMangledName() << ", \""
-         << Def->getBuiltinTypeStr() << "\", \"n\")\n";
+      OS << "TARGET_BUILTIN(__builtin_sve_" << Def->getMangledName() << ", \""
+         << Def->getBuiltinTypeStr() << "\", \"n\", \"" << Def->getGuard()
+         << "\")\n";
   }
 
   // Add reinterpret builtins
   for (const ReinterpretTypeInfo &From : Reinterprets)
     for (const ReinterpretTypeInfo &To : Reinterprets)
-      OS << "BUILTIN(__builtin_sve_reinterpret_" << From.Suffix << "_"
+      OS << "TARGET_BUILTIN(__builtin_sve_reinterpret_" << From.Suffix << "_"
          << To.Suffix << +", \"" << From.BuiltinType << To.BuiltinType
-         << "\", \"n\")\n";
+         << "\", \"n\", \"sve\")\n";
 
   OS << "#endif\n\n";
-  }
 
 void SVEEmitter::createCodeGenMap(raw_ostream &OS) {
   std::vector<Record *> RV = Records.getAllDerivedDefinitions("Inst");
   SmallVector<std::unique_ptr<Intrinsic>, 128> Defs;
   for (auto *R : RV)
     createIntrinsic(R, Defs);
 
   // The mappings must be sorted based on BuiltinID.