Downgrade error about stdcall decls with no prototype to a warning

[rnk]

Summary

The MIDL compiler produces code that does this.

If we wanted to improve the warning, I think we could do this:

void __stdcall f(); // Don't warn without -Wstrict-prototypes.
void g() {
  f(); // Might warn, the user probably meant for f to take no args.
  f(1, 2, 3); // Warn, we have no idea what args f takes.
  f(1); // Error, this is insane, one of these calls is broken.
}

[thakis]

lgtm, thanks! Mention PR21027 somewhere.

[rnk]

Closed by commit rL218394 (authored by @rnk).

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

 def err_attribute_vecreturn_only_pod_record : Error<
   "the vecreturn attribute can only be used on a POD (plain old data) class or structure (i.e. no virtual functions)">;
 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<IgnoredAttributes>;
 def err_cconv_knr : Error<
-  "function with no prototype cannot use %0 calling convention">;
+  "function with no prototype cannot use the callee-cleanup %0 calling convention">;
 def warn_cconv_knr : Warning<
-  "function with no prototype cannot use %0 calling convention">,
-  DefaultError, InGroup<DiagGroup<"missing-prototype-for-cc">>;
+  "function with no prototype cannot use the callee-cleanup %0 calling convention">,
+  InGroup<DiagGroup<"missing-prototype-for-cc">>;
 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<IgnoredAttributes>;
 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">;

cfe/trunk/test/CodeGen/mrtd.c

 // RUN: %clang_cc1 -mrtd -triple i386-unknown-unknown -std=c89 -Wsystem-headers  -Wno-error=missing-prototype-for-cc -emit-llvm -o - %s 2>&1 | FileCheck %s
 
 // prototype-less __stdcall functions are only allowed in system headers.
 # 1 "fake_system_header.h" 1 3 4
 
