From 505427cb2fe4b7d0290eabbf6785c2a3643ef637 Mon Sep 17 00:00:00 2001 From: Erich Keane Date: Thu, 21 Mar 2019 13:30:56 +0000 Subject: [PATCH] Permit redeclarations of a builtin to specify calling convention. After https://reviews.llvm.org/rL355317 we noticed that quite a decent amount of code redeclares builtins (memcpy in particular, I believe reduced from an MSVC header) with a calling convention specified. This gets particularly troublesome when the user specifies a new 'default' calling convention on the command line. When looking to add a diagnostic for this case, it was noticed that we had 3 other diagnostics that differed only slightly. This patch ALSO unifies those under a 'select'. Unfortunately, the order of words in ONE of these diagnostics was reversed ("'thiscall' calling convention" vs "calling convention 'thiscall'"), so this patch also standardizes on the former. Differential Revision: https://reviews.llvm.org/D59560 Change-Id: I79f99fe7c2301640755ffdd774b46eb44526bb22 llvm-svn: 356663 --- clang/include/clang/Basic/DiagnosticSemaKinds.td | 15 +++++++------ clang/include/clang/Sema/Sema.h | 9 ++++++++ clang/lib/Sema/SemaDecl.cpp | 9 ++++++++ clang/lib/Sema/SemaDeclAttr.cpp | 3 ++- clang/lib/Sema/SemaType.cpp | 22 +++++++++--------- clang/test/CodeGen/aarch64-vpcs.c | 4 ++-- clang/test/Sema/callingconv-iamcu.c | 26 +++++++++++----------- clang/test/Sema/callingconv.c | 8 ++++--- clang/test/Sema/pr25786.c | 4 ++-- clang/test/Sema/stdcall-fastcall-x64.c | 22 +++++++++--------- clang/test/SemaCUDA/cuda-inherits-calling-conv.cu | 2 +- clang/test/SemaCXX/borland-extensions.cpp | 16 ++++++------- clang/test/SemaCXX/cxx11-gnu-attrs.cpp | 16 ++++++------- clang/test/SemaCXX/virtual-override-x64.cpp | 6 ++--- .../SemaTemplate/instantiate-function-params.cpp | 2 +- 15 files changed, 92 insertions(+), 72 deletions(-) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index ebbbbc7..8b5ce42 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -2923,7 +2923,14 @@ def err_cconv_change : Error< "function declared '%0' here was previously declared " "%select{'%2'|without calling convention}1">; def warn_cconv_ignored : Warning< - "calling convention %0 ignored for this target">, InGroup; + "%0 calling convention ignored %select{" + // Use CallingConventionIgnoredReason Enum to specify these. + "for this target" + "|on variadic function" + "|on constructor/destructor" + "|on builtin function" + "}1">, + InGroup; def err_cconv_knr : Error< "function with no prototype cannot use the %0 calling convention">; def warn_cconv_knr : Warning< @@ -2931,12 +2938,6 @@ def warn_cconv_knr : Warning< InGroup>; def err_cconv_varargs : Error< "variadic function cannot use %0 calling convention">; -def warn_cconv_varargs : Warning< - "%0 calling convention ignored on variadic function">, - InGroup; -def warn_cconv_structors : Warning< - "%0 calling convention ignored on constructor/destructor">, - InGroup; def err_regparm_mismatch : Error<"function declared with regparm(%0) " "attribute was previously declared " "%plural{0:without the regparm|:with the regparm(%1)}1 attribute">; diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 65a6ecc..be084e2 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -11017,6 +11017,15 @@ public: Expr *E, llvm::function_ref Action); + + /// Describes the reason a calling convention specification was ignored, used + /// for diagnostics. + enum class CallingConventionIgnoredReason { + ForThisTarget = 0, + VariadicFunction, + ConstructorDestructor, + BuiltinFunction + }; }; /// RAII object that enters a new expression evaluation context. diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 2f8295a..4aa9dc2 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -3136,6 +3136,15 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, // there but not here. NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); RequiresAdjustment = true; + } else if (New->getBuiltinID()) { + // 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) + << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) + << (int)CallingConventionIgnoredReason::BuiltinFunction; + NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); + RequiresAdjustment = true; } else { // Calling conventions aren't compatible, so complain. bool FirstCCExplicit = getCallingConvAttributedType(First->getType()); diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index e8a77b3..dcccb4b 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -4652,7 +4652,8 @@ bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC, } if (A != TargetInfo::CCCR_OK) { if (A == TargetInfo::CCCR_Warning) - Diag(Attrs.getLoc(), diag::warn_cconv_ignored) << Attrs; + Diag(Attrs.getLoc(), diag::warn_cconv_ignored) + << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget; // This convention is not valid for the target. Use the default function or // method calling convention. diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 7c36abf..d4a6fc8 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -6930,19 +6930,16 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, if (!supportsVariadicCall(CC)) { const FunctionProtoType *FnP = dyn_cast(fn); if (FnP && FnP->isVariadic()) { - unsigned DiagID = diag::err_cconv_varargs; - // stdcall and fastcall are ignored with a warning for GCC and MS // compatibility. - bool IsInvalid = true; - if (CC == CC_X86StdCall || CC == CC_X86FastCall) { - DiagID = diag::warn_cconv_varargs; - IsInvalid = false; - } + if (CC == CC_X86StdCall || CC == CC_X86FastCall) + return S.Diag(attr.getLoc(), diag::warn_cconv_ignored) + << FunctionType::getNameForCallConv(CC) + << (int)Sema::CallingConventionIgnoredReason::VariadicFunction; - S.Diag(attr.getLoc(), DiagID) << FunctionType::getNameForCallConv(CC); - if (IsInvalid) attr.setInvalid(); - return true; + attr.setInvalid(); + return S.Diag(attr.getLoc(), diag::err_cconv_varargs) + << FunctionType::getNameForCallConv(CC); } } @@ -6997,8 +6994,9 @@ 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_structors) - << FunctionType::getNameForCallConv(CurCC); + Diag(Loc, diag::warn_cconv_ignored) + << FunctionType::getNameForCallConv(CurCC) + << (int)Sema::CallingConventionIgnoredReason::ConstructorDestructor; // Default adjustment. } else { // Only adjust types with the default convention. For example, on Windows diff --git a/clang/test/CodeGen/aarch64-vpcs.c b/clang/test/CodeGen/aarch64-vpcs.c index 0fc2e96..a9edb74 100644 --- a/clang/test/CodeGen/aarch64-vpcs.c +++ b/clang/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 {{calling convention 'aarch64_vector_pcs' ignored for this target}} +void __attribute__((aarch64_vector_pcs)) f(int *); // expected-warning {{'aarch64_vector_pcs' calling convention ignored 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 {{calling convention 'aarch64_vector_pcs' ignored for this target}} +void __attribute__((aarch64_vector_pcs)) h(int *a){ // expected-warning {{'aarch64_vector_pcs' calling convention ignored for this target}} // CHECKC: define aarch64_vector_pcs void @h( // CHECKCXX: define aarch64_vector_pcs void @_Z1hPi( f(a); diff --git a/clang/test/Sema/callingconv-iamcu.c b/clang/test/Sema/callingconv-iamcu.c index b66320e..2c99b02 100644 --- a/clang/test/Sema/callingconv-iamcu.c +++ b/clang/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 {{calling convention 'fastcall' ignored for this target}} +void __attribute__((fastcall)) foo(float *a) { // expected-warning {{'fastcall' calling convention ignored for this target}} } -void __attribute__((stdcall)) bar(float *a) { // expected-warning {{calling convention 'stdcall' ignored for this target}} +void __attribute__((stdcall)) bar(float *a) { // expected-warning {{'stdcall' calling convention ignored 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 {{calling convention 'fastcall' ignored for this target}} +void __attribute__((fastcall)) test2(int a, ...) { // expected-warning {{'fastcall' calling convention ignored for this target}} } -void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{calling convention 'stdcall' ignored for this target}} +void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{'stdcall' calling convention ignored for this target}} } -void __attribute__((thiscall)) test4(int a, ...) { // expected-warning {{calling convention 'thiscall' ignored for this target}} +void __attribute__((thiscall)) test4(int a, ...) { // expected-warning {{'thiscall' calling convention ignored 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 {{calling convention 'fastcall' ignored for this target}} +void (__attribute__((fastcall)) *pfoo)(float*) = foo; // expected-warning {{'fastcall' calling convention ignored for this target}} -void (__attribute__((stdcall)) *pbar)(float*) = bar; // expected-warning {{calling convention 'stdcall' ignored for this target}} +void (__attribute__((stdcall)) *pbar)(float*) = bar; // expected-warning {{'stdcall' calling convention ignored for this target}} void (*pctest0)() = ctest0; void ctest2() {} void (__attribute__((cdecl)) *pctest2)() = ctest2; -typedef void (__attribute__((fastcall)) *Handler) (float *); // expected-warning {{calling convention 'fastcall' ignored for this target}} +typedef void (__attribute__((fastcall)) *Handler) (float *); // expected-warning {{'fastcall' calling convention ignored 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 {{calling convention 'pcs' ignored for this target}} -int __attribute__((pcs("aapcs-vfp"))) pcs6(void); // expected-warning {{calling convention 'pcs' ignored for this target}} +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("foo"))) pcs7(void); // expected-error {{invalid PCS type}} void ctest3(); void __attribute__((cdecl)) ctest3() {} -typedef __attribute__((stdcall)) void (*PROC)(); // expected-warning {{calling convention 'stdcall' ignored for this target}} +typedef __attribute__((stdcall)) void (*PROC)(); // expected-warning {{'stdcall' calling convention ignored for this target}} PROC __attribute__((cdecl)) ctest4(const char *x) {} -void __attribute__((intel_ocl_bicc)) inteloclbifunc(float *a) {} // expected-warning {{calling convention 'intel_ocl_bicc' ignored for this target}} +void __attribute__((intel_ocl_bicc)) inteloclbifunc(float *a) {} // expected-warning {{'intel_ocl_bicc' calling convention ignored for this target}} -struct type_test {} __attribute__((stdcall)); // expected-warning {{calling convention 'stdcall' ignored for this target}} expected-warning {{'stdcall' attribute only applies to functions and methods}} +struct type_test {} __attribute__((stdcall)); // expected-warning {{'stdcall' calling convention ignored for this target}} expected-warning {{'stdcall' attribute only applies to functions and methods}} diff --git a/clang/test/Sema/callingconv.c b/clang/test/Sema/callingconv.c index 8b64bee..e6d6ad2 100644 --- a/clang/test/Sema/callingconv.c +++ b/clang/test/Sema/callingconv.c @@ -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 {{calling convention 'pcs' ignored for this target}} -int __attribute__((pcs("aapcs-vfp"))) pcs6(void); // expected-warning {{calling convention 'pcs' ignored for this target}} +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("foo"))) pcs7(void); // expected-error {{invalid PCS type}} -int __attribute__((aarch64_vector_pcs)) aavpcs(void); // expected-warning {{calling convention 'aarch64_vector_pcs' ignored for this target}} +int __attribute__((aarch64_vector_pcs)) aavpcs(void); // expected-warning {{'aarch64_vector_pcs' calling convention ignored for this target}} // PR6361 void ctest3(); @@ -68,3 +68,5 @@ typedef_fun_t typedef_fun; // expected-note {{previous declaration is here}} void __attribute__((stdcall)) typedef_fun(int x) { } // expected-error {{function declared 'stdcall' here was previously declared without calling convention}} 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}} diff --git a/clang/test/Sema/pr25786.c b/clang/test/Sema/pr25786.c index 2ce6531..bfc2b35 100644 --- a/clang/test/Sema/pr25786.c +++ b/clang/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 {{calling convention 'stdcall' ignored for this target}} -void (__attribute__((regparm(2), stdcall)) foo)(int a) { //expected-warning {{calling convention 'stdcall' ignored for this target}} +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}} } #else //expected-no-diagnostics diff --git a/clang/test/Sema/stdcall-fastcall-x64.c b/clang/test/Sema/stdcall-fastcall-x64.c index d2a475e..e2e39e4 100644 --- a/clang/test/Sema/stdcall-fastcall-x64.c +++ b/clang/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{{calling convention 'stdcall' ignored for this target}} expected-warning {{calling convention 'fastcall' ignored for this target}} -void __attribute__((stdcall)) foo4(); // expected-warning{{calling convention 'stdcall' ignored for this target}} -void __attribute__((fastcall)) foo4(void); // expected-warning {{calling convention 'fastcall' ignored for this target}} +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}} // rdar://8876096 -void rdar8876096foo1(int i, int j) __attribute__((fastcall, cdecl)); // expected-warning{{calling convention 'fastcall' ignored for this target}} -void rdar8876096foo2(int i, int j) __attribute__((fastcall, stdcall)); // expected-warning{{calling convention 'stdcall' ignored for this target}} expected-warning {{calling convention 'fastcall' ignored for this target}} -void rdar8876096foo3(int i, int j) __attribute__((fastcall, regparm(2))); // expected-warning {{calling convention 'fastcall' ignored for this target}} -void rdar8876096foo4(int i, int j) __attribute__((stdcall, cdecl)); // expected-warning{{calling convention 'stdcall' ignored for this target}} -void rdar8876096foo5(int i, int j) __attribute__((stdcall, fastcall)); // expected-warning{{calling convention 'stdcall' ignored for this target}} expected-warning {{calling convention 'fastcall' ignored for this target}} -void rdar8876096foo6(int i, int j) __attribute__((cdecl, fastcall)); // expected-warning {{calling convention 'fastcall' ignored for this target}} -void rdar8876096foo7(int i, int j) __attribute__((cdecl, stdcall)); // expected-warning{{calling convention 'stdcall' ignored for this target}} -void rdar8876096foo8(int i, int j) __attribute__((regparm(2), fastcall)); // expected-warning {{calling convention 'fastcall' ignored for this target}} +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}} diff --git a/clang/test/SemaCUDA/cuda-inherits-calling-conv.cu b/clang/test/SemaCUDA/cuda-inherits-calling-conv.cu index 67c438f..881f294 100644 --- a/clang/test/SemaCUDA/cuda-inherits-calling-conv.cu +++ b/clang/test/SemaCUDA/cuda-inherits-calling-conv.cu @@ -24,7 +24,7 @@ struct Foo {}; // expected-no-diagnostics #else // expected-error@+4 {{redefinition of 'Foo}} -// expected-warning@+3 {{calling convention '__fastcall' ignored}} +// expected-warning@+3 {{'__fastcall' calling convention ignored}} #endif template struct Foo {}; diff --git a/clang/test/SemaCXX/borland-extensions.cpp b/clang/test/SemaCXX/borland-extensions.cpp index d214473..31ebf037 100644 --- a/clang/test/SemaCXX/borland-extensions.cpp +++ b/clang/test/SemaCXX/borland-extensions.cpp @@ -7,21 +7,21 @@ int dummy_function() { return 0; } // 2. test __pascal -// expected-warning@+1 {{calling convention '_pascal' ignored for this target}} +// expected-warning@+1 {{'_pascal' calling convention ignored for this target}} int _pascal f2(); -// expected-warning@+1 {{calling convention '__pascal' ignored for this target}} +// expected-warning@+1 {{'__pascal' calling convention ignored for this target}} float __pascal gi2(int, int); -// expected-warning@+1 {{calling convention '__pascal' ignored for this target}} +// expected-warning@+1 {{'__pascal' calling convention ignored for this target}} template T g2(T (__pascal * const )(int, int)) { return 0; } struct M { - // expected-warning@+1 {{calling convention '__pascal' ignored for this target}} + // expected-warning@+1 {{'__pascal' calling convention ignored for this target}} int __pascal addP(); - // expected-warning@+1 {{calling convention '__pascal' ignored for this target}} + // expected-warning@+1 {{'__pascal' calling convention ignored for this target}} float __pascal subtractP(); }; -// expected-warning@+1 {{calling convention '__pascal' ignored for this target}} +// expected-warning@+1 {{'__pascal' calling convention ignored for this target}} template 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 {{calling convention '_fastcall' ignored for this target}} +// expected-warning@+1 {{'_fastcall' calling convention ignored for this target}} int _fastcall fc3(); -// expected-warning@+1 {{calling convention '_stdcall' ignored for this target}} +// expected-warning@+1 {{'_stdcall' calling convention ignored for this target}} int _stdcall fd3(); // 4. test __uuidof() diff --git a/clang/test/SemaCXX/cxx11-gnu-attrs.cpp b/clang/test/SemaCXX/cxx11-gnu-attrs.cpp index b020d2a..1e8ad1e 100644 --- a/clang/test/SemaCXX/cxx11-gnu-attrs.cpp +++ b/clang/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 {{calling convention 'fastcall' ignored for this target}} +// expected-warning@-1 {{'fastcall' calling convention ignored for this target}} [[gnu::fastcall]] [[gnu::stdcall]] void pr17424_2(); -// expected-warning@-1 {{calling convention 'fastcall' ignored for this target}} -// expected-warning@-2 {{calling convention 'stdcall' ignored for this target}} +// expected-warning@-1 {{'fastcall' calling convention ignored for this target}} +// expected-warning@-2 {{'stdcall' calling convention ignored for this target}} [[gnu::fastcall]] __stdcall void pr17424_3(); -// expected-warning@-1 {{calling convention 'fastcall' ignored for this target}} -// expected-warning@-2 {{calling convention '__stdcall' ignored for this target}} +// expected-warning@-1 {{'fastcall' calling convention ignored for this target}} +// expected-warning@-2 {{'__stdcall' calling convention ignored for this target}} [[gnu::fastcall]] void pr17424_4() [[gnu::stdcall]]; -// expected-warning@-1 {{calling convention 'fastcall' ignored for this target}} -// expected-warning@-2 {{calling convention 'stdcall' ignored for this target}} +// expected-warning@-1 {{'fastcall' calling convention ignored for this target}} +// expected-warning@-2 {{'stdcall' calling convention ignored for this target}} void pr17424_5 [[gnu::fastcall]](); -// expected-warning@-1 {{calling convention 'fastcall' ignored for this target}} +// expected-warning@-1 {{'fastcall' calling convention ignored for this target}} // Valid cases. diff --git a/clang/test/SemaCXX/virtual-override-x64.cpp b/clang/test/SemaCXX/virtual-override-x64.cpp index 8d5aad8..5b9b214 100644 --- a/clang/test/SemaCXX/virtual-override-x64.cpp +++ b/clang/test/SemaCXX/virtual-override-x64.cpp @@ -6,7 +6,7 @@ namespace PR14339 { class A { public: - virtual void __attribute__((thiscall)) f(); // expected-warning {{calling convention 'thiscall' ignored for this target}} + virtual void __attribute__((thiscall)) f(); // expected-warning {{'thiscall' calling convention ignored for this target}} }; class B : public A { @@ -16,7 +16,7 @@ namespace PR14339 { class C : public A { public: - void __attribute__((thiscall)) f(); // expected-warning {{calling convention 'thiscall' ignored for this target}} + void __attribute__((thiscall)) f(); // expected-warning {{'thiscall' calling convention ignored for this target}} }; class D : public A { @@ -26,7 +26,7 @@ namespace PR14339 { class E { public: - virtual void __attribute__((stdcall)) g(); // expected-warning {{calling convention 'stdcall' ignored for this target}} + virtual void __attribute__((stdcall)) g(); // expected-warning {{'stdcall' calling convention ignored for this target}} }; class F : public E { diff --git a/clang/test/SemaTemplate/instantiate-function-params.cpp b/clang/test/SemaTemplate/instantiate-function-params.cpp index 556a818..7984e25 100644 --- a/clang/test/SemaTemplate/instantiate-function-params.cpp +++ b/clang/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 {{calling convention 'pcs' ignored for this target}} + __attribute__((pcs("aapcs"))) functype pcsfunc; // expected-warning {{'pcs' calling convention ignored for this target}} }; void f(X x) { -- 2.7.4