diff --git a/gdb/testsuite/gdb.base/annota1.c b/gdb/testsuite/gdb.base/annota1.c
index 239ea16..424e1b8 100644
--- a/gdb/testsuite/gdb.base/annota1.c
+++ b/gdb/testsuite/gdb.base/annota1.c
@@ -2,28 +2,15 @@
 #include <signal.h>
 
 
-#ifdef PROTOTYPES
 void
 handle_USR1 (int sig)
 {
 }
-#else
-void
-handle_USR1 (sig)
-     int sig;
-{
-}
-#endif
 
 int value;
 
-#ifdef PROTOTYPES
 int
 main (void)
-#else
-int
-main ()
-#endif
 {
   int my_array[3] = { 1, 2, 3 };  /* break main */
   
diff --git a/gdb/testsuite/gdb.base/annota3.c b/gdb/testsuite/gdb.base/annota3.c
index 239ea16..424e1b8 100644
--- a/gdb/testsuite/gdb.base/annota3.c
+++ b/gdb/testsuite/gdb.base/annota3.c
@@ -2,28 +2,15 @@
 #include <signal.h>
 
 
-#ifdef PROTOTYPES
 void
 handle_USR1 (int sig)
 {
 }
-#else
-void
-handle_USR1 (sig)
-     int sig;
-{
-}
-#endif
 
 int value;
 
-#ifdef PROTOTYPES
 int
 main (void)
-#else
-int
-main ()
-#endif
 {
   int my_array[3] = { 1, 2, 3 };  /* break main */
   
diff --git a/gdb/testsuite/gdb.base/async.c b/gdb/testsuite/gdb.base/async.c
index 649e9e6..32779d9 100644
--- a/gdb/testsuite/gdb.base/async.c
+++ b/gdb/testsuite/gdb.base/async.c
@@ -1,12 +1,7 @@
 
 
-#ifdef PROTOTYPES
 int
 foo (void)
-#else
-int
-foo ()
-#endif
 {
  int y;
  volatile int x;
@@ -17,13 +12,8 @@ foo ()
  return x + y;
 }
 
-#ifdef PROTOTYPES
 int
 main (void)
-#else
-int
-main ()
-#endif
 {
  int y, z;
  
@@ -37,13 +27,8 @@ main ()
 }
 
 
-#ifdef PROTOTYPES
 int
 baz (void)
-#else
-int
-baz ()
-#endif
 { 
   return 5;
 }
diff --git a/gdb/testsuite/gdb.base/average.c b/gdb/testsuite/gdb.base/average.c
index 99c28cf..874bb1a 100644
--- a/gdb/testsuite/gdb.base/average.c
+++ b/gdb/testsuite/gdb.base/average.c
@@ -3,22 +3,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#ifdef PROTOTYPES
 extern int sum(int *, int, int);
-#else
-extern int sum();
-#endif
 
 #define num   10
 
 static int my_list[num] = {3,4,2,0,2,1,8,3,6,7};
 
-#ifdef PROTOTYPES
 void print_average(int *list, int low, int high) 
-#else
-void print_average(list, low, high)
-int *list, low, high;
-#endif
     {
         int total = 0, num_elements = 0, average = 0;
         total = sum(list, low, high);
@@ -28,11 +19,7 @@ int *list, low, high;
         printf("%10.d\n", average);
     }
 
-#ifdef PROTOTYPES
 int main(void)
-#else
-main ()
-#endif
 {
     char c;
     int first = 0, last = 0;	/* stop-in-main */
diff --git a/gdb/testsuite/gdb.base/call-ar-st.c b/gdb/testsuite/gdb.base/call-ar-st.c
index f43e001..4b2ffb4 100644
--- a/gdb/testsuite/gdb.base/call-ar-st.c
+++ b/gdb/testsuite/gdb.base/call-ar-st.c
@@ -141,13 +141,7 @@ struct int_char_combo_t {
  * IN     id_int student       -- enumerated type
  * IN     colors shirt         -- enumerated type
  *****************************************************************/
-#ifdef PROTOTYPES
 void print_student_id_shirt_color (id_int student, colors shirt)
-#else
-void print_student_id_shirt_color ( student, shirt ) 
- id_int student;
- colors shirt;
-#endif
 {
 
  printf("student id : %d\t", student);
@@ -196,12 +190,7 @@ void print_student_id_shirt_color ( student, shirt )
  * PRINT_CHAR_ARRAY : 
  * IN     char  array_c[]      -- character array 
  *****************************************************************/
-#ifdef PROTOTYPES
 void print_char_array (char array_c[])
-#else
-void print_char_array ( array_c ) 
-     char    array_c[];
-#endif
 {
 
   int index;
@@ -219,12 +208,7 @@ void print_char_array ( array_c )
  * PRINT_DOUBLE_ARRAY : 
  * IN     double array_d[]      -- array of doubles
  *****************************************************************/
-#ifdef PROTOTYPES
 void print_double_array (double  array_d[])
-#else
-void print_double_array (array_d) 
-     double  array_d[];
-#endif
 {
 
   int index;
@@ -242,12 +226,7 @@ void print_double_array (array_d)
  * PRINT_FLOAT_ARRAY: 
  * IN     float array_f[]      -- array of floats 
  *****************************************************************/
-#ifdef PROTOTYPES
 void print_float_array (float array_f[])
-#else
-void print_float_array ( array_f )
-     float array_f[];
-#endif
 {
 
   int index;
@@ -266,12 +245,7 @@ void print_float_array ( array_f )
  * PRINT_INT_ARRAY: 
  * IN     int  array_i[]      -- array of integers 
  *****************************************************************/
-#ifdef PROTOTYPES
 void print_int_array (int array_i[])
-#else
-void print_int_array ( array_i )
-     int array_i[];
-#endif
 {
 
   int index;
@@ -293,15 +267,7 @@ void print_int_array ( array_i )
  * IN     float array_f[]      -- array of floats 
  * IN     double array_d[]      -- array of doubles 
  *****************************************************************/
-#ifdef PROTOTYPES
 void print_all_arrays(int array_i[], char array_c[], float array_f[], double array_d[])
-#else
-void print_all_arrays( array_i, array_c, array_f, array_d )
-     int array_i[];
-     char array_c[];
-     float array_f[];
-     double array_d[];
-#endif
 {
   print_int_array(array_i);	/* -step1- */
   print_char_array(array_c);	/* -next1- */
@@ -325,12 +291,7 @@ void loop_count () {
  * A do nothing function. Used to provide a point at which calls can be made.  
  * IN  int seed
  *****************************************************************/
-#ifdef PROTOTYPES
 void compute_with_small_structs (int seed)
-#else
-void compute_with_small_structs ( seed ) 
- int seed;
-#endif
 {
 
      struct small_rep_info_t array[4];
@@ -360,18 +321,7 @@ void compute_with_small_structs ( seed )
  * IN  unsigned e  -- 0 or 1 
  * IN  unsigned o  -- 0 or 1 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_bit_flags (struct bit_flags_t *bit_flags, unsigned a, unsigned b, unsigned g, unsigned d, unsigned e, unsigned o)
-#else
-void init_bit_flags ( bit_flags, a, b, g, d, e, o )
-struct bit_flags_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o; 
-#endif
 {
 
    bit_flags->alpha = a;
@@ -397,20 +347,7 @@ unsigned o;
  * IN  unsigned e  -- 0 or 1 
  * IN  unsigned o  -- 0 or 1 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_bit_flags_combo (struct bit_flags_combo_t *bit_flags_combo, unsigned a, unsigned b, char ch1, unsigned g, unsigned d, char ch2, unsigned e, unsigned o)
-#else
-void init_bit_flags_combo ( bit_flags_combo, a, b, ch1, g, d, ch2, e, o )
-     struct bit_flags_combo_t *bit_flags_combo;
-     unsigned a;
-     unsigned b;
-     char     ch1;
-     unsigned g;
-     unsigned d;
-     char     ch2;
-     unsigned e;
-     unsigned o; 
-#endif
 {
 
    bit_flags_combo->alpha = a;	/* -step3- */
@@ -429,13 +366,7 @@ void init_bit_flags_combo ( bit_flags_combo, a, b, ch1, g, d, ch2, e, o )
  * OUT  struct one_double_t *one_double  -- structure to fill 
  * IN   double init_val
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_one_double (struct one_double_t *one_double, double init_val)
-#else
-void init_one_double ( one_double, init_val )
-     struct one_double_t *one_double;
-     double init_val; 
-#endif
 {
 
      one_double->double1  = init_val;
@@ -447,14 +378,7 @@ void init_one_double ( one_double, init_val )
  * IN  float init_val1 
  * IN  float init_val2 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_two_floats (struct two_floats_t *two_floats, float init_val1, float init_val2)
-#else
-void init_two_floats ( two_floats, init_val1, init_val2 )
-     struct two_floats_t *two_floats; 
-     float init_val1;
-     float init_val2;
-#endif
 {
      two_floats->float1 = init_val1;
      two_floats->float2 = init_val2;
@@ -466,14 +390,7 @@ void init_two_floats ( two_floats, init_val1, init_val2 )
  * IN  char init_val1 
  * IN  char init_val2 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_two_chars (struct two_char_t *two_char, char init_val1, char init_val2)
-#else
-void init_two_chars ( two_char, init_val1, init_val2 )
-     struct two_char_t *two_char;
-     char init_val1;
-     char init_val2; 
-#endif
 {
 
      two_char->ch1 = init_val1;
@@ -487,15 +404,7 @@ void init_two_chars ( two_char, init_val1, init_val2 )
  * IN  char init_val2 
  * IN  char init_val3 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_three_chars (struct three_char_t *three_char, char init_val1, char init_val2, char init_val3)
-#else
-void init_three_chars ( three_char, init_val1, init_val2, init_val3 )  
-     struct three_char_t *three_char; 
-     char init_val1;
-     char init_val2;
-     char init_val3;
-#endif
 {
 
      three_char->ch1 = init_val1;
@@ -512,17 +421,7 @@ void init_three_chars ( three_char, init_val1, init_val2, init_val3 )
  * IN  char init_val4 
  * IN  char init_val5 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_five_chars (struct five_char_t *five_char, char init_val1, char init_val2, char init_val3, char init_val4, char init_val5)
-#else
-void init_five_chars ( five_char, init_val1, init_val2, init_val3,init_val4,init_val5 )
-     struct five_char_t *five_char;
-     char init_val1;
-     char init_val2;
-     char init_val3;
-     char init_val4;
-     char init_val5;
-#endif
 {
      five_char->ch1 = init_val1;
      five_char->ch2 = init_val2;
@@ -537,14 +436,7 @@ void init_five_chars ( five_char, init_val1, init_val2, init_val3,init_val4,init
  * IN  int  init_val1 
  * IN  char init_val2 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_int_char_combo (struct int_char_combo_t *combo, int init_val1, char init_val2)
-#else
-void init_int_char_combo ( combo, init_val1, init_val2 )
-     struct int_char_combo_t *combo;
-     int init_val1; 
-     char init_val2; 
-#endif
 {
 
      combo->int1 = init_val1;
@@ -556,13 +448,7 @@ void init_int_char_combo ( combo, init_val1, init_val2 )
  * OUT struct small_rep_into_t *small_struct -- structure to be filled
  * IN  int  seed 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_struct_rep(struct small_rep_info_t *small_struct, int seed)
-#else
-void init_struct_rep( small_struct, seed )
-     struct small_rep_info_t *small_struct;
-     int    seed;
-#endif
 {
 
       small_struct->value = 2 + (seed*2); 
@@ -574,7 +460,6 @@ void init_struct_rep( small_struct, seed )
  * Takes all the small structures as input and calls the appropriate
  * initialization routine for each structure
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_small_structs (
      struct small_rep_info_t  *struct1,
      struct small_rep_info_t  *struct2,
@@ -591,25 +476,6 @@ void init_small_structs (
      struct two_floats_t      *f1,
      struct two_floats_t      *f2,
      struct two_floats_t      *f3)
-#else
-void init_small_structs (struct1, struct2, struct3,struct4,flags,flags_combo,
-three_char, five_char,int_char_combo, d1, d2,d3,f1,f2,f3)
-     struct small_rep_info_t  *struct1;
-     struct small_rep_info_t  *struct2;
-     struct small_rep_info_t  *struct3;
-     struct small_rep_info_t  *struct4;
-     struct bit_flags_t       *flags;
-     struct bit_flags_combo_t *flags_combo;
-     struct three_char_t      *three_char;
-     struct five_char_t       *five_char;
-     struct int_char_combo_t  *int_char_combo;
-     struct one_double_t      *d1;
-     struct one_double_t      *d2;
-     struct one_double_t      *d3;
-     struct two_floats_t      *f1;
-     struct two_floats_t      *f2;
-     struct two_floats_t      *f3;
-#endif
 {
 
      init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, 
@@ -636,7 +502,6 @@ three_char, five_char,int_char_combo, d1, d2,d3,f1,f2,f3)
  * PRINT_TEN_DOUBLES : 
  * ?????????????????????????????
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_ten_doubles (
      double d1,
      double d2,
@@ -648,19 +513,6 @@ void print_ten_doubles (
      double d8,
      double d9,
      double d10)
-#else
-void print_ten_doubles ( d1, d2, d3, d4, d5, d6, d7, d8, d9, d10 )
-     double d1;
-     double d2;
-     double d3;
-     double d4;
-     double d5;
-     double d6;
-     double d7;
-     double d8;
-     double d9;
-     double d10; 
-#endif
 {
 
   printf("Two Doubles : %f\t%f\n", d1, d2);
@@ -674,12 +526,7 @@ void print_ten_doubles ( d1, d2, d3, d4, d5, d6, d7, d8, d9, d10 )
  * PRINT_BIT_FLAGS : 
  * IN struct bit_flags_t bit_flags 
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_bit_flags (struct bit_flags_t bit_flags)
-#else
-void print_bit_flags ( bit_flags )
-struct bit_flags_t bit_flags;
-#endif
 {
 
      if (bit_flags.alpha) printf("alpha\n");
@@ -694,12 +541,7 @@ struct bit_flags_t bit_flags;
  * PRINT_BIT_FLAGS_COMBO : 
  * IN struct bit_flags_combo_t bit_flags_combo 
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo)
-#else
-void print_bit_flags_combo ( bit_flags_combo )
-     struct bit_flags_combo_t bit_flags_combo;
-#endif
 {
 
      if (bit_flags_combo.alpha) printf("alpha\n");
@@ -715,12 +557,7 @@ void print_bit_flags_combo ( bit_flags_combo )
  * PRINT_ONE_DOUBLE : 
  * IN struct one_double_t one_double 
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_one_double (struct one_double_t one_double)
-#else
-void print_one_double ( one_double )
-struct one_double_t one_double;
-#endif
 {
 
      printf("Contents of one_double_t: \n\n");
@@ -731,12 +568,7 @@ struct one_double_t one_double;
  * PRINT_TWO_FLOATS : 
  * IN struct two_floats_t two_floats 
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_two_floats (struct two_floats_t two_floats)
-#else
-void print_two_floats ( two_floats )
-struct two_floats_t two_floats; 
-#endif
 {
 
      printf("Contents of two_floats_t: \n\n");
@@ -747,12 +579,7 @@ struct two_floats_t two_floats;
  * PRINT_TWO_CHARS : 
  * IN struct two_char_t two_char
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_two_chars (struct two_char_t two_char)
-#else
-void print_two_chars ( two_char )
-struct two_char_t two_char; 
-#endif
 {
 
      printf("Contents of two_char_t: \n\n");
@@ -763,12 +590,7 @@ struct two_char_t two_char;
  * PRINT_THREE_CHARS : 
  * IN struct three_char_t three_char
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_three_chars (struct three_char_t three_char)
-#else
-void print_three_chars ( three_char )
-struct three_char_t three_char;
-#endif
 {
 
      printf("Contents of three_char_t: \n\n");
@@ -779,12 +601,7 @@ struct three_char_t three_char;
  * PRINT_FIVE_CHARS : 
  * IN struct five_char_t five_char
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_five_chars (struct five_char_t five_char)
-#else
-void print_five_chars ( five_char ) 
-struct five_char_t five_char; 
-#endif
 {
 
      printf("Contents of five_char_t: \n\n");
@@ -797,12 +614,7 @@ struct five_char_t five_char;
  * PRINT_INT_CHAR_COMBO : 
  * IN struct int_char_combo_t int_char_combo
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_int_char_combo (struct int_char_combo_t int_char_combo)
-#else
-void print_int_char_combo ( int_char_combo )
-struct int_char_combo_t int_char_combo;
-#endif
 {
 
      printf("Contents of int_char_combo_t: \n\n");
@@ -817,17 +629,10 @@ struct int_char_combo_t int_char_combo;
  * IN struct small_rep_info_t  struct2
  * IN struct small_rep_info_t  struct3
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_struct_rep(
      struct small_rep_info_t struct1,
      struct small_rep_info_t struct2,
      struct small_rep_info_t struct3)
-#else
-void print_struct_rep( struct1, struct2, struct3)
-     struct small_rep_info_t struct1;
-     struct small_rep_info_t struct2;
-     struct small_rep_info_t struct3;
-#endif
 {
 
 
@@ -849,21 +654,12 @@ void print_struct_rep( struct1, struct2, struct3)
  * IN struct small_rep_info_t  struct3
  * IN struct small_rep_info_t  struct4
  ****************************************************************/
-#ifdef PROTOTYPES
 void sum_struct_print (
      int seed,
      struct small_rep_info_t struct1,
      struct small_rep_info_t struct2, 
      struct small_rep_info_t struct3,
      struct small_rep_info_t struct4)
-#else
-void sum_struct_print ( seed, struct1, struct2, struct3, struct4) 
-     int seed;
-     struct small_rep_info_t struct1;
-     struct small_rep_info_t struct2; 
-     struct small_rep_info_t struct3; 
-     struct small_rep_info_t struct4; 
-#endif
 {
      int sum;
 
@@ -878,7 +674,6 @@ void sum_struct_print ( seed, struct1, struct2, struct3, struct4)
  * All of the small structures of odd sizes (40 bits, 8bits, etc.)
  * are pushed onto the stack.
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_small_structs (
      struct small_rep_info_t  struct1,
      struct small_rep_info_t  struct2,
@@ -895,25 +690,6 @@ void print_small_structs (
      struct two_floats_t      f1,
      struct two_floats_t      f2,
      struct two_floats_t      f3)
-#else
-void print_small_structs ( struct1, struct2, struct3,  struct4, flags, 
-flags_combo, three_char, five_char, int_char_combo, d1, d2,d3,f1,f2,f3)
-     struct small_rep_info_t  struct1;
-     struct small_rep_info_t  struct2;
-     struct small_rep_info_t  struct3;
-     struct small_rep_info_t  struct4;
-     struct bit_flags_t       flags;
-     struct bit_flags_combo_t flags_combo;
-     struct three_char_t      three_char;
-     struct five_char_t       five_char;
-     struct int_char_combo_t  int_char_combo;
-     struct one_double_t      d1;
-     struct one_double_t      d2;
-     struct one_double_t      d3;
-     struct two_floats_t      f1;
-     struct two_floats_t      f2;
-     struct two_floats_t      f3;
-#endif
 {
    print_bit_flags(flags);
    print_bit_flags_combo(flags_combo);
@@ -939,7 +715,6 @@ flags_combo, three_char, five_char, int_char_combo, d1, d2,d3,f1,f2,f3)
  * may force more space to be pushed onto the stack as part of the callers
  * frame.
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_long_arg_list (
      double a,
      double b,
@@ -962,32 +737,6 @@ void print_long_arg_list (
      struct two_floats_t      f1,
      struct two_floats_t      f2,
      struct two_floats_t      f3)
-#else
-void print_long_arg_list ( a, b, c, d, e, f, struct1, struct2, struct3, 
-struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1,d2,d3,
-f1, f2, f3 )
-     double a;
-     double b;
-     int c;
-     int d;
-     int e;
-     int f;
-     struct small_rep_info_t  struct1;
-     struct small_rep_info_t  struct2;
-     struct small_rep_info_t  struct3;
-     struct small_rep_info_t  struct4;
-     struct bit_flags_t       flags;
-     struct bit_flags_combo_t flags_combo;
-     struct three_char_t      three_char;
-     struct five_char_t       five_char;
-     struct int_char_combo_t  int_char_combo;
-     struct one_double_t      d1;
-     struct one_double_t      d2;
-     struct one_double_t      d3;
-     struct two_floats_t      f1;
-     struct two_floats_t      f2;
-     struct two_floats_t      f3;
-#endif
 {
     printf("double : %f\n", a);	/* -step2- */
     printf("double : %f\n", b);
@@ -1001,12 +750,7 @@ f1, f2, f3 )
 }
 
 
-#ifdef PROTOTYPES
 void print_one_large_struct (struct array_rep_info_t linked_list1)
-#else
-void print_one_large_struct( linked_list1 )
-     struct array_rep_info_t linked_list1;
-#endif
 {
 
  /* printf("Contents of linked list1: \n\n");
@@ -1027,17 +771,10 @@ void print_one_large_struct( linked_list1 )
  * IN struct array_rep_info_t linked_list2
  * IN struct array_rep_info_t linked_list3
  ****************************************************************/
-#ifdef PROTOTYPES
 void print_array_rep(
      struct array_rep_info_t linked_list1,
      struct array_rep_info_t linked_list2,
      struct array_rep_info_t linked_list3)
-#else
-void print_array_rep( linked_list1, linked_list2, linked_list3 )
-     struct array_rep_info_t linked_list1;
-     struct array_rep_info_t linked_list2;
-     struct array_rep_info_t linked_list3;
-#endif
 {
 
   int index;
@@ -1083,21 +820,12 @@ void print_array_rep( linked_list1, linked_list2, linked_list3 )
  * IN struct array_rep_info_t linked_list3
  * IN struct array_rep_info_t linked_list4
  ****************************************************************/
-#ifdef PROTOTYPES
 void sum_array_print (
      int seed,
      struct array_rep_info_t linked_list1,
      struct array_rep_info_t linked_list2,
      struct array_rep_info_t linked_list3,
      struct array_rep_info_t linked_list4)
-#else
-void sum_array_print ( seed, linked_list1, linked_list2, linked_list3,linked_list4)
-     int seed;
-     struct array_rep_info_t linked_list1;
-     struct array_rep_info_t linked_list2;
-     struct array_rep_info_t linked_list3;
-     struct array_rep_info_t linked_list4;
-#endif
 {
      int index;
      int sum;
@@ -1121,15 +849,9 @@ void sum_array_print ( seed, linked_list1, linked_list2, linked_list3,linked_lis
  * IN struct array_rep_info_t *linked_list
  * IN int    seed
  ****************************************************************/
-#ifdef PROTOTYPES
 void init_array_rep(
      struct array_rep_info_t *linked_list,
      int    seed)
-#else
-void init_array_rep( linked_list, seed )
-     struct array_rep_info_t *linked_list;
-     int    seed;
-#endif
 {
 
   int index;
diff --git a/gdb/testsuite/gdb.base/call-rt-st.c b/gdb/testsuite/gdb.base/call-rt-st.c
index a583bab..944f1af 100644
--- a/gdb/testsuite/gdb.base/call-rt-st.c
+++ b/gdb/testsuite/gdb.base/call-rt-st.c
@@ -141,7 +141,6 @@ void loop_count () {
  * IN  unsigned e  -- 0 or 1 
  * IN  unsigned o  -- 0 or 1 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_bit_flags_char (
 struct bit_flags_char_t *bit_flags,
 unsigned a,
@@ -150,16 +149,6 @@ unsigned g,
 unsigned d,
 unsigned e,
 unsigned o)
-#else
-void init_bit_flags_char (bit_flags,a,b,g,d,e,o) 
-struct bit_flags_char_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o; 
-#endif
 {
 
    bit_flags->alpha = a;
@@ -183,7 +172,6 @@ unsigned o;
  * IN  unsigned e  -- 0 or 1 
  * IN  unsigned o  -- 0 or 1 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_bit_flags_short (
 struct bit_flags_short_t *bit_flags,
 unsigned a,
@@ -192,16 +180,6 @@ unsigned g,
 unsigned d,
 unsigned e,
 unsigned o)
-#else
-void init_bit_flags_short (bit_flags,a,b,g,d,e,o) 
-struct bit_flags_short_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o; 
-#endif
 {
 
    bit_flags->alpha = a;
@@ -225,7 +203,6 @@ unsigned o;
  * IN  unsigned e  -- 0 or 1 
  * IN  unsigned o  -- 0 or 1 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_bit_flags (
 struct bit_flags_t *bit_flags,
 unsigned a,
@@ -234,16 +211,6 @@ unsigned g,
 unsigned d,
 unsigned e,
 unsigned o)
-#else
-void init_bit_flags (bit_flags,a,b,g,d,e,o) 
-struct bit_flags_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o; 
-#endif
 {
 
    bit_flags->alpha = a;
@@ -269,7 +236,6 @@ unsigned o;
  * IN  unsigned e  -- 0 or 1 
  * IN  unsigned o  -- 0 or 1 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_bit_flags_combo (
 struct bit_flags_combo_t *bit_flags_combo,
 unsigned a,
@@ -280,18 +246,6 @@ unsigned d,
 char ch2,
 unsigned e,
 unsigned o)
-#else
-void init_bit_flags_combo (bit_flags_combo, a, b, ch1, g, d, ch2, e, o)
-struct bit_flags_combo_t *bit_flags_combo;
-unsigned a;
-unsigned b;
-char ch1;
-unsigned g;
-unsigned d;
-char ch2;
-unsigned e;
-unsigned o;
-#endif
 {
 
    bit_flags_combo->alpha = a;
@@ -310,13 +264,7 @@ unsigned o;
  * OUT  struct one_double_t *one_double  -- structure to fill 
  * IN   double init_val
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_one_double ( struct one_double_t *one_double, double init_val)
-#else
-void init_one_double (one_double, init_val)
-struct one_double_t *one_double; 
-double init_val;
-#endif
 {
 
      one_double->double1  = init_val;
@@ -328,17 +276,10 @@ double init_val;
  * IN  float init_val1 
  * IN  float init_val2 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_two_floats (
      struct two_floats_t *two_floats,
      float init_val1,
      float init_val2)
-#else
-void init_two_floats (two_floats, init_val1, init_val2)
-struct two_floats_t *two_floats;
-float init_val1;
-float init_val2;
-#endif
 {
 
      two_floats->float1 = init_val1;
@@ -352,19 +293,11 @@ float init_val2;
  * IN  char init_val2 
  * IN  char init_val3 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_three_chars (
 struct three_char_t *three_char,
 char init_val1,
 char init_val2,
 char init_val3)
-#else
-void init_three_chars ( three_char, init_val1, init_val2, init_val3)
-struct three_char_t *three_char;
-char init_val1;
-char init_val2;
-char init_val3;
-#endif
 {
 
      three_char->ch1 = init_val1;
@@ -381,7 +314,6 @@ char init_val3;
  * IN  char init_val4 
  * IN  char init_val5 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_five_chars (
 struct five_char_t *five_char,
 char init_val1,
@@ -389,15 +321,6 @@ char init_val2,
 char init_val3,
 char init_val4,
 char init_val5)
-#else
-void init_five_chars ( five_char, init_val1, init_val2, init_val3, init_val4, init_val5)
-struct five_char_t *five_char;
-char init_val1;
-char init_val2;
-char init_val3;
-char init_val4;
-char init_val5;
-#endif
 {
 
      five_char->ch1 = init_val1;
@@ -413,17 +336,10 @@ char init_val5;
  * IN  int  init_val1 
  * IN  char init_val2 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_int_char_combo (
 struct int_char_combo_t *combo,
 int init_val1,
 char init_val2)
-#else
-void init_int_char_combo ( combo, init_val1, init_val2)
-struct int_char_combo_t *combo;
-int init_val1;
-char init_val2;
-#endif
 {
 
      combo->int1 = init_val1;
@@ -435,15 +351,9 @@ char init_val2;
  * OUT struct small_rep_into_t *small_struct -- structure to be filled
  * IN  int  seed 
  *****************************************************************/
-#ifdef PROTOTYPES
 void init_struct_rep(
      struct small_rep_info_t *small_struct,
      int seed)
-#else
-void init_struct_rep( small_struct, seed)
-struct small_rep_info_t *small_struct;
-int    seed;
-#endif
 {
 
       small_struct->value = 2 + (seed*2); 
@@ -454,12 +364,7 @@ int    seed;
  * PRINT_BIT_FLAGS_CHAR : 
  * IN struct bit_flags_char_t bit_flags 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct bit_flags_char_t print_bit_flags_char (struct bit_flags_char_t bit_flags)
-#else
-struct bit_flags_char_t print_bit_flags_char ( bit_flags)
-struct bit_flags_char_t bit_flags;
-#endif
 {
 
      if (bit_flags.alpha) printf("alpha\n");
@@ -476,12 +381,7 @@ struct bit_flags_char_t bit_flags;
  * PRINT_BIT_FLAGS_SHORT : 
  * IN struct bit_flags_short_t bit_flags 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct bit_flags_short_t print_bit_flags_short (struct bit_flags_short_t bit_flags)
-#else
-struct bit_flags_short_t print_bit_flags_short ( bit_flags)
-struct bit_flags_short_t bit_flags;
-#endif
 {
 
      if (bit_flags.alpha) printf("alpha\n");
@@ -498,12 +398,7 @@ struct bit_flags_short_t bit_flags;
  * PRINT_BIT_FLAGS : 
  * IN struct bit_flags_t bit_flags 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct bit_flags_t print_bit_flags (struct bit_flags_t bit_flags)
-#else
-struct bit_flags_t print_bit_flags ( bit_flags)
-struct bit_flags_t bit_flags;
-#endif
 {
 
      if (bit_flags.alpha) printf("alpha\n");
@@ -520,12 +415,7 @@ struct bit_flags_t bit_flags;
  * PRINT_BIT_FLAGS_COMBO : 
  * IN struct bit_flags_combo_t bit_flags_combo 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct bit_flags_combo_t print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo)
-#else
-struct bit_flags_combo_t print_bit_flags_combo ( bit_flags_combo )
-struct bit_flags_combo_t bit_flags_combo;
-#endif
 {
 
      if (bit_flags_combo.alpha) printf("alpha\n");
@@ -543,12 +433,7 @@ struct bit_flags_combo_t bit_flags_combo;
  * PRINT_ONE_DOUBLE : 
  * IN struct one_double_t one_double 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct one_double_t print_one_double (struct one_double_t one_double)
-#else
-struct one_double_t print_one_double ( one_double )
-struct one_double_t one_double;
-#endif
 {
 
      printf("Contents of one_double_t: \n\n");
@@ -561,12 +446,7 @@ struct one_double_t one_double;
  * PRINT_TWO_FLOATS : 
  * IN struct two_floats_t two_floats 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct two_floats_t print_two_floats (struct two_floats_t two_floats)
-#else
-struct two_floats_t print_two_floats ( two_floats ) 
-struct two_floats_t two_floats;
-#endif
 {
 
      printf("Contents of two_floats_t: \n\n");
@@ -579,12 +459,7 @@ struct two_floats_t two_floats;
  * PRINT_THREE_CHARS : 
  * IN struct three_char_t three_char
  ****************************************************************/
-#ifdef PROTOTYPES
 struct three_char_t print_three_chars (struct three_char_t three_char)
-#else
-struct three_char_t print_three_chars ( three_char ) 
-struct three_char_t three_char;
-#endif
 {
 
      printf("Contents of three_char_t: \n\n");
@@ -597,12 +472,7 @@ struct three_char_t three_char;
  * PRINT_FIVE_CHARS : 
  * IN struct five_char_t five_char
  ****************************************************************/
-#ifdef PROTOTYPES
 struct five_char_t print_five_chars (struct five_char_t five_char)
-#else
-struct five_char_t print_five_chars ( five_char )
-struct five_char_t five_char;
-#endif
 {
 
      printf("Contents of five_char_t: \n\n");
@@ -617,12 +487,7 @@ struct five_char_t five_char;
  * PRINT_INT_CHAR_COMBO : 
  * IN struct int_char_combo_t int_char_combo
  ****************************************************************/
-#ifdef PROTOTYPES
 struct int_char_combo_t print_int_char_combo (struct int_char_combo_t int_char_combo)
-#else
-struct int_char_combo_t print_int_char_combo ( int_char_combo )
-struct int_char_combo_t int_char_combo;
-#endif
 {
 
      printf("Contents of int_char_combo_t: \n\n");
@@ -634,12 +499,7 @@ struct int_char_combo_t int_char_combo;
 /*****************************************************************
  * PRINT_STRUCT_REP : 
  ****************************************************************/
-#ifdef PROTOTYPES
 struct small_rep_info_t print_struct_rep(struct small_rep_info_t struct1)
-#else
-struct small_rep_info_t print_struct_rep( struct1 )
-struct small_rep_info_t struct1;
-#endif
 {
 
   printf("Contents of struct1: \n\n");
@@ -652,12 +512,7 @@ struct small_rep_info_t struct1;
 }
 
 
-#ifdef PROTOTYPES
 struct array_rep_info_t print_one_large_struct(struct array_rep_info_t linked_list1)
-#else
-struct array_rep_info_t print_one_large_struct( linked_list1 )
-struct array_rep_info_t linked_list1;
-#endif
 {
 
 
@@ -673,13 +528,7 @@ struct array_rep_info_t linked_list1;
  * IN struct array_rep_info_t *linked_list
  * IN int    seed
  ****************************************************************/
-#ifdef PROTOTYPES
 void init_array_rep(struct array_rep_info_t *linked_list, int seed)
-#else
-void init_array_rep( linked_list, seed )
-struct array_rep_info_t *linked_list;
-int    seed;
-#endif
 {
 
   int index;
diff --git a/gdb/testsuite/gdb.base/call-sc.c b/gdb/testsuite/gdb.base/call-sc.c
index cec4b34..56c18da 100644
--- a/gdb/testsuite/gdb.base/call-sc.c
+++ b/gdb/testsuite/gdb.base/call-sc.c
@@ -41,12 +41,7 @@ T fun()
   return foo;  
 }
 
-#ifdef PROTOTYPES
 void Fun(T foo)
-#else
-void Fun(foo)
-     T foo;
-#endif
 {
   L = foo;
 }
diff --git a/gdb/testsuite/gdb.base/call-strs.c b/gdb/testsuite/gdb.base/call-strs.c
index f3bc8da..c0b1823 100644
--- a/gdb/testsuite/gdb.base/call-strs.c
+++ b/gdb/testsuite/gdb.base/call-strs.c
@@ -6,19 +6,13 @@ char buf[100];
 char bigbuf[1000];
 char * s;
 
-#ifdef PROTOTYPES
 char * str_func1(char *s1)
-#else
-char * str_func1(s1)
-char *s1;
-#endif
 {
   printf("first string arg is: %s\n", s1);
   strcpy(bigbuf, s1);
   return bigbuf;
 }
 
-#ifdef PROTOTYPES
 char * str_func(
 char * s1, 
 char * s2,
@@ -27,22 +21,6 @@ char * s4,
 char * s5,
 char * s6,
 char * s7)
-#else
-char * str_func(s1, 
-                s2,
-               s3,
-               s4,
-               s5,
-               s6,
-               s7)
-char * s1; 
-char * s2;
-char * s3;
-char * s4;
-char * s5;
-char * s6;
-char * s7;
-#endif
 {
   printf("first string arg is: %s\n", s1);
   printf("second string arg is: %s\n", s2);
diff --git a/gdb/testsuite/gdb.base/callfuncs.c b/gdb/testsuite/gdb.base/callfuncs.c
index 8548757..379b713 100644
--- a/gdb/testsuite/gdb.base/callfuncs.c
+++ b/gdb/testsuite/gdb.base/callfuncs.c
@@ -123,20 +123,12 @@ struct struct1 {
 #endif /* TEST_COMPLEX */
 /* Some functions that can be passed as arguments to other test
    functions, or called directly. */
-#ifdef PROTOTYPES
 int add (int a, int b)
-#else
-int add (a, b) int a, b;
-#endif
 {
   return (a + b);
 }
 
-#ifdef PROTOTYPES
 int doubleit (int a)
-#else
-int doubleit (a) int a;
-#endif
 {
   return (a + a);
 }
@@ -151,29 +143,17 @@ enum enumtype enum_val1 = enumval1;
 enum enumtype enum_val2 = enumval2;
 enum enumtype enum_val3 = enumval3;
 
-#ifdef PROTOTYPES
 int t_enum_value1 (enum enumtype enum_arg)
-#else
-int t_enum_value1 (enum_arg) enum enumtype enum_arg;
-#endif
 {
   return (enum_arg == enum_val1);
 }
 
-#ifdef PROTOTYPES
 int t_enum_value2 (enum enumtype enum_arg)
-#else
-int t_enum_value2 (enum_arg) enum enumtype enum_arg;
-#endif
 {
   return (enum_arg == enum_val2);
 }
 
-#ifdef PROTOTYPES
 int t_enum_value3 (enum enumtype enum_arg)
-#else
-int t_enum_value3 (enum_arg) enum enumtype enum_arg;
-#endif
 {
   return (enum_arg == enum_val3);
 }
@@ -181,11 +161,7 @@ int t_enum_value3 (enum_arg) enum enumtype enum_arg;
 /* A function that takes a vector of integers (along with an explicit
    count) and returns their sum. */
 
-#ifdef PROTOTYPES
 int sum_args (int argc, int argv[])
-#else
-int sum_args (argc, argv) int argc; int argv[];
-#endif
 {
   int sumval = 0;
   int idx;
@@ -200,7 +176,6 @@ int sum_args (argc, argv) int argc; int argv[];
 /* Test that we can call functions that take structs and return
    members from that struct */
 
-#ifdef PROTOTYPES
 char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
 short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
 int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
@@ -218,48 +193,17 @@ float _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.fc;}
 double _Complex t_structs_dc (struct struct1 tstruct) { return tstruct.dc;}
 long double _Complex t_structs_ldc (struct struct1 tstruct) { return tstruct.ldc;}
 #endif
-#else
-char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
-short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
-int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
-long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
-float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
-double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
-char  *t_structs_a (tstruct) struct struct1 tstruct;
-{
-  static char buf[8];
-  strcpy (buf, tstruct.a);
-  return buf;
-}
-#ifdef TEST_COMPLEX
-float _Complex t_structs_fc (tstruct) struct struct1 tstruct; { return tstruct.fc;}
-double _Complex t_structs_dc (tstruct) struct struct1 tstruct; { return tstruct.dc;}
-long double _Complex t_structs_ldc (tstruct) struct struct1 tstruct; { return tstruct.ldc;}
-#endif
-#endif
 
 /* Test that calling functions works if there are a lot of arguments.  */
-#ifdef PROTOTYPES
 int
 sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
-#else
-int
-sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
-     int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
-#endif
 {
   return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
 }
 
 /* Test that args are passed in the right order. */
-#ifdef PROTOTYPES
 int
 cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
-#else
-int
-cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
-  int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
-#endif
 {
   return
     (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
@@ -270,63 +214,29 @@ cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
    either 0 or 1, depending upon whether the values were
    passed incorrectly or correctly, respectively. */
 
-#ifdef PROTOTYPES
 int t_char_values (char char_arg1, char char_arg2)
-#else
-int t_char_values (char_arg1, char_arg2)
-char char_arg1, char_arg2;
-#endif
 {
   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 }
 
 int
-#ifdef PROTOTYPES
 t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
 		char arg6, short arg7, int arg8, short arg9, short arg10)
-#else
-t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-     char arg1;
-     short arg2;
-     int arg3;
-     char arg4;
-     short arg5;
-     char arg6;
-     short arg7;
-     int arg8;
-     short arg9;
-     short arg10;
-#endif
 {
   return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
 }
 
-#ifdef PROTOTYPES
 int t_short_values (short short_arg1, short short_arg2)
-#else
-int t_short_values (short_arg1, short_arg2)
-     short short_arg1, short_arg2;
-#endif
 {
   return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
 }
 
-#ifdef PROTOTYPES
 int t_int_values (int int_arg1, int int_arg2)
-#else
-int t_int_values (int_arg1, int_arg2)
-int int_arg1, int_arg2;
-#endif
 {
   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 }
 
-#ifdef PROTOTYPES
 int t_long_values (long long_arg1, long long_arg2)
-#else
-int t_long_values (long_arg1, long_arg2)
-long long_arg1, long_arg2;
-#endif
 {
   return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
 }
@@ -394,12 +304,7 @@ t_float_many_args (float f1, float f2, float f3, float f4, float f5, float f6,
 	  && (sum_args - sum_values) > -DELTA);
 }
 
-#ifdef PROTOTYPES
 int t_double_values (double double_arg1, double double_arg2)
-#else
-int t_double_values (double_arg1, double_arg2)
-double double_arg1, double_arg2;
-#endif
 {
   return ((double_arg1 - double_val1) < DELTA
 	  && (double_arg1 - double_val1) > -DELTA
@@ -544,47 +449,25 @@ DEF_FUNC_VALUES_3(fc, long double, creall, cimagl)
 #endif /* TEST_COMPLEX */
 
 
-#ifdef PROTOTYPES
 int t_string_values (char *string_arg1, char *string_arg2)
-#else
-int t_string_values (string_arg1, string_arg2)
-char *string_arg1, *string_arg2;
-#endif
 {
   return (!strcmp (string_arg1, string_val1) &&
 	  !strcmp (string_arg2, string_val2));
 }
 
-#ifdef PROTOTYPES
 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
-#else
-int t_char_array_values (char_array_arg1, char_array_arg2)
-char char_array_arg1[], char_array_arg2[];
-#endif
 {
   return (!strcmp (char_array_arg1, char_array_val1) &&
 	  !strcmp (char_array_arg2, char_array_val2));
 }
 
-#ifdef PROTOTYPES
 int t_double_int (double double_arg1, int int_arg2)
-#else
-int t_double_int (double_arg1, int_arg2)
-double double_arg1;
-int int_arg2;
-#endif
 {
   return ((double_arg1 - int_arg2) < DELTA
 	  && (double_arg1 - int_arg2) > -DELTA);
 }
 
-#ifdef PROTOTYPES
 int t_int_double (int int_arg1, double double_arg2)
-#else
-int t_int_double (int_arg1, double_arg2)
-int int_arg1;
-double double_arg2;
-#endif
 {
   return ((int_arg1 - double_arg2) < DELTA
 	  && (int_arg1 - double_arg2) > -DELTA);
@@ -608,25 +491,13 @@ double double_arg2;
    that function indirectly through the function pointer.  This would fail
    on the HPPA.  */
 
-#ifdef PROTOTYPES
 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
-#else
-int t_func_values (func_arg1, func_arg2)
-int (*func_arg1) PARAMS ((int, int));
-int (*func_arg2) PARAMS ((int));
-#endif
 {
   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
           && (*func_arg2) (6) == (*func_val2) (6));
 }
 
-#ifdef PROTOTYPES
 int t_call_add (int (*func_arg1)(int, int), int a, int b)
-#else
-int t_call_add (func_arg1, a, b)
-int (*func_arg1) PARAMS ((int, int));
-int a, b;
-#endif
 {
   return ((*func_arg1)(a, b));
 }
diff --git a/gdb/testsuite/gdb.base/ending-run.c b/gdb/testsuite/gdb.base/ending-run.c
index d857cf8..42f12c0 100644
--- a/gdb/testsuite/gdb.base/ending-run.c
+++ b/gdb/testsuite/gdb.base/ending-run.c
@@ -4,12 +4,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#ifdef PROTOTYPES
 int callee (int x)
-#else
-int callee( x )
-int x;
-#endif
 {
     int y = x * x;		/* -break1- */
     return (y - 2);
diff --git a/gdb/testsuite/gdb.base/execd-prog.c b/gdb/testsuite/gdb.base/execd-prog.c
index 5435f7d..ac9928f 100644
--- a/gdb/testsuite/gdb.base/execd-prog.c
+++ b/gdb/testsuite/gdb.base/execd-prog.c
@@ -8,13 +8,7 @@
    */
 int  global_i = 0;
 
-#ifdef PROTOTYPES
 int main (int argc, char **argv)
-#else
-main (argc, argv)
-  int  argc;
-  char *  argv[];
-#endif
 {
   /* There is a local_j in foll-exec, which exec's us.  We
      should not be able to see that other definition of local_j
diff --git a/gdb/testsuite/gdb.base/exprs.c b/gdb/testsuite/gdb.base/exprs.c
index e1ad182..cd605f3 100644
--- a/gdb/testsuite/gdb.base/exprs.c
+++ b/gdb/testsuite/gdb.base/exprs.c
@@ -1,11 +1,4 @@
-#ifdef PROTOTYPES
 int main (int argc, char **argv, char **envp)
-#else
-main (argc, argv, envp)
-     int argc;
-     char **argv;
-     char **envp;
-#endif
 {
     extern void dummy();
     dummy();
diff --git a/gdb/testsuite/gdb.base/foll-exec.c b/gdb/testsuite/gdb.base/foll-exec.c
index 5b0d9c5..6e302bb 100644
--- a/gdb/testsuite/gdb.base/foll-exec.c
+++ b/gdb/testsuite/gdb.base/foll-exec.c
@@ -6,11 +6,7 @@
 
 int  global_i = 100;
 
-#ifdef PROTOTYPES
 int main (void)
-#else
-main ()
-#endif
 {
   int  local_j = global_i+1;
   int  local_k = local_j+1;
diff --git a/gdb/testsuite/gdb.base/foll-fork.c b/gdb/testsuite/gdb.base/foll-fork.c
index a640928..4d8c138 100644
--- a/gdb/testsuite/gdb.base/foll-fork.c
+++ b/gdb/testsuite/gdb.base/foll-fork.c
@@ -2,22 +2,13 @@
 #include <unistd.h>
 #include <stdlib.h>
 
-#ifdef PROTOTYPES
 void callee (int i)
-#else
-void callee (i)
-  int  i;
-#endif
 {
   /* Any output corrupts GDB CLI expect strings.
      printf("callee: %d\n", i);  */
 }
 
-#ifdef PROTOTYPES
 int main (void)
-#else
-main ()
-#endif
 {
   int  pid;
   int  v = 5;
diff --git a/gdb/testsuite/gdb.base/foll-vfork.c b/gdb/testsuite/gdb.base/foll-vfork.c
index 27c0dfc..933ce38 100644
--- a/gdb/testsuite/gdb.base/foll-vfork.c
+++ b/gdb/testsuite/gdb.base/foll-vfork.c
@@ -18,11 +18,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#ifdef PROTOTYPES
 int main (void)
-#else
-main ()
-#endif
 {
   int  pid;
 
diff --git a/gdb/testsuite/gdb.base/funcargs.c b/gdb/testsuite/gdb.base/funcargs.c
index b34f3fb..600792f 100644
--- a/gdb/testsuite/gdb.base/funcargs.c
+++ b/gdb/testsuite/gdb.base/funcargs.c
@@ -77,12 +77,7 @@ char carray[] = {'a', 'n', ' ', 'a', 'r', 'r', 'a', 'y', '\0'};
 /* Test various permutations and interleaving of integral arguments */
 
 
-#ifdef PROTOTYPES
 void call0a (char c, short s, int i, long l)
-#else
-call0a (c, s, i, l)
-char c; short s; int i; long l;
-#endif
 {
   c = 'a';
   s = 5;
@@ -90,42 +85,22 @@ char c; short s; int i; long l;
   l = 7;
 }
 
-#ifdef PROTOTYPES
 void call0b (short s, int i, long l, char c)
-#else
-call0b (s, i, l, c)
-short s; int i; long l; char c;
-#endif
 {
   s = 6; i = 7; l = 8; c = 'j';
 }
 
-#ifdef PROTOTYPES
 void call0c (int i, long l, char c, short s)
-#else
-call0c (i, l, c, s)
-int i; long l; char c; short s;
-#endif
 {
   i = 3; l = 4; c = 'k'; s = 5;
 }
 
-#ifdef PROTOTYPES
 void call0d (long l, char c, short s, int i)
-#else
-call0d (l, c, s, i)
-long l; char c; short s; int i;
-#endif
 {
   l = 7; c = 'z'; s = 8; i = 9;
 }
 
-#ifdef PROTOTYPES
 void call0e (char c1, long l, char c2, int i, char c3, short s, char c4, char c5)
-#else
-call0e (c1, l, c2, i, c3, s, c4, c5)
-char c1; long l; char c2; int i; char c3; short s; char c4; char c5;
-#endif
 {
   c1 = 'a'; l = 5; c2 = 'b'; i = 7; c3 = 'c'; s = 7; c4 = 'f'; c5 = 'g';
 }
@@ -134,53 +109,27 @@ char c1; long l; char c2; int i; char c3; short s; char c4; char c5;
 /* Test various permutations and interleaving of unsigned integral arguments */
 
 
-#ifdef PROTOTYPES
 void call1a (unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call1a (uc, us, ui, ul)
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   uc = 5; us = 6; ui = 7; ul = 8;
 }
 
-#ifdef PROTOTYPES
 void call1b (unsigned short us, unsigned int ui, unsigned long ul, unsigned char uc)
-#else
-call1b (us, ui, ul, uc)
-unsigned short us; unsigned int ui; unsigned long ul; unsigned char uc;
-#endif
 {
   uc = 5; us = 6; ui = 7; ul = 8;
 }
 
-#ifdef PROTOTYPES
 void call1c (unsigned int ui, unsigned long ul, unsigned char uc, unsigned short us)
-#else
-call1c (ui, ul, uc, us)
-unsigned int ui; unsigned long ul; unsigned char uc; unsigned short us;
-#endif
 {
   uc = 5; us = 6; ui = 7; ul = 8;
 }
 
-#ifdef PROTOTYPES
 void call1d (unsigned long ul, unsigned char uc, unsigned short us, unsigned int ui)
-#else
-call1d (ul, uc, us, ui)
-unsigned long ul; unsigned char uc; unsigned short us; unsigned int ui;
-#endif
 {
   uc = 5; us = 6; ui = 7; ul = 8;
 }
 
-#ifdef PROTOTYPES
 void call1e (unsigned char uc1, unsigned long ul, unsigned char uc2, unsigned int ui, unsigned char uc3, unsigned short us, unsigned char uc4, unsigned char uc5)
-#else
-call1e (uc1, ul, uc2, ui, uc3, us, uc4, uc5)
-unsigned char uc1; unsigned long ul; unsigned char uc2; unsigned int ui;
-unsigned char uc3; unsigned short us; unsigned char uc4; unsigned char uc5;
-#endif
 {
   uc1 = 5; ul = 7; uc2 = 8; ui = 9; uc3 = 10; us = 11; uc4 = 12; uc5 = 55;
 }
@@ -189,93 +138,47 @@ unsigned char uc3; unsigned short us; unsigned char uc4; unsigned char uc5;
    floating point arguments. */
 
 
-#ifdef PROTOTYPES
 void call2a (char c, float f1, short s, double d1, int i, float f2, long l, double d2)
-#else
-call2a (c, f1, s, d1, i, f2, l, d2)
-char c; float f1; short s; double d1; int i; float f2; long l; double d2;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2b (float f1, short s, double d1, int i, float f2, long l, double d2, char c)
-#else
-call2b (f1, s, d1, i, f2, l, d2, c)
-float f1; short s; double d1; int i; float f2; long l; double d2; char c;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2c (short s, double d1, int i, float f2, long l, double d2, char c, float f1)
-#else
-call2c (s, d1, i, f2, l, d2, c, f1)
-short s; double d1; int i; float f2; long l; double d2; char c; float f1;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2d (double d1, int i, float f2, long l, double d2, char c, float f1, short s)
-#else
-call2d (d1, i, f2, l, d2, c, f1, s)
-double d1; int i; float f2; long l; double d2; char c; float f1; short s;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2e (int i, float f2, long l, double d2, char c, float f1, short s, double d1)
-#else
-call2e (i, f2, l, d2, c, f1, s, d1)
-int i; float f2; long l; double d2; char c; float f1; short s; double d1;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2f (float f2, long l, double d2, char c, float f1, short s, double d1, int i)
-#else
-call2f (f2, l, d2, c, f1, s, d1, i)
-float f2; long l; double d2; char c; float f1; short s; double d1; int i;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2g (long l, double d2, char c, float f1, short s, double d1, int i, float f2)
-#else
-call2g (l, d2, c, f1, s, d1, i, f2)
-long l; double d2; char c; float f1; short s; double d1; int i; float f2;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2h (double d2, char c, float f1, short s, double d1, int i, float f2, long l)
-#else
-call2h (d2, c, f1, s, d1, i, f2, l)
-double d2; char c; float f1; short s; double d1; int i; float f2; long l;
-#endif
 {
   c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
 }
 
-#ifdef PROTOTYPES
 void call2i (char c1, float f1, char c2, char c3, double d1, char c4, char c5, char c6, float f2, short s, char c7, double d2)
-#else
-call2i (c1, f1, c2, c3, d1, c4, c5, c6, f2, s, c7, d2)
-char c1; float f1; char c2; char c3; double d1; char c4; char c5; char c6;
-float f2; short s; char c7; double d2;
-#endif
 {
   c1 = 'a'; f1 = 0.0; c2 = 5; d1 = 0.0; c3 = 6; f2 = 0.1; c4 = 7; d2 = 0.2;
   c5 = 's'; c6 = 'f'; c7 = 'z'; s = 77;
@@ -285,33 +188,17 @@ float f2; short s; char c7; double d2;
 /* Test pointers to various integral and floating types. */
 
 
-#ifdef PROTOTYPES
 void call3a (char *cp, short *sp, int *ip, long *lp)
-#else
-call3a (cp, sp, ip, lp)
-char *cp; short *sp; int *ip; long *lp;
-#endif
 {
   cp = 0; sp = 0; ip = 0; lp = 0;
 }
 
-#ifdef PROTOTYPES
 void call3b (unsigned char *ucp, unsigned short *usp, unsigned int *uip, unsigned long *ulp)
-#else
-call3b (ucp, usp, uip, ulp)
-unsigned char *ucp; unsigned short *usp; unsigned int *uip;
-unsigned long *ulp;
-#endif
 {
   ucp = 0; usp = 0; uip = 0; ulp = 0;
 }
 
-#ifdef PROTOTYPES
 void call3c (float *fp, double *dp)
-#else
-call3c (fp, dp)
-float *fp; double *dp;
-#endif
 {
   fp = 0; dp = 0;
 }
@@ -322,107 +209,53 @@ float *fp; double *dp;
 
 /* Test various _Complex type args.  */
 
-#ifdef PROTOTYPES
 void callca (float _Complex f1, float _Complex f2, float _Complex f3)
-#else
-callca (f1, f2, f3)
-float _Complex f1; float _Complex f2; float _Complex f3;
-#endif
 {
 
 }
 
-#ifdef PROTOTYPES
 void callcb (double _Complex d1, double _Complex d2, double _Complex d3)
-#else
-callcb (d1, d2, d3)
-double _Complex d1; double _Complex d2; double _Complex d3;
-#endif
 {
 
 }
 
-#ifdef PROTOTYPES
 void callcc (long double _Complex ld1, long double _Complex ld2, long double _Complex ld3)
-#else
-callcc (ld1, ld2, ld3)
-long double _Complex ld1; long double _Complex ld2; long double _Complex ld3;
-#endif
 {
 
 }
 
-#ifdef PROTOTYPES
 void callcd (float _Complex fc1, double _Complex dc1, long double _Complex ldc1)
-#else
-callcd (fc1, dc1, ldc1)
-float _Complex fc1; double _Complex dc1; long double _Complex ldc1;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void callce (double _Complex dc1, long double _Complex ldc1, float _Complex fc1)
-#else
-callce (dc1, ldc1, fc1)
-double _Complex dc1; long double _Complex ldc1; float _Complex fc1;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void callcf (long double _Complex ldc1, float _Complex fc1, double _Complex dc1)
-#else
-callcf (ldc1, fc1, dc1)
-long double _Complex ldc1; float _Complex fc1; double _Complex dc1;
-#endif
 {
 }
 
 
 /* Test passing _Complex type and integral.  */
-#ifdef PROTOTYPES
 void callc1a (char c, short s, int i, unsigned int ui, long l,
 	      float _Complex fc1, double _Complex dc1,
 	      long double _Complex ldc1)
-#else
-callc1a (c, s, i, ui, l, fc1, dc1, ldc1)
-char c; short s; int i; unsigned int ui; long l; float _Complex fc1; double _Complex dc1; long double _Complex ldc1;
-#endif
 {}
 
-#ifdef PROTOTYPES
 void callc1b (long double _Complex ldc1, char c, short s, int i,
 	      float _Complex fc1, unsigned int ui, long l,  double _Complex dc1)
-#else
-callc1b (ldc1, c, s, i, fc1, ui, l, dc1)
-char c; short s; int i; unsigned int ui; long l; float _Complex fc1; double _Complex dc1; long double _Complex ldc1;
-#endif
 {}
 
 
-#ifdef PROTOTYPES
 void callc2a (char c, short s, int i, unsigned int ui, long l, float f,
 	      double d, float _Complex fc1, double _Complex dc1,
 	      long double _Complex ldc1)
-#else
-callc2a (c, s, i, ui, l, f, d, fc1, dc1, ldc1)
-     char c; short s; int i; unsigned int ui; long l; float f; double d;
-     float _Complex fc1; double _Complex dc1;
-     long double _Complex ldc1;
-#endif
 {}
 
-#ifdef PROTOTYPES
 void callc2b (float _Complex fc1, char c, short s, int i, unsigned int ui,
 	      long double _Complex ldc1, long l, float f, double d,
 	      double _Complex dc1)
-#else
-callc2b (fc1, c, s, i, ui, ldc1, l, f, d, dc1)
-     char c; short s; int i; unsigned int ui; long l; float f; double d;
-     float _Complex fc1; double _Complex dc1;
-     long double _Complex ldc1;
-#endif
 {}
 
 
@@ -431,20 +264,10 @@ callc2b (fc1, c, s, i, ui, ldc1, l, f, d, dc1)
 /* Test passing structures and unions by reference. */
 
 
-#ifdef PROTOTYPES
 void call4a (struct stag *stp)
-#else
-call4a (stp)
-struct stag *stp;
-#endif
 {stp = 0;}
 
-#ifdef PROTOTYPES
 void call4b (union utag *unp)
-#else
-call4b (unp)
-union utag *unp;
-#endif
 {
   unp = 0;
 }
@@ -453,20 +276,10 @@ union utag *unp;
 /* Test passing structures and unions by value. */
 
 
-#ifdef PROTOTYPES
 void call5a (struct stag st)
-#else
-call5a (st)
-struct stag st;
-#endif
 {st.s1 = 5;}
 
-#ifdef PROTOTYPES
 void call5b (union utag un)
-#else
-call5b (un)
-union utag un;
-#endif
 {un.u1 = 7;}
 
 
@@ -477,117 +290,61 @@ void call6k ()
 {
 }
 
-#ifdef PROTOTYPES
 void call6j (unsigned long ul)
-#else
-call6j (ul)
-unsigned long ul;
-#endif
 {
   ul = ul;
     call6k ();
 }
 
-#ifdef PROTOTYPES
 void call6i (unsigned int ui, unsigned long ul)
-#else
-call6i (ui, ul)
-unsigned int ui; unsigned long ul;
-#endif
 {
   ui = ui;
     call6j (ul);
 }
 
-#ifdef PROTOTYPES
 void call6h (unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6h (us, ui, ul)
-unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   us = us;
     call6i (ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6g (unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6g (uc, us, ui, ul)
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   uc = uc;
     call6h (us, ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6f (double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6f (d, uc, us, ui, ul)
-double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   d = d;
     call6g (uc, us, ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6e (float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6e (f, d, uc, us, ui, ul)
-float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   f = f;
     call6f (d, uc, us, ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6d (long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6d (l, f, d, uc, us, ui, ul)
-long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   l = l;
     call6e (f, d, uc, us, ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6c (int i, long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6c (i, l, f, d, uc, us, ui, ul)
-int i; long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   i = i;
     call6d (l, f, d, uc, us, ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6b (short s, int i, long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6b (s, i, l, f, d, uc, us, ui, ul)
-short s; int i; long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   s = s;
     call6c (i, l, f, d, uc, us, ui, ul);
 }
 
-#ifdef PROTOTYPES
 void call6a (char c, short s, int i, long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6a (c, s, i, l, f, d, uc, us, ui, ul)
-char c; short s; int i; long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
 {
   c = c;
     call6b (s, i, l, f, d, uc, us, ui, ul);
@@ -596,113 +353,58 @@ unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
 /*  Test shuffling of args, round robin */
 
 
-#ifdef PROTOTYPES
 void call7k (char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui)
-#else
-call7k (c, i, s, l, f, uc, d, us, ul, ui)
-char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui;
-#endif
 {
   c = 'a'; i = 7; s = 8; l = 7; f = 0.3; uc = 44; d = 0.44; us = 77;
   ul = 43; ui = 33;
 }
 
-#ifdef PROTOTYPES
 void call7j (unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul)
-#else
-call7j (ui, c, i, s, l, f, uc, d, us, ul)
-unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul;
-#endif
 {
     call7k (c, i, s, l, f, uc, d, us, ul, ui);
 }
 
-#ifdef PROTOTYPES
 void call7i (unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us)
-#else
-call7i (ul, ui, c, i, s, l, f, uc, d, us)
-unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us;
-#endif
 {
     call7j (ui, c, i, s, l, f, uc, d, us, ul);
 }
 
-#ifdef PROTOTYPES
 void call7h (unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc, double d)
-#else
-call7h (us, ul, ui, c, i, s, l, f, uc, d)
-unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc; double d;
-#endif
 {
     call7i (ul, ui, c, i, s, l, f, uc, d, us);
 }
 
-#ifdef PROTOTYPES
 void call7g (double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc)
-#else
-call7g (d, us, ul, ui, c, i, s, l, f, uc)
-double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc;
-#endif
 {
     call7h (us, ul, ui, c, i, s, l, f, uc, d);
 }
 
-#ifdef PROTOTYPES
 void call7f (unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f)
-#else
-call7f (uc, d, us, ul, ui, c, i, s, l, f)
-unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f;
-#endif
 {
     call7g (d, us, ul, ui, c, i, s, l, f, uc);
 }
 
-#ifdef PROTOTYPES
 void call7e (float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l)
-#else
-call7e (f, uc, d, us, ul, ui, c, i, s, l)
-float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l;
-#endif
 {
     call7f (uc, d, us, ul, ui, c, i, s, l, f);
 }
 
-#ifdef PROTOTYPES
 void call7d (long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s)
-#else
-call7d (l, f, uc, d, us, ul, ui, c, i, s)
-long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s;
-#endif
 {
     call7e (f, uc, d, us, ul, ui, c, i, s, l);
 }
 
-#ifdef PROTOTYPES
 void call7c (short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i)
-#else
-call7c (s, l, f, uc, d, us, ul, ui, c, i)
-short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i;
-#endif
 {
     call7d (l, f, uc, d, us, ul, ui, c, i, s);
 }
 
-#ifdef PROTOTYPES
 void call7b (int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c)
-#else
-call7b (i, s, l, f, uc, d, us, ul, ui, c)
-int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c;
-#endif
 {
     call7c (s, l, f, uc, d, us, ul, ui, c, i);
 }
 
-#ifdef PROTOTYPES
 void call7a (char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui)
-#else
-call7a (c, i, s, l, f, uc, d, us, ul, ui)
-char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui;
-#endif
 {
     call7b (i, s, l, f, uc, d, us, ul, ui, c);
 }
@@ -722,13 +424,7 @@ void hitbottom ()
 {
 }
 
-#ifdef PROTOTYPES
 void recurse (SVAL a, int depth)
-#else
-void recurse (a, depth)
-SVAL a;
-int depth;
-#endif
 {
   a.s = a.i = a.l = --depth;
   if (depth == 0)
@@ -748,16 +444,7 @@ void test_struct_args ()
    calls alloca may do things differently with respect to frames.  So give
    it a try.  */
 
-#ifdef PROTOTYPES
 void localvars_after_alloca (char c, short s, int i, long l)
-#else
-void
-localvars_after_alloca (c, s, i, l)
-     char c;
-     short s;
-     int i;
-     long l;
-#endif
 {
 #ifdef HAVE_STACK_ALLOCA
   /* No need to use the alloca.c alloca-on-top-of-malloc; it doesn't
@@ -772,29 +459,14 @@ localvars_after_alloca (c, s, i, l)
   l = 7;
 }
 
-#ifdef PROTOTYPES
 void call_after_alloca_subr (char c, short s, int i, long l, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-void
-call_after_alloca_subr (c, s, i, l, uc, us, ui, ul)
-char c; int i; short s; long l; unsigned char uc; unsigned short us; unsigned long ul; unsigned int ui;
-#endif
 {
   c = 'a';
   i = 7; s = 8; l = 7; uc = 44; us = 77;
   ul = 43; ui = 33;
 }
 
-#ifdef PROTOTYPES
 void call_after_alloca (char c, short s, int i, long l)
-#else
-void
-call_after_alloca (c, s, i, l)
-     char c;
-     short s;
-     int i;
-     long l;
-#endif
 {
 #ifdef HAVE_STACK_ALLOCA
   /* No need to use the alloca.c alloca-on-top-of-malloc; it doesn't
@@ -813,13 +485,7 @@ call_after_alloca (c, s, i, l)
    will require a trampoline between dyncall and this function on the
    call path, then another trampoline on between this function and main
    on the return path.  */
-#ifdef PROTOTYPES
 double call_with_trampolines (double d1)
-#else
-double
-call_with_trampolines (d1)
-double d1;
-#endif
 {
   return d1;
 } /* End of call_with_trampolines, this comment is needed by funcargs.exp */
diff --git a/gdb/testsuite/gdb.base/gcore.c b/gdb/testsuite/gdb.base/gcore.c
index 88418b3..ee826a5 100644
--- a/gdb/testsuite/gdb.base/gcore.c
+++ b/gdb/testsuite/gdb.base/gcore.c
@@ -49,12 +49,7 @@ array_func ()
   terminal_func ();
 }
 
-#ifdef PROTOTYPES
 int factorial_func (int value)
-#else
-int factorial_func (value)
-     int value;
-#endif
 {
   if (value > 1) {
     value *= factorial_func (value - 1);
diff --git a/gdb/testsuite/gdb.base/jump.c b/gdb/testsuite/gdb.base/jump.c
index 3c05244..376ea17 100644
--- a/gdb/testsuite/gdb.base/jump.c
+++ b/gdb/testsuite/gdb.base/jump.c
@@ -2,12 +2,7 @@
    particularly deep about the functionality nor names in here.
    */
 
-#ifdef PROTOTYPES
 static int square (int x)
-#else
-static int square (x)
-  int  x;
-#endif
 {
   return x*x;			/* out-of-func */
 }
diff --git a/gdb/testsuite/gdb.base/langs0.c b/gdb/testsuite/gdb.base/langs0.c
index cc6efdd..41e5d38 100644
--- a/gdb/testsuite/gdb.base/langs0.c
+++ b/gdb/testsuite/gdb.base/langs0.c
@@ -1,14 +1,8 @@
 /* This file is actually in C, it is not supposed to simulate something
    translated from another language or anything like that.  */
-#ifdef PROTOTYPES
 extern  int fsub_();
 
 int csub (int x)
-#else
-int
-csub (x)
-     int x;
-#endif
 {
   return x + 1;
 }
diff --git a/gdb/testsuite/gdb.base/langs1.c b/gdb/testsuite/gdb.base/langs1.c
index 8ffd13f..7b6b229 100644
--- a/gdb/testsuite/gdb.base/langs1.c
+++ b/gdb/testsuite/gdb.base/langs1.c
@@ -16,22 +16,14 @@ static integer c__10000 = 10000;
 
 /* I am not sure whether there is a way to have a fortran program without */
 /* a MAIN, but it does not really harm us to have one. */
-#ifdef PROTOTYPES
 /* Main program */ void MAIN__()
-#else
-/* Main program */ MAIN__()
-#endif
 {
 } /* MAIN__ */
 
 #line 4 "langs1.f"
 /* Subroutine */ int fsub_()
 {
-#ifdef PROTOTYPES
     extern integer cppsub_(int*);
-#else
-    extern integer cppsub_();
-#endif
 
 #line 5 "langs1.f"
 #line 6 "langs1.f"
diff --git a/gdb/testsuite/gdb.base/langs2.c b/gdb/testsuite/gdb.base/langs2.c
index 502b800..a06fb30 100644
--- a/gdb/testsuite/gdb.base/langs2.c
+++ b/gdb/testsuite/gdb.base/langs2.c
@@ -1,5 +1,4 @@
 /* This is intended to be a vague simulation of cfront output.  */
-#ifdef PROTOTYPES
 #line 1 "langs2.cxx"
 extern int csub (int);
 int
@@ -14,19 +13,3 @@ cppsub_ (int * y)
 {
   return foo__Fi (*y);
 }
-#else 
-#line 1 "langs2.cxx"
-extern int csub ();
-int
-foo__Fi (x) int x;
-{
-  return csub (x / 2);
-}
-
-extern int cppsub_ ();
-int
-cppsub_ (y) int *y;
-{
-  return foo__Fi (*y);
-}
-#endif
diff --git a/gdb/testsuite/gdb.base/mips_pro.c b/gdb/testsuite/gdb.base/mips_pro.c
index c28f99e..2c258a8 100644
--- a/gdb/testsuite/gdb.base/mips_pro.c
+++ b/gdb/testsuite/gdb.base/mips_pro.c
@@ -1,25 +1,13 @@
 /* Tests regarding examination of prologues.  */
 
-#ifdef PROTOTYPES
 int
 inner (int z)
-#else
-int
-inner (z)
-     int z;
-#endif
 {
   return 2 * z;
 }
 
-#ifdef PROTOTYPES
 int
 middle (int x)
-#else
-int
-middle (x)
-     int x;
-#endif
 {
   if (x == 0)
     return inner (5);
@@ -27,27 +15,14 @@ middle (x)
     return inner (6);
 }
 
-#ifdef PROTOTYPES
 int
 top (int y)
-#else
-int
-top (y)
-     int y;
-#endif
 {
   return middle (y + 1);
 }
 
-#ifdef PROTOTYPES
 int
 main (int argc, char **argv)
-#else
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-#endif
 {
   return top (-1) + top (1);
 }
diff --git a/gdb/testsuite/gdb.base/nodebug.c b/gdb/testsuite/gdb.base/nodebug.c
index 4857882..eb5d661 100644
--- a/gdb/testsuite/gdb.base/nodebug.c
+++ b/gdb/testsuite/gdb.base/nodebug.c
@@ -6,65 +6,33 @@ static int datalocal = 4;		/* Should go in local data */
 int bssglobal;				/* Should go in global bss */
 static int bsslocal;			/* Should go in local bss */
 
-#ifdef PROTOTYPES
 int
 inner (int x)
-#else
-int
-inner (x)
-     int x;
-#endif
 {
   return x + dataglobal + datalocal + bssglobal + bsslocal;
 }
 
-#ifdef PROTOTYPES
 static short
 middle (int x)
-#else
-static short
-middle (x)
-     int x;
-#endif
 {
   return 2 * inner (x);
 }
 
-#ifdef PROTOTYPES
 short
 top (int x)
-#else
-short
-top (x)
-     int x;
-#endif
 {
   return 2 * middle (x);
 }
 
-#ifdef PROTOTYPES
 int
 main (int argc, char **argv)
-#else
-int 
-main (argc, argv)
-     int argc;
-     char **argv;
-#endif
 {
   return top (argc);
 }
 
 int *x;
 
-#ifdef PROTOTYPES
 int array_index (char *arr, int i)
-#else
-int
-array_index (arr, i)
-     char *arr;
-     int i;
-#endif
 {
   /* The basic concept is just "return arr[i];".  But call malloc so that gdb
      will be able to call functions.  */
diff --git a/gdb/testsuite/gdb.base/opaque0.c b/gdb/testsuite/gdb.base/opaque0.c
index bf90eca..330560e 100644
--- a/gdb/testsuite/gdb.base/opaque0.c
+++ b/gdb/testsuite/gdb.base/opaque0.c
@@ -7,9 +7,7 @@
 
 struct foo *foop;
 extern struct foo *getfoo ();
-#ifdef PROTOTYPES
 extern void putfoo (struct foo *foop);
-#endif
 
 int main ()
 {
diff --git a/gdb/testsuite/gdb.base/opaque1.c b/gdb/testsuite/gdb.base/opaque1.c
index c34f7aa..ccb5fce 100644
--- a/gdb/testsuite/gdb.base/opaque1.c
+++ b/gdb/testsuite/gdb.base/opaque1.c
@@ -8,11 +8,6 @@ struct foo *getfoo ()
     return (&afoo);
 }
 
-#ifdef PROTOTYPES
 void putfoo (struct foo *foop)
-#else
-void putfoo (foop)
-     struct foo *foop;
-#endif
 {
 }
diff --git a/gdb/testsuite/gdb.base/recurse.c b/gdb/testsuite/gdb.base/recurse.c
index cb7b022..821c2de 100644
--- a/gdb/testsuite/gdb.base/recurse.c
+++ b/gdb/testsuite/gdb.base/recurse.c
@@ -1,14 +1,8 @@
 /* Trivial code used to test watchpoints in recursive code and 
    auto-deletion of watchpoints as they go out of scope.  */
 
-#ifdef PROTOTYPES
 static int
 recurse (int a)
-#else
-static int 
-recurse (a)
-     int a;
-#endif
 {
   int b = 0;
 
diff --git a/gdb/testsuite/gdb.base/run.c b/gdb/testsuite/gdb.base/run.c
index df54056..0c62002 100644
--- a/gdb/testsuite/gdb.base/run.c
+++ b/gdb/testsuite/gdb.base/run.c
@@ -6,17 +6,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#ifdef PROTOTYPES
 int factorial (int);
 
 int
 main (int argc, char **argv, char **envp)
-#else
-int
-main (argc, argv, envp)
-int argc;
-char *argv[], **envp;
-#endif
 {
 #ifdef FAKEARGV
     printf ("%d\n", factorial (1)); /* commands.exp: hw local_var out of scope */
@@ -31,11 +24,7 @@ char *argv[], **envp;
     return 0;
 }
 
-#ifdef PROTOTYPES
 int factorial (int value)
-#else
-int factorial (value) int value;
-#endif
 {
     int  local_var;
 
diff --git a/gdb/testsuite/gdb.base/scope0.c b/gdb/testsuite/gdb.base/scope0.c
index 775f8dc..e7f4724 100644
--- a/gdb/testsuite/gdb.base/scope0.c
+++ b/gdb/testsuite/gdb.base/scope0.c
@@ -44,14 +44,8 @@ void init0 ()
 
 /* This is to derail optimizer in localscopes.
    Return 1 + 2 + . . . + N.  */
-#ifdef PROTOTYPES
 int
 sum_upto (int n)
-#else
-int
-sum_upto (n)
-     int n;
-#endif
 {
   int i;
   int retval = 0;
@@ -61,13 +55,8 @@ sum_upto (n)
   return retval;
 }
 
-#ifdef PROTOTYPES
 int
 useit (int val)
-#else
-int
-useit (val) int val;
-#endif
 {
     static int usedval;
 
@@ -75,13 +64,8 @@ useit (val) int val;
     return val + sum_upto (0);
 }
 
-#ifdef PROTOTYPES
 int
 useitp (const int *val)
-#else
-int
-useitp (val) const int *val;
-#endif
 {
     static int usedval;
 
@@ -89,15 +73,8 @@ useitp (val) const int *val;
     return *val + sum_upto (0);
 }
 
-#ifdef PROTOTYPES
 int
 autovars (int bcd, int abc)
-#else
-int
-autovars (bcd, abc)
-     int bcd;
-     int abc;
-#endif
 {
     int  i0 =  useit (0),  i1 =  useit (1),  i2 =  useit (2);
     int  i3 =  useit (3),  i4 =  useit (4),  i5 =  useit (5);
@@ -172,14 +149,8 @@ autovars (bcd, abc)
       + i91 + i92 + i93 + i94 + i95 + i96 + i97 + i98 + i99 + abc + bcd;
 }
 
-#ifdef PROTOTYPES
 int
 localscopes (int x)
-#else
-int
-localscopes (x)
-     int x;
-#endif
 {
     int localval;
     int retval;
diff --git a/gdb/testsuite/gdb.base/scope1.c b/gdb/testsuite/gdb.base/scope1.c
index 2631ead..e4a7ed2 100644
--- a/gdb/testsuite/gdb.base/scope1.c
+++ b/gdb/testsuite/gdb.base/scope1.c
@@ -43,11 +43,7 @@ void usestatics1 ()
   useit1 (&filelocal_ro);
 }
 
-#ifdef PROTOTYPES
 void useit1 (const int *val)
-#else
-void useit1 (val) const int *val;
-#endif
 {
     static int usedval;
 
diff --git a/gdb/testsuite/gdb.base/setshow.c b/gdb/testsuite/gdb.base/setshow.c
index a30ef82..c8e843c 100644
--- a/gdb/testsuite/gdb.base/setshow.c
+++ b/gdb/testsuite/gdb.base/setshow.c
@@ -3,15 +3,8 @@
 
 #include <stdio.h>
 
-#ifdef PROTOTYPES
 int
 main(int argc, char **argv)
-#else
-int 
-main(argc, argv)
-     int argc;
-     char **argv;
-#endif
 {
   int i = 1;
 
diff --git a/gdb/testsuite/gdb.base/setvar.c b/gdb/testsuite/gdb.base/setvar.c
index 5d08602..1b8d808 100644
--- a/gdb/testsuite/gdb.base/setvar.c
+++ b/gdb/testsuite/gdb.base/setvar.c
@@ -1,13 +1,6 @@
 #include <stdlib.h>
 
-#ifdef PROTOTYPES
 int main (int argc, char **argv, char **envp)
-#else
-main (argc, argv, envp)
-     int argc;
-     char **argv;
-     char **envp;
-#endif
 {
     extern void dummy();
     dummy();
diff --git a/gdb/testsuite/gdb.base/shmain.c b/gdb/testsuite/gdb.base/shmain.c
index d2dc2f3..e36f84f 100644
--- a/gdb/testsuite/gdb.base/shmain.c
+++ b/gdb/testsuite/gdb.base/shmain.c
@@ -18,22 +18,12 @@ struct {
 
 int g;
 
-#ifdef PROTOTYPES
 int local_structarg(struct s x)
-#else
-int local_structarg(x)
-struct s x;
-#endif
 {
   return x.b;
 }
 
-#ifdef PROTOTYPES
 int mainshr1(int g)
-#else
-int mainshr1(g)
-int g;
-#endif
 {
   return 2*g;
 }
diff --git a/gdb/testsuite/gdb.base/shr1.c b/gdb/testsuite/gdb.base/shr1.c
index 117119a..da7bffa 100644
--- a/gdb/testsuite/gdb.base/shr1.c
+++ b/gdb/testsuite/gdb.base/shr1.c
@@ -7,12 +7,7 @@ float sg = 5.5;
 int sgi = 2;
 static int sgs = 7;
 
-#ifdef PROTOTYPES
 int shr1(int x)
-#else
-int shr1(x)
-int x;
-#endif
 {
   f mumble;
   int l;
@@ -29,32 +24,17 @@ int x;
   return 2*x;
 }
 
-#ifdef PROTOTYPES
 static int shr1_local(int x)
-#else
-static int shr1_local(x)
-int x;
-#endif
 {
   return 2*x;
 }
 
-#ifdef PROTOTYPES
 int structarg(struct s x)
-#else
-int structarg(x)
-struct s x;
-#endif
 {
   return x.a;
 }
 
-#ifdef PROTOTYPES
 int pstructarg(struct s *x)
-#else
-int pstructarg(x)
-struct s *x;
-#endif
 {
   return x->a;
 }
diff --git a/gdb/testsuite/gdb.base/shr2.c b/gdb/testsuite/gdb.base/shr2.c
index 36a71b3..1007b61 100644
--- a/gdb/testsuite/gdb.base/shr2.c
+++ b/gdb/testsuite/gdb.base/shr2.c
@@ -1,17 +1,9 @@
-#ifdef PROTOTYPES
 int shr2(int x)
-#else
-int shr2(x) int x;
-#endif
 {
   return 2*x;			/* shr2-return */
 }
 
-#ifdef PROTOTYPES
 int shr2_local(int x)
-#else
-int shr2_local(x) int x;
-#endif
 {
   return 2*x;
 }
diff --git a/gdb/testsuite/gdb.base/sigall.c b/gdb/testsuite/gdb.base/sigall.c
index 283cef3..81f3b08 100644
--- a/gdb/testsuite/gdb.base/sigall.c
+++ b/gdb/testsuite/gdb.base/sigall.c
@@ -5,784 +5,358 @@
 /* Signal handlers, we set breakpoints in them to make sure that the
    signals really get delivered.  */
 
-#ifdef PROTOTYPES
 void
 handle_ABRT (int sig)
-#else
-void
-handle_ABRT (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_HUP (int sig)
-#else
-void
-handle_HUP (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_QUIT (int sig)
-#else
-void
-handle_QUIT (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_ILL (int sig)
-#else
-void
-handle_ILL (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_EMT (int sig)
-#else
-void
-handle_EMT (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_FPE (int sig)
-#else
-void
-handle_FPE (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_BUS (int sig)
-#else
-void
-handle_BUS (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_SEGV (int sig)
-#else
-void
-handle_SEGV (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_SYS (int sig)
-#else
-void
-handle_SYS (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_PIPE (int sig)
-#else
-void
-handle_PIPE (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_ALRM (int sig)
-#else
-void
-handle_ALRM (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_URG (int sig)
-#else
-void
-handle_URG (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_TSTP (int sig)
-#else
-void
-handle_TSTP (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_CONT (int sig)
-#else
-void
-handle_CONT (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_CHLD (int sig)
-#else
-void
-handle_CHLD (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_TTIN (int sig)
-#else
-void
-handle_TTIN (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_TTOU (int sig)
-#else
-void
-handle_TTOU (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_IO (int sig)
-#else
-void
-handle_IO (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_XCPU (int sig)
-#else
-void
-handle_XCPU (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_XFSZ (int sig)
-#else
-void
-handle_XFSZ (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_VTALRM (int sig)
-#else
-void
-handle_VTALRM (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_PROF (int sig)
-#else
-void
-handle_PROF (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_WINCH (int sig)
-#else
-void
-handle_WINCH (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_LOST (int sig)
-#else
-void
-handle_LOST (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_USR1 (int sig)
-#else
-void
-handle_USR1 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_USR2 (int sig)
-#else
-void
-handle_USR2 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_PWR (int sig)
-#else
-void
-handle_PWR (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_POLL (int sig)
-#else
-void
-handle_POLL (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_WIND (int sig)
-#else
-void
-handle_WIND (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_PHONE (int sig)
-#else
-void
-handle_PHONE (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_WAITING (int sig)
-#else
-void
-handle_WAITING (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_LWP (int sig)
-#else
-void
-handle_LWP (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_DANGER (int sig)
-#else
-void
-handle_DANGER (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_GRANT (int sig)
-#else
-void
-handle_GRANT (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_RETRACT (int sig)
-#else
-void
-handle_RETRACT (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_MSG (int sig)
-#else
-void
-handle_MSG (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_SOUND (int sig)
-#else
-void
-handle_SOUND (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_SAK (int sig)
-#else
-void
-handle_SAK (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_PRIO (int sig)
-#else
-void
-handle_PRIO (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_33 (int sig)
-#else
-void
-handle_33 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_34 (int sig)
-#else
-void
-handle_34 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_35 (int sig)
-#else
-void
-handle_35 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_36 (int sig)
-#else
-void
-handle_36 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_37 (int sig)
-#else
-void
-handle_37 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_38 (int sig)
-#else
-void
-handle_38 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_39 (int sig)
-#else
-void
-handle_39 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_40 (int sig)
-#else
-void
-handle_40 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_41 (int sig)
-#else
-void
-handle_41 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_42 (int sig)
-#else
-void
-handle_42 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_43 (int sig)
-#else
-void
-handle_43 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_44 (int sig)
-#else
-void
-handle_44 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_45 (int sig)
-#else
-void
-handle_45 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_46 (int sig)
-#else
-void
-handle_46 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_47 (int sig)
-#else
-void
-handle_47 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_48 (int sig)
-#else
-void
-handle_48 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_49 (int sig)
-#else
-void
-handle_49 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_50 (int sig)
-#else
-void
-handle_50 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_51 (int sig)
-#else
-void
-handle_51 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_52 (int sig)
-#else
-void
-handle_52 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_53 (int sig)
-#else
-void
-handle_53 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_54 (int sig)
-#else
-void
-handle_54 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_55 (int sig)
-#else
-void
-handle_55 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_56 (int sig)
-#else
-void
-handle_56 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_57 (int sig)
-#else
-void
-handle_57 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_58 (int sig)
-#else
-void
-handle_58 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_59 (int sig)
-#else
-void
-handle_59 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_60 (int sig)
-#else
-void
-handle_60 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_61 (int sig)
-#else
-void
-handle_61 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_62 (int sig)
-#else
-void
-handle_62 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_63 (int sig)
-#else
-void
-handle_63 (sig)
-     int sig;
-#endif
 {
 }
 
-#ifdef PROTOTYPES
 void
 handle_TERM (int sig)
-#else
-void
-handle_TERM (sig)
-     int sig;
-#endif
 {
 }
 
diff --git a/gdb/testsuite/gdb.base/signals.c b/gdb/testsuite/gdb.base/signals.c
index 51e97c4..7566068 100644
--- a/gdb/testsuite/gdb.base/signals.c
+++ b/gdb/testsuite/gdb.base/signals.c
@@ -6,14 +6,8 @@
 
 static int count = 0;
 
-#ifdef PROTOTYPES
 static void
 handler (int sig)
-#else
-static void
-handler (sig)
-     int sig;
-#endif
 {
   signal (sig, handler);
   ++count;
diff --git a/gdb/testsuite/gdb.base/so-indr-cl.c b/gdb/testsuite/gdb.base/so-indr-cl.c
index f31800d..9b5e5a9 100644
--- a/gdb/testsuite/gdb.base/so-indr-cl.c
+++ b/gdb/testsuite/gdb.base/so-indr-cl.c
@@ -3,18 +3,10 @@
    */
 
 #include <stdio.h>
-#ifdef PROTOTYPES
 extern "C" int solib_main (int);
 
 static int
 solib_wrapper (int (*function)(int))
-#else
-extern int solib_main (int);
-
-static int
-solib_wrapper (function)
-  int (*function)(int);
-#endif
 {
   return (*function)(100);
 }
diff --git a/gdb/testsuite/gdb.base/solib2.c b/gdb/testsuite/gdb.base/solib2.c
index 8c69d8b..131c337 100644
--- a/gdb/testsuite/gdb.base/solib2.c
+++ b/gdb/testsuite/gdb.base/solib2.c
@@ -5,12 +5,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#ifdef PROTOTYPES
 int  solib_main (int  arg)
-#else
-int  solib_main (arg)
-  int  arg;
-#endif
 {
   return arg*arg*arg;
 }
diff --git a/gdb/testsuite/gdb.base/structs.c b/gdb/testsuite/gdb.base/structs.c
index d0b69a8..1fb4250 100644
--- a/gdb/testsuite/gdb.base/structs.c
+++ b/gdb/testsuite/gdb.base/structs.c
@@ -193,165 +193,75 @@ struct struct18 fun18()
   return foo18; 
 }
 
-#ifdef PROTOTYPES
 void Fun1(struct struct1 foo1)
-#else
-void Fun1(foo1)
-     struct struct1 foo1;
-#endif
 {
   L1 = foo1;
 }
-#ifdef PROTOTYPES
 void Fun2(struct struct2 foo2)
-#else
-void Fun2(foo2)
-     struct struct2 foo2;
-#endif
 {
   L2 = foo2;
 }
-#ifdef PROTOTYPES
 void Fun3(struct struct3 foo3)
-#else
-void Fun3(foo3)
-     struct struct3 foo3;
-#endif
 {
   L3 = foo3;
 }
-#ifdef PROTOTYPES
 void Fun4(struct struct4 foo4)
-#else
-void Fun4(foo4)
-     struct struct4 foo4;
-#endif
 {
   L4 = foo4;
 }
-#ifdef PROTOTYPES
 void Fun5(struct struct5 foo5)
-#else
-void Fun5(foo5)
-     struct struct5 foo5;
-#endif
 {
   L5 = foo5;
 }
-#ifdef PROTOTYPES
 void Fun6(struct struct6 foo6)
-#else
-void Fun6(foo6)
-     struct struct6 foo6;
-#endif
 {
   L6 = foo6;
 }
-#ifdef PROTOTYPES
 void Fun7(struct struct7 foo7)
-#else
-void Fun7(foo7)
-     struct struct7 foo7;
-#endif
 {
   L7 = foo7;
 }
-#ifdef PROTOTYPES
 void Fun8(struct struct8 foo8)
-#else
-void Fun8(foo8)
-     struct struct8 foo8;
-#endif
 {
   L8 = foo8;
 }
-#ifdef PROTOTYPES
 void Fun9(struct struct9 foo9)
-#else
-void Fun9(foo9)
-     struct struct9 foo9;
-#endif
 {
   L9 = foo9;
 }
-#ifdef PROTOTYPES
 void Fun10(struct struct10 foo10)
-#else
-void Fun10(foo10)
-     struct struct10 foo10;
-#endif
 {
   L10 = foo10; 
 }
-#ifdef PROTOTYPES
 void Fun11(struct struct11 foo11)
-#else
-void Fun11(foo11)
-     struct struct11 foo11;
-#endif
 {
   L11 = foo11; 
 }
-#ifdef PROTOTYPES
 void Fun12(struct struct12 foo12)
-#else
-void Fun12(foo12)
-     struct struct12 foo12;
-#endif
 {
   L12 = foo12; 
 }
-#ifdef PROTOTYPES
 void Fun13(struct struct13 foo13)
-#else
-void Fun13(foo13)
-     struct struct13 foo13;
-#endif
 {
   L13 = foo13; 
 }
-#ifdef PROTOTYPES
 void Fun14(struct struct14 foo14)
-#else
-void Fun14(foo14)
-     struct struct14 foo14;
-#endif
 {
   L14 = foo14; 
 }
-#ifdef PROTOTYPES
 void Fun15(struct struct15 foo15)
-#else
-void Fun15(foo15)
-     struct struct15 foo15;
-#endif
 {
   L15 = foo15; 
 }
-#ifdef PROTOTYPES
 void Fun16(struct struct16 foo16)
-#else
-void Fun16(foo16)
-     struct struct16 foo16;
-#endif
 {
   L16 = foo16; 
 }
-#ifdef PROTOTYPES
 void Fun17(struct struct17 foo17)
-#else
-void Fun17(foo17)
-     struct struct17 foo17;
-#endif
 {
   L17 = foo17; 
 }
-#ifdef PROTOTYPES
 void Fun18(struct struct18 foo18)
-#else
-void Fun18(foo18)
-     struct struct18 foo18;
-#endif
 {
   L18 = foo18; 
 }
diff --git a/gdb/testsuite/gdb.base/sum.c b/gdb/testsuite/gdb.base/sum.c
index 6dd7a75..3e27fa1 100644
--- a/gdb/testsuite/gdb.base/sum.c
+++ b/gdb/testsuite/gdb.base/sum.c
@@ -1,12 +1,7 @@
 /* This is a sample program for the HP/DDE debugger. */
 #include <stdio.h>
 
-#ifdef PROTOTYPES
 int sum(int *list, int low, int high)
-#else
-int sum(list, low, high)
-int *list, low, high;
-#endif
     {
         int i = 0, s = 0;	/* stop-in-sum */
         for (i = low; i <= high; i++)
diff --git a/gdb/testsuite/gdb.base/vforked-prog.c b/gdb/testsuite/gdb.base/vforked-prog.c
index 763e5d9..818ad98 100644
--- a/gdb/testsuite/gdb.base/vforked-prog.c
+++ b/gdb/testsuite/gdb.base/vforked-prog.c
@@ -17,11 +17,7 @@
 
 #include <stdio.h>
 
-#ifdef PROTOTYPES
 int main (void)
-#else
-main()
-#endif
 {
   printf("Hello from vforked-prog...\n");
   return 0;
diff --git a/gdb/testsuite/gdb.base/watchpoint.c b/gdb/testsuite/gdb.base/watchpoint.c
index 92fb3b1..60f60d6 100644
--- a/gdb/testsuite/gdb.base/watchpoint.c
+++ b/gdb/testsuite/gdb.base/watchpoint.c
@@ -81,11 +81,7 @@ void marker6 ()
 {
 }
 
-#ifdef PROTOTYPES
 void recurser (int  x)
-#else
-void recurser (x) int  x;
-#endif
 {
   int  local_x = 0;
 
diff --git a/gdb/testsuite/gdb.reverse/shr2.c b/gdb/testsuite/gdb.reverse/shr2.c
index 52ed6b2..1329df1 100644
--- a/gdb/testsuite/gdb.reverse/shr2.c
+++ b/gdb/testsuite/gdb.reverse/shr2.c
@@ -17,20 +17,12 @@
 
 #include "shr.h"
 
-#ifdef PROTOTYPES
 int shr2(int x)
-#else
-int shr2(x) int x;
-#endif
 {
   return 2*x;
 }
 
-#ifdef PROTOTYPES
 int shr2_local(int x)
-#else
-int shr2_local(x) int x;
-#endif
 {
   return 2*x;
 }
diff --git a/gdb/testsuite/gdb.reverse/until-reverse.c b/gdb/testsuite/gdb.reverse/until-reverse.c
index 28c71b2..80581b4 100644
--- a/gdb/testsuite/gdb.reverse/until-reverse.c
+++ b/gdb/testsuite/gdb.reverse/until-reverse.c
@@ -18,34 +18,20 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#ifdef PROTOTYPES
 extern int marker1 (void);
 extern int marker2 (int a);
 extern void marker3 (char *a, char *b);
 extern void marker4 (long d);
-#else
-extern int marker1 ();
-extern int marker2 ();
-extern void marker3 ();
-extern void marker4 ();
-#endif
 
 /*
  *	This simple classical example of recursion is useful for
  *	testing stack backtraces and such.
  */
 
-#ifdef PROTOTYPES
 int factorial(int);
 
 int
 main (int argc, char **argv, char **envp)
-#else
-int
-main (argc, argv, envp)
-int argc;
-char *argv[], **envp;
-#endif
 {
     if (argc == 12345) {  /* an unlikely value < 2^16, in case uninited */ /* set breakpoint 6 here */
 	fprintf (stderr, "usage:  factorial <number>\n");
@@ -65,12 +51,7 @@ char *argv[], **envp;
     return argc;  /* set breakpoint 10 here */
 } /* set breakpoint 10a here */
 
-#ifdef PROTOTYPES
 int factorial (int value)
-#else
-int factorial (value)
-int value;
-#endif
 {
   if (value > 1) {  /* set breakpoint 7 here */
 	value *= factorial (value - 1);
@@ -78,12 +59,7 @@ int value;
     return (value); /* set breakpoint 19 here */
 }
 
-#ifdef PROTOTYPES
 int multi_line_if_conditional (int a, int b, int c)
-#else
-int multi_line_if_conditional (a, b, c)
-  int a, b, c;
-#endif
 {
   if (a    /* set breakpoint 3 here */
       && b
@@ -93,12 +69,7 @@ int multi_line_if_conditional (a, b, c)
     return 1;
 }
 
-#ifdef PROTOTYPES
 int multi_line_while_conditional (int a, int b, int c)
-#else
-int multi_line_while_conditional (a, b, c)
-  int a, b, c;
-#endif
 {
   while (a /* set breakpoint 4 here */
       && b
diff --git a/gdb/testsuite/gdb.reverse/ur1.c b/gdb/testsuite/gdb.reverse/ur1.c
index b07e211..3147646 100644
--- a/gdb/testsuite/gdb.reverse/ur1.c
+++ b/gdb/testsuite/gdb.reverse/ur1.c
@@ -26,17 +26,10 @@
    These functions are in a separate source file to prevent an
    optimizing compiler from inlining them and optimizing them away. */
 
-#ifdef PROTOTYPES
 int marker1 (void) { return (0); }	/* set breakpoint 15 here */
 int marker2 (int a) { return (1); }	/* set breakpoint 8 here */
 void marker3 (char *a, char *b) {}	/* set breakpoint 17 here */
 void marker4 (long d) {}		/* set breakpoint 14 here */
-#else
-int marker1 () { return (0); }		/* set breakpoint 16 here */
-int marker2 (a) int a; { return (1); }	/* set breakpoint 9 here */
-void marker3 (a, b) char *a, *b; {}	/* set breakpoint 18 here */
-void marker4 (d) long d; {}		/* set breakpoint 13 here */
-#endif
 
 /* A structure we use for field name completion tests.  */
 struct some_struct
diff --git a/gdb/testsuite/gdb.reverse/watch-reverse.c b/gdb/testsuite/gdb.reverse/watch-reverse.c
index 7244793..2f7b180 100644
--- a/gdb/testsuite/gdb.reverse/watch-reverse.c
+++ b/gdb/testsuite/gdb.reverse/watch-reverse.c
@@ -78,11 +78,7 @@ void marker6 ()
 {
 }
 
-#ifdef PROTOTYPES
 void recurser (int  x)
-#else
-void recurser (x) int  x;
-#endif
 {
   int  local_x;
 
