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 ninth batch of tests being updated (there are a
significant number of other tests left to be updated).

Author: AaronBallman

clang/test/Analysis/Inputs/expected-plists/unix-fns.c.plist

@@ -561,7 +561,7 @@
    <key>type</key><string>Improper use of &apos;dispatch_once&apos;</string>
    <key>check_name</key><string>osx.API</string>
    <!-- This hash is experimental and going to change! -->
-   <key>issue_hash_content_of_line_in_context</key><string>173fbcac3fc64dbaec32768d4cfda250</string>
+   <key>issue_hash_content_of_line_in_context</key><string>3c7c4524233ba46b615e7c4c2ce7c20d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_dispatch_once</string>
   <key>issue_hash_function_offset</key><string>2</string>
@@ -1473,7 +1473,7 @@
    <key>type</key><string>Improper use of &apos;dispatch_once&apos;</string>
    <key>check_name</key><string>osx.API</string>
    <!-- This hash is experimental and going to change! -->
-   <key>issue_hash_content_of_line_in_context</key><string>8ded1f2025c1e4a4bcd5302dc97006d9</string>
+   <key>issue_hash_content_of_line_in_context</key><string>6fec229f3dde6d311481c6a64eeffefa</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_dispatch_once_in_macro</string>
   <key>issue_hash_function_offset</key><string>2</string>

clang/test/Analysis/exploded-graph-rewriter/escapes.c

@@ -5,7 +5,7 @@
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
 // REQUIRES: asserts
 
