Use functions with prototypes when appropriate; NFC

A significant number of our tests in C accidentally use functions
without prototypes. This patch converts the function signatures to have
a prototype for the situations where the test is not specific to K&R C
declarations. e.g.,

  void func();

becomes

  void func(void);

This is the first batch of tests being updated (there are a significant
number of other tests left to be updated).

Author: AaronBallman

clang/test/Sema/2010-05-31-palignr.c

@@ -5,7 +5,7 @@
 
 extern int i;
 
-int main ()
+int main (void)
 {
   typedef int16_t     vSInt16         __attribute__ ((__vector_size__ (16)));
 

clang/test/Sema/Float16.c

@@ -11,7 +11,7 @@ _Float16 f;
 
 #ifdef HAVE
 _Complex _Float16 a;
-void builtin_complex() {
+void builtin_complex(void) {
   _Float16 a = 0;
   (void)__builtin_complex(a, a); // expected-error {{'_Complex _Float16' is invalid}}
 }

clang/test/Sema/MicrosoftExtensions.c

@@ -68,7 +68,7 @@ struct test {
   NESTED6;   // expected-warning {{anonymous unions are a Microsoft extension}}
 };
 
-void foo()
+void foo(void)
 {
   struct test var;
   var.a;
@@ -148,14 +148,14 @@ void ptr_func2(int * __sptr __ptr32 i) {}  // expected-note {{previous definitio
 void ptr_func2(int * __uptr __ptr32 i) {} // expected-error {{redefinition of 'ptr_func2'}}
 
 // Check for warning when return types have the type attribute.
-void *__ptr32 ptr_func3() { return 0; } // expected-note {{previous definition is here}}
-void *__ptr64 ptr_func3() { return 0; } // expected-error {{redefinition of 'ptr_func3'}}
+void *__ptr32 ptr_func3(void) { return 0; } // expected-note {{previous definition is here}}
+void *__ptr64 ptr_func3(void) { return 0; } // expected-error {{redefinition of 'ptr_func3'}}
 
 // Test that __ptr32/__ptr64 can be passed as arguments with other address
 // spaces.
 void ptr_func4(int *i);
 void ptr_func5(int *__ptr32 i);
-void test_ptr_arguments() {
+void test_ptr_arguments(void) {
   int *__ptr64 i64;
   ptr_func4(i64);
   ptr_func5(i64);
@@ -191,7 +191,7 @@ void myprintf(const char *f, ...) {
 }
 
 // __unaligned handling
-void test_unaligned() {
+void test_unaligned(void) {
   __unaligned int *p1 = 0;
   int *p2 = p1; // expected-warning {{initializing 'int *' with an expression of type '__unaligned int *' discards qualifiers}}
   __unaligned int *p3 = p2;

clang/test/Sema/PR28181.c

@@ -4,10 +4,10 @@ struct spinlock_t {
   int lock;
 } audit_skb_queue;
 
-void fn1() {
+void fn1(void) {
   audit_skb_queue = (lock); // expected-error {{use of undeclared identifier 'lock'; did you mean 'long'?}}
 }                           // expected-error@-1 {{assigning to 'struct spinlock_t' from incompatible type '<overloaded function type>'}}
 
-void fn2() {
+void fn2(void) {
   audit_skb_queue + (lock); // expected-error {{use of undeclared identifier 'lock'; did you mean 'long'?}}
 }                           // expected-error@-1 {{reference to overloaded function could not be resolved; did you mean to call it?}}

clang/test/Sema/__try.c

@@ -11,11 +11,11 @@ typedef int DWORD;
 
 struct EXCEPTION_INFO{};
 
-unsigned long __exception_code();
+unsigned long __exception_code(void);
 #ifdef BORLAND
-struct EXCEPTION_INFO* __exception_info();
+struct EXCEPTION_INFO* __exception_info(void);
 #endif
-int __abnormal_termination();
+int __abnormal_termination(void);
 
 #define GetExceptionCode __exception_code
 #define GetExceptionInformation __exception_info
@@ -26,9 +26,9 @@ int __abnormal_termination();
 DWORD FilterExpression(int); // expected-note{{declared here}}
 DWORD FilterExceptionInformation(struct EXCEPTION_INFO*);
 
-const char * NotFilterExpression();
+const char * NotFilterExpression(void);
 
-void TEST() {
+void TEST(void) {
   __try {
     __try {
       __try {
@@ -43,32 +43,32 @@ void TEST() {
   }
 }
 
-void TEST() {
+void TEST(void) {
   __try {
 
   }
 }  // expected-error{{expected '__except' or '__finally' block}}
 
-void TEST() {
+void TEST(void) {
   __except (FilterExpression()) { // expected-warning{{implicit declaration of function '__except' is invalid in C99}} \
     // expected-error{{too few arguments to function call, expected 1, have 0}} \
     // expected-error{{expected ';' after expression}}
   }
 }
 
-void TEST() {
+void TEST(void) {
   __finally { } // expected-error{{}}
 }
 
-void TEST() {
+void TEST(void) {
   __try{
     int try_scope = 0;
   } // TODO: expected expression is an extra error
   __except( try_scope ? 1 : -1 ) // expected-error{{undeclared identifier 'try_scope'}} expected-error{{expected expression}}
   {}
 }
 
-void TEST() {
+void TEST(void) {
   __try {
 
   }
@@ -77,7 +77,7 @@ void TEST() {
   }
 }
 
-void TEST() {
+void TEST(void) {
   __try {
 
   }
@@ -107,7 +107,7 @@ void TEST() {
   }
 }
 
-void TEST() {
+void TEST(void) {
   __try {
 
   }
@@ -116,7 +116,7 @@ void TEST() {
   }
 }
 
-void TEST() {
+void TEST(void) {
   int function_scope = 0;
   __try {
     int try_scope = 0;
@@ -127,7 +127,7 @@ void TEST() {
   }
 }
 
-void TEST() {
+void TEST(void) {
   int function_scope = 0;
   __try {
     int try_scope = 0;
@@ -138,7 +138,7 @@ void TEST() {
   }
 }
 
-void TEST() {
+void TEST(void) {
   int function_scope = 0;
   __try {
 
@@ -147,7 +147,7 @@ void TEST() {
 }
 
 #ifdef BORLAND
-void TEST() {
+void TEST(void) {
   (void)__abnormal_termination(); // expected-error{{only allowed in __finally block}}
   (void)AbnormalTermination();  // expected-error{{only allowed in __finally block}}
 
@@ -169,28 +169,28 @@ void TEST() {
 }
 #endif
 
-void TEST() {
+void TEST(void) {
   (void)__exception_info();       // expected-error{{only allowed in __except filter expression}}
   (void)GetExceptionInformation(); // expected-error{{only allowed in __except filter expression}}
 }
 
-void TEST() {
+void TEST(void) {
 #ifndef BORLAND
   (void)__exception_code;     // expected-error{{builtin functions must be directly called}}
 #endif
   (void)__exception_code();     // expected-error{{only allowed in __except block or filter expression}}
   (void)GetExceptionCode();     // expected-error{{only allowed in __except block or filter expression}}
 }
 
-void TEST() {
+void TEST(void) {
   __try {
   } __except(1) {
     GetExceptionCode(); // valid
     GetExceptionInformation(); // expected-error{{only allowed in __except filter expression}}
   }
 }
 
-void test_seh_leave_stmt() {
+void test_seh_leave_stmt(void) {
   __leave; // expected-error{{'__leave' statement not in __try block}}
 
   __try {
@@ -208,7 +208,7 @@ void test_seh_leave_stmt() {
   __leave; // expected-error{{'__leave' statement not in __try block}}
 }
 
-void test_jump_out_of___finally() {
+void test_jump_out_of___finally(void) {
   while(1) {
     __try {
     } __finally {
@@ -282,7 +282,7 @@ void test_jump_out_of___finally() {
   }
 }
 
-void test_typo_in_except() {
+void test_typo_in_except(void) {
   __try {
   } __except(undeclared_identifier) { // expected-error {{use of undeclared identifier 'undeclared_identifier'}} expected-error {{expected expression}}
   }

clang/test/Sema/aarch64-branch-protection-attr-err.c

@@ -2,28 +2,28 @@
 
 __attribute__((target("branch-protection=foo"))) // expected-error {{invalid or misplaced branch protection specification 'foo'}}
 void
-badvalue0() {}
+badvalue0(void) {}
 
 __attribute__((target("branch-protection=+bti"))) // expected-error {{invalid or misplaced branch protection specification '<empty>'}}
 void
-badvalue1() {}
+badvalue1(void) {}
 
 __attribute__((target("branch-protection=bti+"))) // expected-error {{invalid or misplaced branch protection specification '<empty>'}}
 void
-badvalue2() {}
+badvalue2(void) {}
 
 __attribute__((target("branch-protection=pac-ret+bkey"))) // expected-error {{invalid or misplaced branch protection specification 'bkey'}}
 void
-badvalue3() {}
+badvalue3(void) {}
 
 __attribute__((target("branch-protection=bti+leaf"))) // expected-error {{invalid or misplaced branch protection specification 'leaf'}}
 void
-badoption0() {}
+badoption0(void) {}
 
 __attribute__((target("branch-protection=bti+leaf+pac-ret"))) // expected-error {{invalid or misplaced branch protection specification 'leaf'}}
 void
-badorder0() {}
+badorder0(void) {}
 
 __attribute__((target("branch-protection=pac-ret+bti+leaf"))) // expected-error {{invalid or misplaced branch protection specification 'leaf'}}
 void
-badorder1() {}
+badorder1(void) {}

clang/test/Sema/aarch64-special-register.c

@@ -16,15 +16,15 @@ void wsr64_1(unsigned long v) {
   __builtin_arm_wsr64("sysreg", v);
 }
 
-unsigned rsr_1() {
+unsigned rsr_1(void) {
   return __builtin_arm_rsr("sysreg");
 }
 
-void *rsrp_1() {
+void *rsrp_1(void) {
   return __builtin_arm_rsrp("sysreg");
 }
 
-unsigned long rsr64_1() {
+unsigned long rsr64_1(void) {
   return __builtin_arm_rsr64("sysreg");
 }
 
@@ -40,15 +40,15 @@ void wsr64_2(unsigned long v) {
   __builtin_arm_wsr64("0:1:2:3:4", v);
 }
 
-unsigned rsr_2() {
+unsigned rsr_2(void) {
   return __builtin_arm_rsr("0:1:15:15:4");
 }
 
-void *rsrp_2() {
+void *rsrp_2(void) {
   return __builtin_arm_rsrp("0:1:2:3:4");
 }
 
-unsigned long rsr64_2() {
+unsigned long rsr64_2(void) {
   return __builtin_arm_rsr64("0:1:15:15:4");
 }
 
@@ -64,38 +64,38 @@ void wsr64_3(unsigned long v) {
   __builtin_arm_wsr64("0:1:2", v); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned rsr_3() {
+unsigned rsr_3(void) {
   return __builtin_arm_rsr("0:1:2"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned rsr_4() {
+unsigned rsr_4(void) {
   return __builtin_arm_rsr("0:1:2:3:8"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned rsr_5() {
+unsigned rsr_5(void) {
   return __builtin_arm_rsr("0:8:1:2:3"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned rsr_6() {
+unsigned rsr_6(void) {
   return __builtin_arm_rsr("0:1:16:16:2"); //expected-error {{invalid special register for builtin}}
 }
 
-void *rsrp_3() {
+void *rsrp_3(void) {
   return __builtin_arm_rsrp("0:1:2"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned long rsr64_3() {
+unsigned long rsr64_3(void) {
   return __builtin_arm_rsr64("0:1:2"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned long rsr64_4() {
+unsigned long rsr64_4(void) {
   return __builtin_arm_rsr64("0:1:2:3:8"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned long rsr64_5() {
+unsigned long rsr64_5(void) {
   return __builtin_arm_rsr64("0:8:2:3:4"); //expected-error {{invalid special register for builtin}}
 }
 
-unsigned long rsr64_6() {
+unsigned long rsr64_6(void) {
   return __builtin_arm_rsr64("0:1:16:16:2"); //expected-error {{invalid special register for builtin}}
 }

clang/test/Sema/aarch64-sve-types.c

@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 %s -triple aarch64-none-linux-gnu -target-feature +sve,+bf16 -fsyntax-only -verify
 
-void f() {
+void f(void) {
   int size_s8[sizeof(__SVInt8_t) == 0 ? 1 : -1];        // expected-error {{invalid application of 'sizeof' to sizeless type '__SVInt8_t'}}
   int align_s8[__alignof__(__SVInt8_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVInt8_t'}}
 

clang/test/Sema/aarch64-tme-errors.c

@@ -2,7 +2,7 @@
 
 #include "arm_acle.h"
 
-void test_no_tme_funcs() {
+void test_no_tme_funcs(void) {
   __tstart();         // expected-warning{{implicit declaration of function '__tstart'}}
   __builtin_tstart(); // expected-error{{use of unknown builtin '__builtin_tstart'}}
 }

clang/test/Sema/aarch64-tme-tcancel-errors.c

@@ -4,6 +4,6 @@ void t_cancel_const(unsigned short u) {
 }
 
 // RUN: %clang_cc1 -triple aarch64-eabi -target-feature +tme -verify %s
-void t_cancel_range() {
+void t_cancel_range(void) {
   __builtin_arm_tcancel(0x12345u); // expected-error{{argument value 74565 is outside the valid range [0, 65535]}}
 }