Renamed and changed the wording of warn_cconv_ignored

As discussed in D64780 the wording of this warning message is being
changed to say 'is not supported' instead of 'ignored', and the
diag ID itself is being changed to warn_cconv_not_supported.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@366368 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index c68271b784da12a494dabbb1a64151dfc233f9df..effcbad78b2318f0752689618e9c87d059f3157d 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -2957,8 +2957,8 @@ def err_attribute_vecreturn_only_pod_record : Error<
 def err_cconv_change : Error<
   "function declared '%0' here was previously declared "
   "%select{'%2'|without calling convention}1">;
-def warn_cconv_ignored : Warning<
-  "%0 calling convention ignored %select{"
+def warn_cconv_unsupported : Warning<
+  "%0 calling convention is not supported %select{"
   // Use CallingConventionIgnoredReason Enum to specify these.
   "for this target"
   "|on variadic function"

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 0709c926ed90e1fd8d7fb0cedaf84b9b10ed9be5..cc91ec5946844f17348cd2e0acaa7c2ac7b11671 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -3165,7 +3165,7 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
       // Calling Conventions on a Builtin aren't really useful and setting a
       // default calling convention and cdecl'ing some builtin redeclarations is
       // common, so warn and ignore the calling convention on the redeclaration.
-      Diag(New->getLocation(), diag::warn_cconv_ignored)
+      Diag(New->getLocation(), diag::warn_cconv_unsupported)
           << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
           << (int)CallingConventionIgnoredReason::BuiltinFunction;
       NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());

diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
index 725a7770d67d7cec51ccc3d4c42d718679cdc711..ee06f8ae5114714b2e5c7a2b0e7644843d75a18a 100644 (file)
--- a/lib/Sema/SemaDeclAttr.cpp
+++ b/lib/Sema/SemaDeclAttr.cpp
@@ -4669,7 +4669,7 @@ bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
     break;
 
   case TargetInfo::CCCR_Warning: {
-    Diag(Attrs.getLoc(), diag::warn_cconv_ignored)
+    Diag(Attrs.getLoc(), diag::warn_cconv_unsupported)
         << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget;
 
     // This convention is not valid for the target. Use the default function or

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 12bad62d1f1dd2db4d45aeef9e854ae8f7f5371b..bb71db7609f55766e6b3c553986435d2658def77 100644 (file)
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -7038,7 +7038,7 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
       // stdcall and fastcall are ignored with a warning for GCC and MS
       // compatibility.
       if (CC == CC_X86StdCall || CC == CC_X86FastCall)
-        return S.Diag(attr.getLoc(), diag::warn_cconv_ignored)
+        return S.Diag(attr.getLoc(), diag::warn_cconv_unsupported)
                << FunctionType::getNameForCallConv(CC)
                << (int)Sema::CallingConventionIgnoredReason::VariadicFunction;
 
@@ -7103,7 +7103,7 @@ void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
     // Issue a warning on ignored calling convention -- except of __stdcall.
     // Again, this is what MS compiler does.
     if (CurCC != CC_X86StdCall)
-      Diag(Loc, diag::warn_cconv_ignored)
+      Diag(Loc, diag::warn_cconv_unsupported)
           << FunctionType::getNameForCallConv(CurCC)
           << (int)Sema::CallingConventionIgnoredReason::ConstructorDestructor;
   // Default adjustment.

diff --git a/test/CodeGen/aarch64-vpcs.c b/test/CodeGen/aarch64-vpcs.c
index a9edb7490c630b15993f1e5794f65ef3793df304..7e4f50cb87badf07adb6fc62043091a7525a2929 100644 (file)
--- a/test/CodeGen/aarch64-vpcs.c
+++ b/test/CodeGen/aarch64-vpcs.c
@@ -2,7 +2,7 @@
 // RUN: %clang_cc1 -triple aarch64-linux-gnu -emit-llvm -x c++ -o - %s | FileCheck %s -check-prefix=CHECKCXX
 // RUN: %clang_cc1 -triple i686-pc-linux-gnu -verify %s
 
-void __attribute__((aarch64_vector_pcs)) f(int *); // expected-warning {{'aarch64_vector_pcs' calling convention ignored for this target}}
+void __attribute__((aarch64_vector_pcs)) f(int *); // expected-warning {{'aarch64_vector_pcs' calling convention is not supported for this target}}
 
 // CHECKC: define void @g(
 // CHECKCXX: define void @_Z1gPi(
@@ -16,7 +16,7 @@ void g(int *a) {
 // CHECKC: declare aarch64_vector_pcs void @f(
 // CHECKCXX: declare aarch64_vector_pcs void @_Z1fPi
 
-void __attribute__((aarch64_vector_pcs)) h(int *a){ // expected-warning {{'aarch64_vector_pcs' calling convention ignored for this target}}
+void __attribute__((aarch64_vector_pcs)) h(int *a){ // expected-warning {{'aarch64_vector_pcs' calling convention is not supported for this target}}
 // CHECKC: define aarch64_vector_pcs void @h(
 // CHECKCXX: define aarch64_vector_pcs void @_Z1hPi(
   f(a);

diff --git a/test/Frontend/macro_defined_type.cpp b/test/Frontend/macro_defined_type.cpp
index 7a4427e42c0992f285cbe507814cad28d0115655..d4f54b65a8d686aabc43cd8b7cad440aee527bc4 100644 (file)
--- a/test/Frontend/macro_defined_type.cpp
+++ b/test/Frontend/macro_defined_type.cpp
@@ -17,5 +17,5 @@ void Func() {
 // Added test for fix for P41835
 #define _LIBCPP_FLOAT_ABI __attribute__((pcs("aapcs")))
 struct A {
-  _LIBCPP_FLOAT_ABI int operator()() throw(); // expected-warning{{'pcs' calling convention ignored for this target}}
+  _LIBCPP_FLOAT_ABI int operator()() throw(); // expected-warning{{'pcs' calling convention is not supported for this target}}
 };

diff --git a/test/Sema/callingconv-iamcu.c b/test/Sema/callingconv-iamcu.c
index 2c99b029b6a2878c2aca9761b5b8cf5e647186c2..248e98b0d01df881b804ebd2bc6a4f14b56c4b07 100644 (file)
--- a/test/Sema/callingconv-iamcu.c
+++ b/test/Sema/callingconv-iamcu.c
@@ -1,35 +1,35 @@
 // RUN: %clang_cc1 %s -fsyntax-only -triple i686-intel-elfiamcu -verify
 
-void __attribute__((fastcall)) foo(float *a) { // expected-warning {{'fastcall' calling convention ignored for this target}}
+void __attribute__((fastcall)) foo(float *a) { // expected-warning {{'fastcall' calling convention is not supported for this target}}
 }
 
-void __attribute__((stdcall)) bar(float *a) { // expected-warning {{'stdcall' calling convention ignored for this target}}
+void __attribute__((stdcall)) bar(float *a) { // expected-warning {{'stdcall' calling convention is not supported for this target}}
 }
 
 void __attribute__((fastcall(1))) baz(float *a) { // expected-error {{'fastcall' attribute takes no arguments}}
 }
 
-void __attribute__((fastcall)) test2(int a, ...) { // expected-warning {{'fastcall' calling convention ignored for this target}}
+void __attribute__((fastcall)) test2(int a, ...) { // expected-warning {{'fastcall' calling convention is not supported for this target}}
 }
-void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{'stdcall' calling convention ignored for this target}}
+void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{'stdcall' calling convention is not supported for this target}}
 }
-void __attribute__((thiscall)) test4(int a, ...) { // expected-warning {{'thiscall' calling convention ignored for this target}}
+void __attribute__((thiscall)) test4(int a, ...) { // expected-warning {{'thiscall' calling convention is not supported for this target}}
 }
 
 void __attribute__((cdecl)) ctest0() {}
 
 void __attribute__((cdecl(1))) ctest1(float x) {} // expected-error {{'cdecl' attribute takes no arguments}}
 
-void (__attribute__((fastcall)) *pfoo)(float*) = foo; // expected-warning {{'fastcall' calling convention ignored for this target}}
+void (__attribute__((fastcall)) *pfoo)(float*) = foo; // expected-warning {{'fastcall' calling convention is not supported for this target}}
 
-void (__attribute__((stdcall)) *pbar)(float*) = bar; // expected-warning {{'stdcall' calling convention ignored for this target}}
+void (__attribute__((stdcall)) *pbar)(float*) = bar; // expected-warning {{'stdcall' calling convention is not supported for this target}}
 
 void (*pctest0)() = ctest0;
 
 void ctest2() {}
 void (__attribute__((cdecl)) *pctest2)() = ctest2;
 
-typedef void (__attribute__((fastcall)) *Handler) (float *); // expected-warning {{'fastcall' calling convention ignored for this target}}
+typedef void (__attribute__((fastcall)) *Handler) (float *); // expected-warning {{'fastcall' calling convention is not supported for this target}}
 Handler H = foo;
 
 int __attribute__((pcs("aapcs", "aapcs"))) pcs1(void); // expected-error {{'pcs' attribute takes one argument}}
@@ -38,16 +38,16 @@ int __attribute__((pcs(pcs1))) pcs3(void); // expected-error {{'pcs' attribute r
                                            // expected-error {{invalid PCS type}}
 int __attribute__((pcs(0))) pcs4(void); // expected-error {{'pcs' attribute requires a string}}
 /* These are ignored because the target is i386 and not ARM */
-int __attribute__((pcs("aapcs"))) pcs5(void); // expected-warning {{'pcs' calling convention ignored for this target}}
-int __attribute__((pcs("aapcs-vfp"))) pcs6(void); // expected-warning {{'pcs' calling convention ignored for this target}}
+int __attribute__((pcs("aapcs"))) pcs5(void); // expected-warning {{'pcs' calling convention is not supported for this target}}
+int __attribute__((pcs("aapcs-vfp"))) pcs6(void); // expected-warning {{'pcs' calling convention is not supported for this target}}
 int __attribute__((pcs("foo"))) pcs7(void); // expected-error {{invalid PCS type}}
 
 void ctest3();
 void __attribute__((cdecl)) ctest3() {}
 
-typedef __attribute__((stdcall)) void (*PROC)(); // expected-warning {{'stdcall' calling convention ignored for this target}}
+typedef __attribute__((stdcall)) void (*PROC)(); // expected-warning {{'stdcall' calling convention is not supported for this target}}
 PROC __attribute__((cdecl)) ctest4(const char *x) {}
 
-void __attribute__((intel_ocl_bicc)) inteloclbifunc(float *a) {} // expected-warning {{'intel_ocl_bicc' calling convention ignored for this target}}
+void __attribute__((intel_ocl_bicc)) inteloclbifunc(float *a) {} // expected-warning {{'intel_ocl_bicc' calling convention is not supported for this target}}
 
-struct type_test {} __attribute__((stdcall)); // expected-warning {{'stdcall' calling convention ignored for this target}} expected-warning {{'stdcall' attribute only applies to functions and methods}}
+struct type_test {} __attribute__((stdcall)); // expected-warning {{'stdcall' calling convention is not supported for this target}} expected-warning {{'stdcall' attribute only applies to functions and methods}}

diff --git a/test/Sema/callingconv.c b/test/Sema/callingconv.c
index e6d6ad2c12048af04f49aec7103c8a5bdb28c800..6273d04f21217d8fa0f933861664f1f8b3ce5be1 100644 (file)
--- a/test/Sema/callingconv.c
+++ b/test/Sema/callingconv.c
@@ -16,9 +16,9 @@ void __attribute__((fastcall)) test0() {
 void __attribute__((fastcall)) test1(void) {
 }
 
-void __attribute__((fastcall)) test2(int a, ...) { // expected-warning {{fastcall calling convention ignored on variadic function}}
+void __attribute__((fastcall)) test2(int a, ...) { // expected-warning {{fastcall calling convention is not supported on variadic function}}
 }
-void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{stdcall calling convention ignored on variadic function}}
+void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{stdcall calling convention is not supported on variadic function}}
 }
 void __attribute__((thiscall)) test4(int a, ...) { // expected-error {{variadic function cannot use thiscall calling convention}}
 }
@@ -47,11 +47,11 @@ int __attribute__((pcs(pcs1))) pcs3(void); // expected-error {{'pcs' attribute r
                                            // expected-error {{invalid PCS type}}
 int __attribute__((pcs(0))) pcs4(void); // expected-error {{'pcs' attribute requires a string}}
 /* These are ignored because the target is i386 and not ARM */
-int __attribute__((pcs("aapcs"))) pcs5(void); // expected-warning {{'pcs' calling convention ignored for this target}}
-int __attribute__((pcs("aapcs-vfp"))) pcs6(void); // expected-warning {{'pcs' calling convention ignored for this target}}
+int __attribute__((pcs("aapcs"))) pcs5(void); // expected-warning {{'pcs' calling convention is not supported for this target}}
+int __attribute__((pcs("aapcs-vfp"))) pcs6(void); // expected-warning {{'pcs' calling convention is not supported for this target}}
 int __attribute__((pcs("foo"))) pcs7(void); // expected-error {{invalid PCS type}}
 
-int __attribute__((aarch64_vector_pcs)) aavpcs(void); // expected-warning {{'aarch64_vector_pcs' calling convention ignored for this target}}
+int __attribute__((aarch64_vector_pcs)) aavpcs(void); // expected-warning {{'aarch64_vector_pcs' calling convention is not supported for this target}}
 
 // PR6361
 void ctest3();
@@ -69,4 +69,4 @@ void __attribute__((stdcall)) typedef_fun(int x) { } // expected-error {{functio
 
 struct type_test {} __attribute__((stdcall));  // expected-warning {{'stdcall' attribute only applies to functions and methods}}
 
-void __vectorcall __builtin_unreachable(); // expected-warning {{vectorcall calling convention ignored on builtin function}}
+void __vectorcall __builtin_unreachable(); // expected-warning {{vectorcall calling convention is not supported on builtin function}}

diff --git a/test/Sema/mrtd.c b/test/Sema/mrtd.c
index 7bdeb27293b780dd3ce2b74097dcf51bee457ad5..0ce08880606435cb2957aaa41411b2c5355489cc 100644 (file)
--- a/test/Sema/mrtd.c
+++ b/test/Sema/mrtd.c
@@ -12,7 +12,7 @@ void __attribute__((stdcall)) nonvariadic1(int a, int b, int c);
 void nonvariadic2(int a, int b, int c);
 void __attribute__((stdcall)) nonvariadic2(int a, int b, int c) { }
 
-// expected-warning@+2 {{stdcall calling convention ignored on variadic function}}
+// expected-warning@+2 {{stdcall calling convention is not supported on variadic function}}
 void variadic(int a, ...);
 void __attribute__((stdcall)) variadic(int a, ...);
 
@@ -33,6 +33,6 @@ __attribute__((cdecl)) extern void (*b)(int, ...);
 extern void (*c)(int, int);
 __attribute__((stdcall)) extern void (*c)(int, int);
 
-// expected-warning@+2 {{stdcall calling convention ignored on variadic function}}
+// expected-warning@+2 {{stdcall calling convention is not supported on variadic function}}
 extern void (*d)(int, ...);
 __attribute__((stdcall)) extern void (*d)(int, ...);

diff --git a/test/Sema/pr25786.c b/test/Sema/pr25786.c
index bfc2b35ede23929d9b4e245f9f021f130cfdb4e3..f79d8144716b1f4f076b0067de3d898cd6c6f4ce 100644 (file)
--- a/test/Sema/pr25786.c
+++ b/test/Sema/pr25786.c
@@ -2,8 +2,8 @@
 // RUN: %clang_cc1 -triple i686-unknown-linux-gnu -fsyntax-only -verify %s
 
 #if TEST
-void (__attribute__((regparm(3), stdcall)) *pf) (); //expected-warning {{'stdcall' calling convention ignored for this target}}
-void (__attribute__((regparm(2), stdcall)) foo)(int a) { //expected-warning {{'stdcall' calling convention ignored for this target}}
+void (__attribute__((regparm(3), stdcall)) *pf) (); //expected-warning {{'stdcall' calling convention is not supported for this target}}
+void (__attribute__((regparm(2), stdcall)) foo)(int a) { //expected-warning {{'stdcall' calling convention is not supported for this target}}
 }
 #else
 //expected-no-diagnostics

diff --git a/test/Sema/stdcall-fastcall-x64.c b/test/Sema/stdcall-fastcall-x64.c
index e2e39e434f810038e1500997af6393ad439a5386..335da4169352a318929e92f45fa500f47c0ca86a 100644 (file)
--- a/test/Sema/stdcall-fastcall-x64.c
+++ b/test/Sema/stdcall-fastcall-x64.c
@@ -5,16 +5,16 @@ int __attribute__((stdcall)) var1; // expected-warning{{'stdcall' only applies t
 int __attribute__((fastcall)) var2; // expected-warning{{'fastcall' only applies to function types; type here is 'int'}}
 
 // Different CC qualifiers are not compatible
-void __attribute__((stdcall, fastcall)) foo3(void); // expected-warning{{'stdcall' calling convention ignored for this target}} expected-warning {{'fastcall' calling convention ignored for this target}}
-void __attribute__((stdcall)) foo4(); // expected-warning{{'stdcall' calling convention ignored for this target}}
-void __attribute__((fastcall)) foo4(void); // expected-warning {{'fastcall' calling convention ignored for this target}}
+void __attribute__((stdcall, fastcall)) foo3(void); // expected-warning{{'stdcall' calling convention is not supported for this target}} expected-warning {{'fastcall' calling convention is not supported for this target}}
+void __attribute__((stdcall)) foo4(); // expected-warning{{'stdcall' calling convention is not supported for this target}}
+void __attribute__((fastcall)) foo4(void); // expected-warning {{'fastcall' calling convention is not supported for this target}}
 
 // rdar://8876096
-void rdar8876096foo1(int i, int j) __attribute__((fastcall, cdecl)); // expected-warning{{'fastcall' calling convention ignored for this target}}
-void rdar8876096foo2(int i, int j) __attribute__((fastcall, stdcall)); // expected-warning{{'stdcall' calling convention ignored for this target}} expected-warning {{'fastcall' calling convention ignored for this target}}
-void rdar8876096foo3(int i, int j) __attribute__((fastcall, regparm(2))); // expected-warning {{'fastcall' calling convention ignored for this target}}
-void rdar8876096foo4(int i, int j) __attribute__((stdcall, cdecl)); // expected-warning{{'stdcall' calling convention ignored for this target}}
-void rdar8876096foo5(int i, int j) __attribute__((stdcall, fastcall)); // expected-warning{{'stdcall' calling convention ignored for this target}} expected-warning {{'fastcall' calling convention ignored for this target}}
-void rdar8876096foo6(int i, int j) __attribute__((cdecl, fastcall)); // expected-warning {{'fastcall' calling convention ignored for this target}}
-void rdar8876096foo7(int i, int j) __attribute__((cdecl, stdcall)); // expected-warning{{'stdcall' calling convention ignored for this target}}
-void rdar8876096foo8(int i, int j) __attribute__((regparm(2), fastcall)); // expected-warning {{'fastcall' calling convention ignored for this target}}
+void rdar8876096foo1(int i, int j) __attribute__((fastcall, cdecl)); // expected-warning{{'fastcall' calling convention is not supported for this target}}
+void rdar8876096foo2(int i, int j) __attribute__((fastcall, stdcall)); // expected-warning{{'stdcall' calling convention is not supported for this target}} expected-warning {{'fastcall' calling convention is not supported for this target}}
+void rdar8876096foo3(int i, int j) __attribute__((fastcall, regparm(2))); // expected-warning {{'fastcall' calling convention is not supported for this target}}
+void rdar8876096foo4(int i, int j) __attribute__((stdcall, cdecl)); // expected-warning{{'stdcall' calling convention is not supported for this target}}
+void rdar8876096foo5(int i, int j) __attribute__((stdcall, fastcall)); // expected-warning{{'stdcall' calling convention is not supported for this target}} expected-warning {{'fastcall' calling convention is not supported for this target}}
+void rdar8876096foo6(int i, int j) __attribute__((cdecl, fastcall)); // expected-warning {{'fastcall' calling convention is not supported for this target}}
+void rdar8876096foo7(int i, int j) __attribute__((cdecl, stdcall)); // expected-warning{{'stdcall' calling convention is not supported for this target}}
+void rdar8876096foo8(int i, int j) __attribute__((regparm(2), fastcall)); // expected-warning {{'fastcall' calling convention is not supported for this target}}

diff --git a/test/SemaCUDA/cuda-inherits-calling-conv.cu b/test/SemaCUDA/cuda-inherits-calling-conv.cu
index 881f2945b1b34738172d001d6cfee436a1cf7c7a..a6928e71f3ae09d6310595c485cac4fe01aa5bce 100644 (file)
--- a/test/SemaCUDA/cuda-inherits-calling-conv.cu
+++ b/test/SemaCUDA/cuda-inherits-calling-conv.cu
@@ -24,7 +24,7 @@ struct Foo<T()> {};
 // expected-no-diagnostics
 #else
 // expected-error@+4 {{redefinition of 'Foo}}
-// expected-warning@+3 {{'__fastcall' calling convention ignored}}
+// expected-warning@+3 {{'__fastcall' calling convention is not supported}}
 #endif
 template <class T>
 struct Foo<T __fastcall()> {};

diff --git a/test/SemaCXX/borland-extensions.cpp b/test/SemaCXX/borland-extensions.cpp
index 31ebf0371292495fcef96d0680cd8adb1c11023a..a869f4ee60e90d83238da37a8486ad57a60793e5 100644 (file)
--- a/test/SemaCXX/borland-extensions.cpp
+++ b/test/SemaCXX/borland-extensions.cpp
@@ -7,21 +7,21 @@
 int dummy_function() { return 0; }
 
 // 2. test __pascal
-// expected-warning@+1 {{'_pascal' calling convention ignored for this target}}
+// expected-warning@+1 {{'_pascal' calling convention is not supported for this target}}
 int _pascal f2();
 
-// expected-warning@+1 {{'__pascal' calling convention ignored for this target}}
+// expected-warning@+1 {{'__pascal' calling convention is not supported for this target}}
 float __pascal gi2(int, int); 
-// expected-warning@+1 {{'__pascal' calling convention ignored for this target}}
+// expected-warning@+1 {{'__pascal' calling convention is not supported for this target}}
 template<typename T> T g2(T (__pascal * const )(int, int)) { return 0; }
 
 struct M {
-    // expected-warning@+1 {{'__pascal' calling convention ignored for this target}}
+    // expected-warning@+1 {{'__pascal' calling convention is not supported for this target}}
     int __pascal addP();
-    // expected-warning@+1 {{'__pascal' calling convention ignored for this target}}
+    // expected-warning@+1 {{'__pascal' calling convention is not supported for this target}}
     float __pascal subtractP(); 
 };
-// expected-warning@+1 {{'__pascal' calling convention ignored for this target}}
+// expected-warning@+1 {{'__pascal' calling convention is not supported for this target}}
 template<typename T> int h2(T (__pascal M::* const )()) { return 0; }
 void m2() {
     int i; float f;
@@ -34,9 +34,9 @@ void m2() {
 
 // 3. test other calling conventions
 int _cdecl fa3();
-// expected-warning@+1 {{'_fastcall' calling convention ignored for this target}}
+// expected-warning@+1 {{'_fastcall' calling convention is not supported for this target}}
 int _fastcall fc3();
-// expected-warning@+1 {{'_stdcall' calling convention ignored for this target}}
+// expected-warning@+1 {{'_stdcall' calling convention is not supported for this target}}
 int _stdcall fd3();
 
 // 4. test __uuidof()

diff --git a/test/SemaCXX/cxx11-gnu-attrs.cpp b/test/SemaCXX/cxx11-gnu-attrs.cpp
index 1e8ad1e495bbfc8a20fd0abe13efbe3e41adb8f0..a91cb278b4d241cc478cb664dc9903d003739592 100644 (file)
--- a/test/SemaCXX/cxx11-gnu-attrs.cpp
+++ b/test/SemaCXX/cxx11-gnu-attrs.cpp
@@ -9,18 +9,18 @@ int [[gnu::unused]] attr_on_type;
 int *[[gnu::unused]] attr_on_ptr;
 // expected-warning@-1 {{attribute 'unused' ignored, because it cannot be applied to a type}}
 [[gnu::fastcall]] void pr17424_1();
-// expected-warning@-1 {{'fastcall' calling convention ignored for this target}}
+// expected-warning@-1 {{'fastcall' calling convention is not supported for this target}}
 [[gnu::fastcall]] [[gnu::stdcall]] void pr17424_2();
-// expected-warning@-1 {{'fastcall' calling convention ignored for this target}}
-// expected-warning@-2 {{'stdcall' calling convention ignored for this target}}
+// expected-warning@-1 {{'fastcall' calling convention is not supported for this target}}
+// expected-warning@-2 {{'stdcall' calling convention is not supported for this target}}
 [[gnu::fastcall]] __stdcall void pr17424_3();
-// expected-warning@-1 {{'fastcall' calling convention ignored for this target}}
-// expected-warning@-2 {{'__stdcall' calling convention ignored for this target}}
+// expected-warning@-1 {{'fastcall' calling convention is not supported for this target}}
+// expected-warning@-2 {{'__stdcall' calling convention is not supported for this target}}
 [[gnu::fastcall]] void pr17424_4() [[gnu::stdcall]];
-// expected-warning@-1 {{'fastcall' calling convention ignored for this target}}
-// expected-warning@-2 {{'stdcall' calling convention ignored for this target}}
+// expected-warning@-1 {{'fastcall' calling convention is not supported for this target}}
+// expected-warning@-2 {{'stdcall' calling convention is not supported for this target}}
 void pr17424_5 [[gnu::fastcall]]();
-// expected-warning@-1 {{'fastcall' calling convention ignored for this target}}
+// expected-warning@-1 {{'fastcall' calling convention is not supported for this target}}
 
 // Valid cases.
 

diff --git a/test/SemaCXX/decl-microsoft-call-conv.cpp b/test/SemaCXX/decl-microsoft-call-conv.cpp
index acd9b0720b6202bb89cba6b8231b892d3bae1dbe..a2a04ac9c8b99368c31b08577d0f8e0e094e8c84 100644 (file)
--- a/test/SemaCXX/decl-microsoft-call-conv.cpp
+++ b/test/SemaCXX/decl-microsoft-call-conv.cpp
@@ -77,7 +77,7 @@ struct S {
 
   // Structors can't be other than default in MS ABI environment
 #ifdef MSABI
-  __vectorcall S(); // expected-warning {{vectorcall calling convention ignored on constructor/destructor}}
+  __vectorcall S(); // expected-warning {{vectorcall calling convention is not supported on constructor/destructor}}
 #endif
 };
 

diff --git a/test/SemaCXX/virtual-override-x64.cpp b/test/SemaCXX/virtual-override-x64.cpp
index 5b9b2148f00a5a0349e537bd369e7192228d1ee6..f3eaf11569c8f7454b82e85ecf7518f0d8d241de 100644 (file)
--- a/test/SemaCXX/virtual-override-x64.cpp
+++ b/test/SemaCXX/virtual-override-x64.cpp
@@ -6,7 +6,7 @@
 namespace PR14339 {
   class A {
   public:
-    virtual void __attribute__((thiscall)) f();        // expected-warning {{'thiscall' calling convention ignored for this target}}
+    virtual void __attribute__((thiscall)) f();        // expected-warning {{'thiscall' calling convention is not supported for this target}}
   };
 
   class B : public A {
@@ -16,7 +16,7 @@ namespace PR14339 {
 
   class C : public A {
   public:
-    void __attribute__((thiscall)) f();  // expected-warning {{'thiscall' calling convention ignored for this target}}
+    void __attribute__((thiscall)) f();  // expected-warning {{'thiscall' calling convention is not supported for this target}}
   };
 
   class D : public A {
@@ -26,7 +26,7 @@ namespace PR14339 {
 
   class E {
   public:
-    virtual void __attribute__((stdcall)) g();  // expected-warning {{'stdcall' calling convention ignored for this target}}
+    virtual void __attribute__((stdcall)) g();  // expected-warning {{'stdcall' calling convention is not supported for this target}}
   };
 
   class F : public E {

diff --git a/test/SemaTemplate/instantiate-function-params.cpp b/test/SemaTemplate/instantiate-function-params.cpp
index 7984e258653deb46fe9a6d87aa02385e5b9959fb..505034d004d196a40a0d2a516cb08c9cf96d699c 100644 (file)
--- a/test/SemaTemplate/instantiate-function-params.cpp
+++ b/test/SemaTemplate/instantiate-function-params.cpp
@@ -88,7 +88,7 @@ namespace InstantiateFunctionTypedef {
     __attribute__((stdcall)) functype stdfunc1;
     stdfunctype stdfunc2;
 
-    __attribute__((pcs("aapcs"))) functype pcsfunc; // expected-warning {{'pcs' calling convention ignored for this target}}
+    __attribute__((pcs("aapcs"))) functype pcsfunc; // expected-warning {{'pcs' calling convention is not supported for this target}}
   };
 
   void f(X<int> x) {