-void escapes() {
+void escapes(void) {
   // CHECK: <td align="left"><b>Store: </b> <font color="gray">(0x{{[0-9a-f]*}})</font></td>
   // CHECK-SAME: <td align="left">foo</td><td align="left">0</td>
   // CHECK-SAME: <td align="left">&amp;Element\{"foo",0 S64b,char\}</td>

clang/test/Analysis/exploded-graph-rewriter/macros.c

@@ -1,5 +1,5 @@
 #define NULL 0
-void *foo() {
+void *foo(void) {
   return NULL;
 }
 

clang/test/Analysis/expr-inspection-printState-diseq-info.c

@@ -1,7 +1,7 @@
 // RUN: %clang_analyze_cc1 \
 // RUN:  -analyzer-checker=debug.ExprInspection %s 2>&1 | FileCheck %s
 
-void clang_analyzer_printState();
+void clang_analyzer_printState(void);
 
 void test_disequality_info(int e0, int b0, int b1, int c0) {
   int e1 = e0 - b0;

clang/test/Analysis/expr-inspection-printState-eq-classes.c

@@ -1,7 +1,7 @@
 // RUN: %clang_analyze_cc1 \
 // RUN:  -analyzer-checker=debug.ExprInspection %s 2>&1 | FileCheck %s
 
-void clang_analyzer_printState();
+void clang_analyzer_printState(void);
 
 void test_equivalence_classes(int a, int b, int c, int d) {
   if (a + b != c)

clang/test/Analysis/expr-inspection.c

@@ -6,8 +6,8 @@
 
 void clang_analyzer_dump(int x);
 void clang_analyzer_dump_pointer(int *p);
-void clang_analyzer_printState();
-void clang_analyzer_numTimesReached();
+void clang_analyzer_printState(void);
+void clang_analyzer_numTimesReached(void);
 
 void foo(int x) {
   clang_analyzer_dump(x); // expected-warning{{reg_$0<int x>}}

clang/test/Analysis/fields.c

@@ -2,9 +2,9 @@
 
 void clang_analyzer_eval(int);
 
-unsigned foo();
+unsigned foo(void);
 typedef struct bf { unsigned x:2; } bf;
-void bar() {
+void bar(void) {
   bf y;
   *(unsigned*)&y = foo();
   y.x = 1;
@@ -14,7 +14,7 @@ struct s {
   int n;
 };
 
-void f() {
+void f(void) {
   struct s a;
   int *p = &(a.n) + 1; // expected-warning{{Pointer arithmetic on}}
 }
@@ -24,7 +24,7 @@ typedef struct {
 } Point;
 
 Point getit(void);
-void test() {
+void test(void) {
   Point p;
   (void)(p = getit()).x;
 }
@@ -34,7 +34,7 @@ void test() {
 typedef _Bool bool;
 
 
-void testLazyCompoundVal() {
+void testLazyCompoundVal(void) {
   Point p = {42, 0};
   Point q;
   clang_analyzer_eval((q = p).x == 42); // expected-warning{{TRUE}}
@@ -58,7 +58,7 @@ struct Bits {
   } inner;
 };
 
-void testBitfields() {
+void testBitfields(void) {
   struct Bits bits;
 
   if (foo() && bits.b) // expected-warning {{garbage}}
@@ -89,7 +89,7 @@ void testBitfields() {
   if (foo() && bits.inner.f) // expected-warning {{garbage}}
     return;
 
-  extern struct InnerBits getInner();
+  extern struct InnerBits getInner(void);
   bits.inner = getInner();
 
   if (foo() && bits.inner.e) // no-warning
@@ -117,7 +117,7 @@ void testBitfields() {
 // Incorrect behavior
 //-----------------------------------------------------------------------------
 
-void testTruncation() {
+void testTruncation(void) {
   struct Bits bits;
   bits.c = 0x11; // expected-warning{{implicit truncation}}
   // FIXME: We don't model truncation of bitfields.

clang/test/Analysis/flexible-array-members.c

@@ -22,7 +22,7 @@ void *alloca(size_t size);
 void *malloc(size_t size);
 void free(void *ptr);
 
-void test_incomplete_array_fam() {
+void test_incomplete_array_fam(void) {
   typedef struct FAM {
     char c;
     int data[];
@@ -48,7 +48,7 @@ void test_incomplete_array_fam() {
   free(q);
 }
 
-void test_zero_length_array_fam() {
+void test_zero_length_array_fam(void) {
   typedef struct FAM {
     char c;
     int data[0];
@@ -74,7 +74,7 @@ void test_zero_length_array_fam() {
   free(q);
 }
 
-void test_single_element_array_possible_fam() {
+void test_single_element_array_possible_fam(void) {
   typedef struct FAM {
     char c;
     int data[1];

clang/test/Analysis/flexignore.c

@@ -8,7 +8,7 @@
 
 /* A lexical scanner generated by flex */
 
-void clang_analyzer_warnIfReached();
-void foo() {
+void clang_analyzer_warnIfReached(void);
+void foo(void) {
   clang_analyzer_warnIfReached(); // conditional-warning {{REACHABLE}}
 }

clang/test/Analysis/free.c

@@ -10,21 +10,21 @@ typedef __typeof(sizeof(int)) size_t;
 void free(void *);
 void *alloca(size_t);
 
-void t1 () {
+void t1 (void) {
   int a[] = { 1 };
   free(a);
   // expected-warning@-1{{Argument to free() is the address of the local variable 'a', which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object 'a'}}
 }
 
-void t2 () {
+void t2 (void) {
   int a = 1;
   free(&a);
   // expected-warning@-1{{Argument to free() is the address of the local variable 'a', which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object 'a'}}
 }
 
-void t3 () {
+void t3 (void) {
   static int a[] = { 1 };
   free(a);
   // expected-warning@-1{{Argument to free() is the address of the static variable 'a', which is not memory allocated by malloc()}}
@@ -35,12 +35,12 @@ void t4 (char *x) {
   free(x); // no-warning
 }
 
-void t5 () {
-  extern char *ptr();
+void t5 (void) {
+  extern char *ptr(void);
   free(ptr()); // no-warning
 }
 
-void t6 () {
+void t6 (void) {
   free((void*)1000);
   // expected-warning@-1{{Argument to free() is a constant address (1000), which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object '(void *)1000'}}
@@ -55,30 +55,30 @@ void t8 (char **x) {
   free((*x)+8); // no-warning
 }
 
-void t9 () {
+void t9 (void) {
 label:
   free(&&label);
   // expected-warning@-1{{Argument to free() is the address of the label 'label', which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object 'label'}}
 }
 
-void t10 () {
+void t10 (void) {
   free((void*)&t10);
   // expected-warning@-1{{Argument to free() is the address of the function 't10', which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object 't10'}}
 }
 
-void t11 () {
+void t11 (void) {
   char *p = (char*)alloca(2);
   free(p); // expected-warning {{Memory allocated by alloca() should not be deallocated}}
 }
 
-void t12 () {
+void t12 (void) {
   char *p = (char*)__builtin_alloca(2);
   free(p); // expected-warning {{Memory allocated by alloca() should not be deallocated}}
 }
 
-void t13 () {
+void t13 (void) {
   free(^{return;});
   // expected-warning@-1{{Argument to free() is a block, which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object: block expression}}
@@ -91,7 +91,7 @@ void t14 (char a) {
 }
 
 static int someGlobal[2];
-void t15 () {
+void t15 (void) {
   free(someGlobal);
   // expected-warning@-1{{Argument to free() is the address of the global variable 'someGlobal', which is not memory allocated by malloc()}}
   // expected-warning@-2{{attempt to call free on non-heap object 'someGlobal'}}

clang/test/Analysis/fuchsia_lock.c

@@ -29,7 +29,7 @@ void bad2(void) {
   spin_unlock(&mtx1); // expected-warning {{This lock has already been unlocked}}
 }
 
-void bad3() {
+void bad3(void) {
   spin_lock_init(&mtx1);
   if (spin_trylock(&mtx1) != 0)
     spin_unlock(&mtx1); // expected-warning {{This lock has already been unlocked}}
@@ -42,14 +42,14 @@ void bad4(void) {
   spin_unlock(&mtx2);
 }
 
-void good() {
+void good(void) {
   spin_lock_t mtx;
   spin_lock_init(&mtx);
   spin_lock_save(&mtx, 0, 0);
   spin_unlock_restore(&mtx, 0, 0);
 }
 
-void good2() {
+void good2(void) {
   spin_lock_t mtx;
   spin_lock_init(&mtx);
   if (spin_trylock(&mtx) == 0)
@@ -78,7 +78,7 @@ void bad12(void) {
   sync_mutex_unlock(&smtx1); // expected-warning {{This lock has already been unlocked}}
 }
 
-void bad13() {
+void bad13(void) {
   sync_mutex_unlock(&smtx1);
   if (sync_mutex_trylock(&smtx1) != 0)
     sync_mutex_unlock(&smtx1); // expected-warning {{This lock has already been unlocked}}
@@ -91,13 +91,13 @@ void bad14(void) {
   sync_mutex_unlock(&smtx2);
 }
 
-void good11() {
+void good11(void) {
   sync_mutex_t mtx;
   if (sync_mutex_trylock(&mtx) == 0)
     sync_mutex_unlock(&mtx);
 }
 
-void good12() {
+void good12(void) {
   sync_mutex_t mtx;
   if (sync_mutex_timedlock(&mtx, 0) == 0)
     sync_mutex_unlock(&mtx);

clang/test/Analysis/fuchsia_lock_impl.c

@@ -3,7 +3,7 @@
 typedef int spin_lock_t;
 
 void spin_lock(spin_lock_t *lock);
-int getCond();
+int getCond(void);
 int spin_trylock(spin_lock_t *lock) {
     if (getCond())
         return 0;
@@ -12,7 +12,7 @@ int spin_trylock(spin_lock_t *lock) {
 void spin_unlock(spin_lock_t *lock);
 
 spin_lock_t mtx;
-void no_crash() {
+void no_crash(void) {
   if (spin_trylock(&mtx) == 0)
     spin_unlock(&mtx);
 }

clang/test/Analysis/func.c

@@ -1,7 +1,7 @@
 // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
 
 void clang_analyzer_eval(int);
-void clang_analyzer_warnIfReached();
+void clang_analyzer_warnIfReached(void);
 
 void f(void) {
   void (*p)(void);
@@ -13,7 +13,7 @@ void f(void) {
 
 void g(void (*fp)(void));
 
-void f2() {
+void f2(void) {
   g(f);
 }
 
@@ -27,7 +27,7 @@ void f3(void (*f)(void), void (*g)(void)) {
   clang_analyzer_eval(!g); // expected-warning{{FALSE}}
 }
 
-void nullFunctionPointerConstant() {
+void nullFunctionPointerConstant(void) {
   void (*f)(void) = 0;
   f(); // expected-warning{{Called function pointer is null}}
   clang_analyzer_warnIfReached(); // no-warning