[Clang] Make __arm_streaming apply only to prototyped functions.

[sdesmalen]

Remove changes that limited the attribute from being valid only when compiled with '+sme'.

[aaron.ballman]

LGTM!

clang/include/clang/Basic/Attr.td

class TargetSpec {
   code CustomCode = [{}];
 }
 
 class TargetArch<list<string> arches> : TargetSpec {
   let Arches = arches;
 }
 def TargetARM : TargetArch<["arm", "thumb", "armeb", "thumbeb"]>;
 def TargetAArch64 : TargetArch<["aarch64"]>;
+def TargetAArch64SME : TargetArch<["aarch64"]> {
+  let CustomCode = [{ Target.hasFeature("sme") }];
+}
 def TargetAnyArm : TargetArch<!listconcat(TargetARM.Arches, TargetAArch64.Arches)>;
 def TargetAVR : TargetArch<["avr"]>;
 def TargetBPF : TargetArch<["bpfel", "bpfeb"]>;
 def TargetMips32 : TargetArch<["mips", "mipsel"]>;
 def TargetAnyMips : TargetArch<["mips", "mipsel", "mips64", "mips64el"]>;
 def TargetMSP430 : TargetArch<["msp430"]>;
 def TargetM68k : TargetArch<["m68k"]>;
 def TargetRISCV : TargetArch<["riscv32", "riscv64"]>;
def AArch64VectorPcs: DeclOrTypeAttr {
   let Documentation = [AArch64VectorPcsDocs];
 }
 
 def AArch64SVEPcs: DeclOrTypeAttr {
   let Spellings = [Clang<"aarch64_sve_pcs">];
   let Documentation = [AArch64SVEPcsDocs];
 }
 
-def ArmStreaming : TypeAttr, TargetSpecificAttr<TargetAArch64> {
+def ArmStreaming : TypeAttr, TargetSpecificAttr<TargetAArch64SME> {
   let Spellings = [RegularKeyword<"__arm_streaming">];
-  let Documentation = [ArmStreamingDocs];
+  let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>;
+  let Documentation = [ArmSmeStreamingDocs];
 }
 
 def Pure : InheritableAttr {
   let Spellings = [GCC<"pure">];
   let Documentation = [Undocumented];
   let SimpleHandler = 1;
 }
 

clang/include/clang/Basic/AttrDocs.td

 from secure state. Entering from and returning to non-secure state would switch
 to and from secure state, respectively, and prevent flow of information
 to non-secure state, except via return values. See `ARMv8-M Security Extensions:
 Requirements on Development Tools - Engineering Specification Documentation
 <https://developer.arm.com/docs/ecm0359818/latest/>`_ for more information.
   }];
 }
 