-// CHECK: fake_system_header.h:9:3: warning: function with no prototype cannot use stdcall calling convention
+// CHECK: fake_system_header.h:9:3: warning: function with no prototype cannot use the callee-cleanup stdcall calling convention
 
 void baz(int arg);
 
 // CHECK: define x86_stdcallcc void @foo(i32 %arg) [[NUW:#[0-9]+]]
 void foo(int arg) {
 // CHECK: call x86_stdcallcc i32 bitcast (i32 (...)* @bar to i32 (i32)*)(
   bar(arg);
 // CHECK: call x86_stdcallcc void @baz(i32

cfe/trunk/test/Sema/callingconv.c

 // RUN: %clang_cc1 %s -fsyntax-only -triple i386-unknown-unknown -verify
 // RUN: %clang_cc1 %s -fsyntax-only -triple i386-unknown-unknown -fms-compatibility -DWIN -verify
 
 void __attribute__((fastcall)) foo(float *a) {
 }
 
 void __attribute__((stdcall)) bar(float *a) {
 }
 
 void __attribute__((fastcall(1))) baz(float *a) { // expected-error {{'fastcall' attribute takes no arguments}}
 }
 
-void __attribute__((fastcall)) test0() { // expected-error {{function with no prototype cannot use fastcall calling convention}}
+void __attribute__((fastcall)) test0() { // expected-error {{function with no prototype cannot use the callee-cleanup fastcall calling convention}}
 }
 
 void __attribute__((fastcall)) test1(void) {
 }
 
 void __attribute__((fastcall)) test2(int a, ...) { // expected-warning {{fastcall calling convention ignored on variadic function}}
 }
 void __attribute__((stdcall)) test3(int a, ...) { // expected-warning {{stdcall calling convention ignored on variadic function}}

cfe/trunk/test/Sema/decl-microsoft-call-conv.c

 // RUN: %clang_cc1 -triple i686-pc-win32 -verify %s
 
 // It's important that this is a .c file.
 
 // This is fine, as CrcGenerateTable*() has a prototype.
 void __fastcall CrcGenerateTableFastcall(void);
 void __fastcall CrcGenerateTableFastcall() {}
 void __stdcall CrcGenerateTableStdcall(void);
 void __stdcall CrcGenerateTableStdcall() {}
 void __thiscall CrcGenerateTableThiscall(void);
 void __thiscall CrcGenerateTableThiscall() {}
 void __pascal CrcGenerateTablePascal(void);
 void __pascal CrcGenerateTablePascal() {}
 
-void __fastcall CrcGenerateTableNoProtoFastcall() {} // expected-error{{function with no prototype cannot use fastcall calling convention}}
-void __stdcall CrcGenerateTableNoProtoStdcall() {} // expected-error{{function with no prototype cannot use stdcall calling convention}}
-void __thiscall CrcGenerateTableNoProtoThiscall() {} // expected-error{{function with no prototype cannot use thiscall calling convention}}
-void __pascal CrcGenerateTableNoProtoPascal() {} // expected-error{{function with no prototype cannot use pascal calling convention}}
+void __fastcall CrcGenerateTableNoProtoFastcall() {} // expected-error{{function with no prototype cannot use the callee-cleanup fastcall calling convention}}
+void __stdcall CrcGenerateTableNoProtoStdcall() {} // expected-warning{{function with no prototype cannot use the callee-cleanup stdcall calling convention}}
+void __thiscall CrcGenerateTableNoProtoThiscall() {} // expected-error{{function with no prototype cannot use the callee-cleanup thiscall calling convention}}
+void __pascal CrcGenerateTableNoProtoPascal() {} // expected-error{{function with no prototype cannot use the callee-cleanup pascal calling convention}}
 
 // Regular calling convention is fine.
 void CrcGenerateTableNoProto() {}
 
 
 // In system headers, the stdcall version should be a warning.
 # 1 "fake_system_header.h" 1 3 4
-void __fastcall SystemHeaderFastcall() {} // expected-error{{function with no prototype cannot use fastcall calling convention}}
+void __fastcall SystemHeaderFastcall() {} // expected-error{{function with no prototype cannot use the callee-cleanup fastcall calling convention}}
 void __stdcall SystemHeaderStdcall() {}
-void __thiscall SystemHeaderThiscall() {} // expected-error{{function with no prototype cannot use thiscall calling convention}}
-void __pascal SystemHeaderPascal() {} // expected-error{{function with no prototype cannot use pascal calling convention}}
+void __thiscall SystemHeaderThiscall() {} // expected-error{{function with no prototype cannot use the callee-cleanup thiscall calling convention}}
+void __pascal SystemHeaderPascal() {} // expected-error{{function with no prototype cannot use the callee-cleanup pascal calling convention}}

cfe/trunk/test/Sema/stdcall-fastcall.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple i686-apple-darwin10 %s
 
 // CC qualifier can be applied only to functions
 int __attribute__((stdcall)) var1; // expected-warning{{'stdcall' only applies to function types; type here is 'int'}}
 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-error{{fastcall and stdcall attributes are not compatible}}
-void __attribute__((stdcall)) foo4(); // expected-note{{previous declaration is here}} expected-error{{function with no prototype cannot use stdcall calling convention}}
+void __attribute__((stdcall)) foo4(); // expected-note{{previous declaration is here}} expected-warning{{function with no prototype cannot use the callee-cleanup stdcall calling convention}}
 void __attribute__((fastcall)) foo4(void); // expected-error{{function declared 'fastcall' here was previously declared 'stdcall'}}
 
 // rdar://8876096
 void rdar8876096foo1(int i, int j) __attribute__((fastcall, cdecl)); // expected-error {{not compatible}}
 void rdar8876096foo2(int i, int j) __attribute__((fastcall, stdcall)); // expected-error {{not compatible}}
 void rdar8876096foo3(int i, int j) __attribute__((fastcall, regparm(2))); // expected-error {{not compatible}}
 void rdar8876096foo4(int i, int j) __attribute__((stdcall, cdecl)); // expected-error {{not compatible}}
 void rdar8876096foo5(int i, int j) __attribute__((stdcall, fastcall)); // expected-error {{not compatible}}
 void rdar8876096foo6(int i, int j) __attribute__((cdecl, fastcall)); // expected-error {{not compatible}}
 void rdar8876096foo7(int i, int j) __attribute__((cdecl, stdcall)); // expected-error {{not compatible}}
 void rdar8876096foo8(int i, int j) __attribute__((regparm(2), fastcall)); // expected-error {{not compatible}}