-def ArmStreamingDocs : Documentation {
+def ArmSmeStreamingDocs : Documentation {
   let Category = DocCatType;
   let Content = [{
 .. Note:: This attribute has not been implemented yet, but once it is
    implemented, it will behave as described below.
 
 The ``__arm_streaming`` keyword is only available on AArch64 targets.
 It applies to function types and specifies that the function has a
 “streaming interface”.  This means that:
 
 * the function requires the Scalable Matrix Extension (SME)
 
 * the function must be entered in streaming mode (that is, with PSTATE.SM
   set to 1)
 
 * the function must return in streaming mode
 
+* the function does not have a K&R-style unprototyped function type.
+
 See `Procedure Call Standard for the Arm® 64-bit Architecture (AArch64)
 <https://github.com/ARM-software/abi-aa>`_ for more details about
 streaming-interface functions.
 
 Clang manages PSTATE.SM automatically; it is not the source code's
 responsibility to do this.  For example, if a normal non-streaming
 function calls an ``__arm_streaming`` function, Clang generates code
 that switches into streaming mode before calling the function and

clang/test/Parser/aarch64-sme-attrs-no-sme.c

+// Test that the attribute is ignored if we don't compile for both AArch64 with +sme.
+//
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -target-feature +sme -fsyntax-only -verify %s
+
+extern int normal_callee(void);
+
+// expected-error@+1 {{'__arm_streaming' is not supported on this target}}
+int streaming_caller(void) __arm_streaming {
+  return normal_callee();
+}
+
+// expected-error@+1 {{'__arm_locally_streaming' is not supported on this target}}
+__arm_locally_streaming int locally_streaming_caller(void) {
+  return normal_callee();
+}
+
+// expected-error@+1 {{'__arm_shared_za' is not supported on this target}}
+int shared_za_caller(void) __arm_shared_za {
+  return normal_callee();
+}
+
+// expected-error@+1 {{'__arm_preserves_za' is not supported on this target}}
+int preserves_za_caller(void) __arm_preserves_za {
+  return normal_callee();
+}
+
+// expected-error@+1 {{'__arm_new_za' is not supported on this target}}
+__arm_new_za int new_za_caller(void) {
+  return normal_callee();
+}

clang/test/Parser/c2x-attribute-keywords.c

 // RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,notc2x -Wno-strict-prototypes %s
 // RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,c2x %s
 
-enum __arm_streaming E { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-  One __arm_streaming, // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+enum __arm_streaming E { // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+  One __arm_streaming, // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   Two,
-  Three __arm_streaming // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  Three __arm_streaming // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 };
 
-enum __arm_streaming { Four }; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+enum __arm_streaming { Four }; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 __arm_streaming enum E2 { Five }; // expected-error {{misplaced '__arm_streaming'}}
 
 // FIXME: this diagnostic can be improved.
 enum { __arm_streaming Six }; // expected-error {{expected identifier}}
 
 // FIXME: this diagnostic can be improved.
 enum E3 __arm_streaming { Seven }; // expected-error {{expected identifier or '('}}
 
-struct __arm_streaming S1 { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+struct __arm_streaming S1 { // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   int i __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
   int __arm_streaming j; // expected-error {{'__arm_streaming' only applies to function types}}
   int k[10] __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
   int l __arm_streaming[10]; // expected-error {{'__arm_streaming' only applies to function types}}
   __arm_streaming int m, n; // expected-error {{'__arm_streaming' only applies to function types}}
   int o __arm_streaming : 12; // expected-error {{'__arm_streaming' only applies to function types}}
   int __arm_streaming : 0; // expected-error {{'__arm_streaming' only applies to function types}}
   int p, __arm_streaming : 0; // expected-error {{'__arm_streaming' cannot appear here}}
   int q, __arm_streaming r; // expected-error {{'__arm_streaming' cannot appear here}}
   __arm_streaming int; // expected-error {{'__arm_streaming' cannot appear here}} \
             // expected-warning {{declaration does not declare anything}}
 };
 
 __arm_streaming struct S2 { int a; }; // expected-error {{misplaced '__arm_streaming'}}
 struct S3 __arm_streaming { int a; }; // expected-error {{'__arm_streaming' cannot appear here}} \
-                                         expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                         expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
-union __arm_streaming U { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+union __arm_streaming U { // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   double d __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types; type here is 'double'}}
   __arm_streaming int i; // expected-error {{'__arm_streaming' only applies to function types; type here is 'int'}}
 };
 
 __arm_streaming union U2 { double d; }; // expected-error {{misplaced '__arm_streaming'}}
 union U3 __arm_streaming { double d; }; // expected-error {{'__arm_streaming' cannot appear here}} \
-                                           expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                           expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
-struct __arm_streaming IncompleteStruct; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-union __arm_streaming IncompleteUnion; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-enum __arm_streaming IncompleteEnum; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+struct __arm_streaming IncompleteStruct; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+union __arm_streaming IncompleteUnion; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+enum __arm_streaming IncompleteEnum; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
 __arm_streaming void f1(void); // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
 void __arm_streaming f2(void); // expected-error {{'__arm_streaming' only applies to function types}}
 void f3 __arm_streaming (void); // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
 void f4(void) __arm_streaming;
 
 void f5(int i __arm_streaming, __arm_streaming int j, int __arm_streaming k); // expected-error 3 {{'__arm_streaming' only applies to function types}}
 
void f11(void) {
   __arm_streaming if (1) {} // expected-error {{'__arm_streaming' cannot be applied to a statement}}
 
   __arm_streaming switch (1) { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
   __arm_streaming case 1: __arm_streaming break; // expected-error 2 {{'__arm_streaming' cannot be applied to a statement}}
   __arm_streaming default: break; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
   }
 
   goto foo;
-  __arm_streaming foo: (void)1; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  __arm_streaming foo: (void)1; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
   __arm_streaming for (;;); // expected-error {{'__arm_streaming' cannot be applied to a statement}}
   __arm_streaming while (1); // expected-error {{'__arm_streaming' cannot be applied to a statement}}
   __arm_streaming do __arm_streaming { } while(1); // expected-error 2 {{'__arm_streaming' cannot be applied to a statement}}
 
   __arm_streaming (void)1; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
 
   __arm_streaming; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
 
   (void)sizeof(int [4]__arm_streaming); // expected-error {{'__arm_streaming' only applies to function types}}
-  (void)sizeof(struct __arm_streaming S3 { int a __arm_streaming; }); // expected-error {{'__arm_streaming' cannot be applied to a declaration}} \
+  (void)sizeof(struct __arm_streaming S3 { int a __arm_streaming; }); // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}} \
                                                                       // expected-error {{'__arm_streaming' only applies to function types; type here is 'int'}}
 
   __arm_streaming return; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
 
   __arm_streaming asm (""); // expected-error {{'__arm_streaming' cannot appear here}}
 }
 
 struct __arm_streaming S4 *s; // expected-error {{'__arm_streaming' cannot appear here}}
 struct S5 {};
 int c = sizeof(struct __arm_streaming S5); // expected-error {{'__arm_streaming' cannot appear here}}

clang/test/Parser/c2x-attribute-keywords.m

 // RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify %s
 
-enum __arm_streaming E1 : int; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+enum __arm_streaming E1 : int; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
 @interface Base
 @end
 
 @interface S : Base
 - (void) bar;
 @end
 
 @interface T : Base
 - (S *) foo;
 @end
 
 
 void f(T *t) {
   __arm_streaming[[t foo] bar]; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
 }

clang/test/Parser/cxx0x-keyword-attributes.cpp

-// RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu %s
+// RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu -target-feature +sme %s
 
 // Need std::initializer_list
 namespace std {
   typedef decltype(sizeof(int)) size_t;
 
   // libc++'s implementation
   template <class _E>
   class initializer_list

 int & __arm_streaming ref_attr = after_attr; // expected-error {{'__arm_streaming' only applies to function types}}
 int && __arm_streaming rref_attr = 0; // expected-error {{'__arm_streaming' only applies to function types}}
 int array_attr [1] __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
 void fn_attr () __arm_streaming;
 void noexcept_fn_attr () noexcept __arm_streaming;
 struct MemberFnOrder {
   virtual void f() const volatile && noexcept __arm_streaming final = 0;
 };
-struct __arm_streaming struct_attr; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-class __arm_streaming class_attr {}; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-union __arm_streaming union_attr; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-enum __arm_streaming E { }; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+struct __arm_streaming struct_attr; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+class __arm_streaming class_attr {}; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+union __arm_streaming union_attr; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+enum __arm_streaming E { }; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 namespace test_misplacement {
 __arm_streaming struct struct_attr2;  // expected-error {{misplaced '__arm_streaming'}}
 __arm_streaming class class_attr2; // expected-error {{misplaced '__arm_streaming'}}
 __arm_streaming union union_attr2; // expected-error {{misplaced '__arm_streaming'}}
 __arm_streaming enum  E2 { }; // expected-error {{misplaced '__arm_streaming'}}
 }
 
 // Checks attributes placed at wrong syntactic locations of class specifiers.
-class __arm_streaming __arm_streaming // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+class __arm_streaming __arm_streaming // expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
   attr_after_class_name_decl __arm_streaming __arm_streaming; // expected-error {{'__arm_streaming' cannot appear here}} \
-                                                                 expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+                                                                 expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
 
-class __arm_streaming __arm_streaming // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+class __arm_streaming __arm_streaming // expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
  attr_after_class_name_definition __arm_streaming __arm_streaming __arm_streaming{}; // expected-error {{'__arm_streaming' cannot appear here}} \
-                                                                                        expected-error 3 {{'__arm_streaming' cannot be applied to a declaration}}
+                                                                                        expected-error 3 {{'__arm_streaming' only applies to non-K&R-style functions}}
 
-class __arm_streaming c {}; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+class __arm_streaming c {}; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 class c __arm_streaming __arm_streaming x; // expected-error 2 {{'__arm_streaming' only applies to function types}}
 class c __arm_streaming __arm_streaming y __arm_streaming __arm_streaming; // expected-error 4 {{'__arm_streaming' only applies to function types}}
 class c final [(int){0}];
 
 class base {};
-class __arm_streaming __arm_streaming final_class // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+class __arm_streaming __arm_streaming final_class // expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
   __arm_streaming alignas(float) final // expected-error {{'__arm_streaming' cannot appear here}} \
-                                          expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                          expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   __arm_streaming alignas(float) __arm_streaming alignas(float): base{}; // expected-error {{'__arm_streaming' cannot appear here}}
 
-class __arm_streaming __arm_streaming final_class_another // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+class __arm_streaming __arm_streaming final_class_another // expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
   __arm_streaming __arm_streaming alignas(16) final // expected-error {{'__arm_streaming' cannot appear here}} \
-                                                       expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+                                                       expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
   __arm_streaming __arm_streaming alignas(16) __arm_streaming{}; // expected-error {{'__arm_streaming' cannot appear here}}
 
 class after_class_close {} __arm_streaming; // expected-error {{'__arm_streaming' cannot appear here, place it after "class" to apply it to the type declaration}}
 
 class C {};
 
 __arm_streaming struct with_init_declarators {} init_declarator; // expected-error {{'__arm_streaming' only applies to function types}}
 __arm_streaming struct no_init_declarators; // expected-error {{misplaced '__arm_streaming'}}
 template<typename> __arm_streaming struct no_init_declarators_template; // expected-error {{'__arm_streaming' cannot appear here}}
 void fn_with_structs() {
   __arm_streaming struct with_init_declarators {} init_declarator; // expected-error {{'__arm_streaming' only applies to function types}}
   __arm_streaming struct no_init_declarators; // expected-error {{'__arm_streaming' cannot appear here}}
 }
-__arm_streaming; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+__arm_streaming; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 struct ctordtor {
   __arm_streaming ctordtor __arm_streaming () __arm_streaming; // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
   ctordtor (C) __arm_streaming;
   __arm_streaming ~ctordtor __arm_streaming () __arm_streaming; // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
 };
 __arm_streaming ctordtor::ctordtor __arm_streaming () __arm_streaming {} // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
 __arm_streaming ctordtor::ctordtor (C) __arm_streaming try {} catch (...) {} // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
 __arm_streaming ctordtor::~ctordtor __arm_streaming () __arm_streaming {} // expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}

 extern "C++" __arm_streaming { } // expected-error {{'__arm_streaming' cannot appear here}}
 __arm_streaming extern "C++" { } // expected-error {{'__arm_streaming' cannot appear here}}
 __arm_streaming template <typename T> void before_template_attr (); // expected-error {{'__arm_streaming' cannot appear here}}
 __arm_streaming namespace ns { int i; } // expected-error {{'__arm_streaming' cannot appear here}}
 __arm_streaming static_assert(true, ""); //expected-error {{'__arm_streaming' cannot appear here}}
 __arm_streaming asm(""); // expected-error {{'__arm_streaming' cannot appear here}}
 
 __arm_streaming using ns::i; // expected-warning {{ISO C++}} \
-                                expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-__arm_streaming using namespace ns; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+__arm_streaming using namespace ns; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 namespace __arm_streaming ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}} \
-                                    expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                    expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
 using __arm_streaming alignas(4)__arm_streaming ns::i;          // expected-warning 2 {{ISO C++}} \
                                                                    expected-error {{'__arm_streaming' cannot appear here}} \
                                                                    expected-error {{'alignas' attribute only applies to variables, data members and tag types}} \
                                                                    expected-warning {{ISO C++}} \
-                                                                   expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+                                                                   expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
 using __arm_streaming alignas(4) __arm_streaming foobar = int; // expected-error {{'__arm_streaming' cannot appear here}} \
                                                                   expected-error {{'alignas' attribute only applies to}} \
                                                                   expected-error 2 {{'__arm_streaming' only applies to function types}}
 
 __arm_streaming using T = int; // expected-error {{'__arm_streaming' cannot appear here}}
 using T __arm_streaming = int; // expected-error {{'__arm_streaming' only applies to function types}}
 template<typename T> using U __arm_streaming = T; // expected-error {{'__arm_streaming' only applies to function types}}
 using ns::i __arm_streaming; // expected-warning {{ISO C++}} \
-                                expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 using ns::i __arm_streaming, ns::i __arm_streaming; // expected-warning 2 {{ISO C++}} \
                                                        expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
-                                                       expected-error 2 {{'__arm_streaming' cannot be applied to a declaration}}
+                                                       expected-error 2 {{'__arm_streaming' only applies to non-K&R-style functions}}
 struct using_in_struct_base {
   typedef int i, j, k, l;
 };
 struct using_in_struct : using_in_struct_base {
   __arm_streaming using using_in_struct_base::i; // expected-warning {{ISO C++}} \
-                                                    expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                                    expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   using using_in_struct_base::j __arm_streaming; // expected-warning {{ISO C++}} \
-                                                    expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                                    expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   __arm_streaming using using_in_struct_base::k __arm_streaming, using_in_struct_base::l __arm_streaming; // expected-warning 3 {{ISO C++}} \
                                                                                                              expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
-                                                                                                             expected-error 4 {{'__arm_streaming' cannot be applied to a declaration}}
+                                                                                                             expected-error 4 {{'__arm_streaming' only applies to non-K&R-style functions}}
 };
 using __arm_streaming ns::i; // expected-warning {{ISO C++}} \
                                 expected-error {{'__arm_streaming' cannot appear here}} \
-                                expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 using T __arm_streaming = int; // expected-error {{'__arm_streaming' only applies to function types}}
 
 auto trailing() -> __arm_streaming const int; // expected-error {{'__arm_streaming' cannot appear here}}
 auto trailing() -> const __arm_streaming int; // expected-error {{'__arm_streaming' cannot appear here}}
 auto trailing() -> const int __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
 auto trailing_2() -> struct struct_attr __arm_streaming; // expected-error {{'__arm_streaming' only applies to function types}}
 
 namespace N {
   struct S {};
 };
 template<typename> struct Template {};
 
 // FIXME: Improve this diagnostic
 struct __arm_streaming N::S s; // expected-error {{'__arm_streaming' cannot appear here}}
 struct __arm_streaming Template<int> t; // expected-error {{'__arm_streaming' cannot appear here}}
 struct __arm_streaming ::template Template<int> u; // expected-error {{'__arm_streaming' cannot appear here}}
 template struct __arm_streaming Template<char>; // expected-error {{'__arm_streaming' cannot appear here}}
 template struct __attribute__((pure)) Template<std::size_t>; // We still allow GNU-style attributes here
-template <> struct __arm_streaming Template<void>; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+template <> struct __arm_streaming Template<void>; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
-enum __arm_streaming E1 {}; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+enum __arm_streaming E1 {}; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 enum __arm_streaming E2; // expected-error {{forbids forward references}} \
-                            expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-enum __arm_streaming E1; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-enum __arm_streaming E3 : int; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
-enum __arm_streaming { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                            expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+enum __arm_streaming E1; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+enum __arm_streaming E3 : int; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
+enum __arm_streaming { // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
   k_123 __arm_streaming = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}} \
-                                 expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+                                 expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 };
 enum __arm_streaming E1 e; // expected-error {{'__arm_streaming' cannot appear here}}
 enum __arm_streaming class E4 { }; // expected-error {{'__arm_streaming' cannot appear here}}
-enum struct __arm_streaming E5; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+enum struct __arm_streaming E5; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 enum E6 {} __arm_streaming; // expected-error {{'__arm_streaming' cannot appear here, place it after "enum" to apply it to the type declaration}}
 
 struct S {
   friend int f __arm_streaming (); // expected-error {{'__arm_streaming' cannot appear here}} \
                                       expected-error {{'__arm_streaming' cannot be applied to a declaration}}
   friend int f2 __arm_streaming () {} // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
   __arm_streaming friend int g(); // expected-error {{'__arm_streaming' cannot appear here}}
   __arm_streaming friend int h() { // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
void foo () {
 
   __arm_streaming switch (i) { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
     __arm_streaming case 0: // expected-error {{'__arm_streaming' cannot be applied to a statement}}
     __arm_streaming default: // expected-error {{'__arm_streaming' cannot be applied to a statement}}
       __arm_streaming break; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
   }
 
   __arm_streaming goto there; // expected-error {{'__arm_streaming' cannot be applied to a statement}}
-  __arm_streaming there: // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+  __arm_streaming there: // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
   __arm_streaming try { // expected-error {{'__arm_streaming' cannot be applied to a statement}}
   } __arm_streaming catch (...) { // expected-error {{'__arm_streaming' cannot appear here}}
   }
 
   void bar __arm_streaming (__arm_streaming int i, __arm_streaming int j); // expected-error 2 {{'__arm_streaming' only applies to function types}} \
                                                                               expected-error {{'__arm_streaming' cannot be applied to a declaration}}
   using FuncType = void (__arm_streaming int); // expected-error {{'__arm_streaming' only applies to function types}}
void baz () {
 
   for (__arm_streaming int n : { 1, 2, 3 }) { // expected-error {{'__arm_streaming' only applies to function types}}
   }
 }
 
 enum class __attribute__((visibility("hidden"))) SecretKeepers {
   one, /* rest are deprecated */ two, three
 };
-enum class __arm_streaming EvenMoreSecrets {}; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+enum class __arm_streaming EvenMoreSecrets {}; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
 // Forbid attributes on decl specifiers.
 unsigned __arm_streaming static int __arm_streaming v1; // expected-error {{'__arm_streaming' only applies to function types}} \
            expected-error {{'__arm_streaming' cannot appear here}}
 typedef __arm_streaming unsigned long __arm_streaming v2; // expected-error {{'__arm_streaming' only applies to function types}} \
           expected-error {{'__arm_streaming' cannot appear here}}
 int __arm_streaming foo(int __arm_streaming x); // expected-error 2 {{'__arm_streaming' only applies to function types}}
 
-__arm_streaming; // expected-error {{'__arm_streaming' cannot be applied to a declaration}}
+__arm_streaming; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}}
 
 class A {
   A(__arm_streaming int a); // expected-error {{'__arm_streaming' only applies to function types}}
 };
 A::A(__arm_streaming int a) {} // expected-error {{'__arm_streaming' only applies to function types}}
 
 template<typename T> struct TemplateStruct {};
 class FriendClassesWithAttributes {

 struct C : __arm_streaming virtual A {}; // expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
 struct D : __arm_streaming public virtual A {}; // expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
 struct E : public __arm_streaming virtual A {}; // expected-error {{'__arm_streaming' cannot appear here}} \
                                                    expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
 struct F : virtual __arm_streaming public A {}; // expected-error {{'__arm_streaming' cannot appear here}} \
                                                    expected-error {{'__arm_streaming' cannot be applied to a base specifier}}
 }
 
-namespace __arm_streaming ns_attr {}; // expected-error {{'__arm_streaming' cannot be applied to a declaration}} \
+namespace __arm_streaming ns_attr {}; // expected-error {{'__arm_streaming' only applies to non-K&R-style functions}} \
                                          expected-warning {{attributes on a namespace declaration are a C++17 extension}}