renamed to have names 14 characters long or shorter.

4 files changed, 0 insertions, 2246 deletions

diff --git a/gdb/testsuite/gdb.base/call-array-struct.c b/gdb/testsuite/gdb.base/call-array-struct.c
deleted file mode 100644
index da5015b..0000000
--- a/gdb/testsuite/gdb.base/call-array-struct.c
+++ /dev/null
@@ -1,1137 +0,0 @@
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <strings.h>
-
-/**************************************************************************
- * TESTS :
- *   -- function arguments that are enumerated types
- *   -- small structure arguments ( <= 64 bits ) 
- *            -- stored in registers
- *            -- stored on the stack
- *   -- large structure arguments ( > 64 bits )
- *            -- stored in registers
- *            -- stored on the stack
- *   -- array arguments
- *   -- caller is a leaf routine :
- *            -- use the call command from within an init routine (i.e.
- *               init_bit_flags, init_bit_flags_combo, init_array_rep)
- *   -- caller doesn't have enough space for all the function arguments :
- *            -- call print_long_arg_list from inside print_small_structs
- ***************************************************************************/
-
-/* Some enumerated types -- used to test that the structureal data type is
- * retrieved for function arguments with typedef data types.
- */
-typedef int id_int;
-
-typedef enum { 
-	      BLACK,
-	      BLUE,
-	      BROWN,
-	      ECRUE,
-	      GOLD,
-	      GRAY,
-	      GREEN,
-	      IVORY,
-	      MAUVE,
-	      ORANGE,
-	      PINK,
-	      PURPLE,
-	      RED,
-	      SILVER,
-	      TAN,
-	      VIOLET,
-	      WHITE,
-	      YELLOW} colors;
-
-/* A large structure (> 64 bits) used to test passing large structures as
- * parameters
- */
-
-struct array_rep_info_t {
-   int   next_index[10]; 
-   int   values[10];
-   int   head;
-};
-
-/*****************************************************************************
- * Small structures ( <= 64 bits). These are used to test passing small 
- * structures as parameters and test argument size promotion.
- *****************************************************************************/
-
- /* 64 bits
-  */
-struct small_rep_info_t {
-   int   value;
-   int   head;
-};
-
-/* 6 bits : really fits in 8 bits and is promoted to 32 bits
- */
-struct bit_flags_t {
-       unsigned alpha   :1;
-       unsigned beta    :1;
-       unsigned gamma   :1;
-       unsigned delta   :1;
-       unsigned epsilon :1;
-       unsigned omega   :1;
-};
-
-/* 22 bits : really fits in 40 bits and is promoted to 64 bits
- */
-struct bit_flags_combo_t {
-       unsigned alpha   :1;
-       unsigned beta    :1;
-       char     ch1;
-       unsigned gamma   :1;
-       unsigned delta   :1;
-       char     ch2;
-       unsigned epsilon :1;
-       unsigned omega   :1;
-};
-
-/* 64 bits
- */
-struct one_double_t {
-       double double1;
-};
-
-/* 64 bits
- */
-struct two_floats_t {
-       float float1;
-       float float2;
-};
-
-/* 16 bits : promoted to 32 bits
- */
-struct two_char_t {
-       char ch1;
-       char ch2;
-};
-
-/* 24 bits : promoted to 32 bits
- */
-struct three_char_t {
-       char ch1;
-       char ch2;
-       char ch3;
-};
-
-/* 40 bits : promoted to 64 bits
- */
-struct five_char_t {
-       char ch1;
-       char ch2;
-       char ch3;
-       char ch4;
-       char ch5;
-};
-
-/* 40 bits : promoted to 64 bits
- */
-struct int_char_combo_t {
-       int  int1;
-       char ch1;
-};
-
-/*****************************************************************
- * PRINT_STUDENT_ID_SHIRT_COLOR : 
- * IN     id_int student       -- enumerated type
- * IN     colors shirt         -- enumerated type
- *****************************************************************/
-void print_student_id_shirt_color ( student, shirt ) 
- id_int student;
- colors shirt;
-{
-
- printf("student id : %d\t", student);
- printf("shirt color : ");
- switch (shirt) {
-   case BLACK :  printf("BLACK\n"); 
-		 break;
-   case BLUE :   printf("BLUE\n");
-		 break;
-   case BROWN :  printf("BROWN\n");
-		 break;
-   case ECRUE :  printf("ECRUE\n");
-		 break;
-   case GOLD :   printf("GOLD\n");
-		 break;
-   case GRAY :   printf("GRAY\n");
-		 break;
-   case GREEN :  printf("GREEN\n");
-		 break;
-   case IVORY :  printf("IVORY\n");
-		 break;
-   case MAUVE :  printf("MAUVE\n");
-		 break;
-   case ORANGE : printf("ORANGE\n");
-		 break;
-   case PINK :   printf("PINK\n");
-		 break;
-   case PURPLE : printf("PURPLE\n");
-		 break;
-   case RED :    printf("RED\n");
-		 break;
-   case SILVER : printf("SILVER\n");
-		 break;
-   case TAN :    printf("TAN\n");
-		 break;
-   case VIOLET : printf("VIOLET\n");
-		 break;
-   case WHITE :  printf("WHITE\n");
-		 break;
-   case YELLOW : printf("YELLOW\n");
-		 break;
- }
-}
-
-/*****************************************************************
- * PRINT_CHAR_ARRAY : 
- * IN     char  array_c[]      -- character array 
- *****************************************************************/
-void print_char_array ( array_c ) 
-     char    array_c[];
-
-{
-
-  int index;
-
-  printf("array_c :\n");
-  printf("=========\n\n");
-  for (index = 0; index < 120; index++) {
-      printf("%1c", array_c[index]); 
-      if ((index%50) == 0) printf("\n");
-  }
-  printf("\n\n");
-}
-
-/*****************************************************************
- * PRINT_DOUBLE_ARRAY : 
- * IN     double array_d[]      -- array of doubles
- *****************************************************************/
-void print_double_array (array_d) 
-     double  array_d[];
-
-{
-
-  int index;
-
-  printf("array_d :\n");
-  printf("=========\n\n");
-  for (index = 0; index < 100; index++) {
-      printf("%f  ", array_d[index]); 
-      if ((index%8) == 0) printf("\n");
-  }
-  printf("\n\n");
-}
-
-/*****************************************************************
- * PRINT_FLOAT_ARRAY: 
- * IN     float array_f[]      -- array of floats 
- *****************************************************************/
-void print_float_array ( array_f )
-     float array_f[];
-
-{
-
-  int index;
-
-  printf("array_f :\n");
-  printf("=========\n\n");
-  for (index = 0; index < 15; index++) {
-      printf("%f  ", array_f[index]); 
-      if ((index%8) == 0) printf("\n");
-
-  }
-  printf("\n\n");
-}
-
-/*****************************************************************
- * PRINT_INT_ARRAY: 
- * IN     int  array_i[]      -- array of integers 
- *****************************************************************/
-void print_int_array ( array_i )
-     int array_i[];
-
-{
-
-  int index;
-
-  printf("array_i :\n");
-  printf("=========\n\n");
-  for (index = 0; index < 50; index++) {
-      printf("%d  ", array_i[index]); 
-      if ((index%8) == 0) printf("\n");
-  }
-  printf("\n\n");
-
-}
-
-/*****************************************************************
- * PRINT_ALL_ARRAYS: 
- * IN     int  array_i[]      -- array of integers 
- * IN     char array_c[]      -- array of characters 
- * IN     float array_f[]      -- array of floats 
- * IN     double array_d[]      -- array of doubles 
- *****************************************************************/
-void print_all_arrays( array_i, array_c, array_f, array_d )
-     int array_i[];
-     char array_c[];
-     float array_f[];
-     double array_d[];
-
-{
-  print_int_array(array_i);
-  print_char_array(array_c);
-  print_float_array(array_f);
-  print_double_array(array_d);
-}
-
-/*****************************************************************
- * LOOP_COUNT : 
- * A do nothing function. Used to provide a point at which calls can be made.  
- *****************************************************************/
-void loop_count () {
-
-     int index;
-
-     for (index=0; index<4; index++);
-}
-
-/*****************************************************************
- * COMPUTE_WITH_SMALL_STRUCTS : 
- * A do nothing function. Used to provide a point at which calls can be made.  
- * IN  int seed
- *****************************************************************/
-void compute_with_small_structs ( seed ) 
- int seed;
-{
-
-     struct small_rep_info_t array[4];
-     int index;
-
-     for (index = 0; index < 4; index++) {
-         array[index].value = index*seed;
-	 array[index].head = (index+1)*seed;
-     }
-
-     for (index = 1; index < 4; index++) {
-	 array[index].value = array[index].value + array[index-1].value;
-	 array[index].head = array[index].head + array[index-1].head;
-     }
-}
-
-/*****************************************************************
- * INIT_BIT_FLAGS :
- * Initializes a bit_flags_t structure. Can call this function see
- * the call command behavior when integer arguments do not fit into
- * registers and must be placed on the stack.
- * OUT struct bit_flags_t *bit_flags -- structure to be filled
- * IN  unsigned a  -- 0 or 1 
- * IN  unsigned b  -- 0 or 1 
- * IN  unsigned g  -- 0 or 1 
- * IN  unsigned d  -- 0 or 1 
- * IN  unsigned e  -- 0 or 1 
- * IN  unsigned o  -- 0 or 1 
- *****************************************************************/
-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; 
-{
-
-   bit_flags->alpha = a;
-   bit_flags->beta = b;
-   bit_flags->gamma = g;
-   bit_flags->delta = d;
-   bit_flags->epsilon = e;
-   bit_flags->omega = o;
-}
-
-/*****************************************************************
- * INIT_BIT_FLAGS_COMBO :
- * Initializes a bit_flags_combo_t structure. Can call this function
- * to see the call command behavior when integer and character arguments
- * do not fit into registers and must be placed on the stack.
- * OUT struct bit_flags_combo_t *bit_flags_combo -- structure to fill
- * IN  unsigned a  -- 0 or 1 
- * IN  unsigned b  -- 0 or 1 
- * IN  char     ch1
- * IN  unsigned g  -- 0 or 1 
- * IN  unsigned d  -- 0 or 1 
- * IN  char     ch2
- * IN  unsigned e  -- 0 or 1 
- * IN  unsigned o  -- 0 or 1 
- *****************************************************************/
-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; 
-{
-
-   bit_flags_combo->alpha = a;
-   bit_flags_combo->beta = b;
-   bit_flags_combo->ch1 = ch1;
-   bit_flags_combo->gamma = g;
-   bit_flags_combo->delta = d;
-   bit_flags_combo->ch2 = ch2;
-   bit_flags_combo->epsilon = e;
-   bit_flags_combo->omega = o;
-}
-
-
-/*****************************************************************
- * INIT_ONE_DOUBLE : 
- * OUT  struct one_double_t *one_double  -- structure to fill 
- * IN   double init_val
- *****************************************************************/
-void init_one_double ( one_double, init_val )
-     struct one_double_t *one_double;
-     double init_val; 
-{
-
-     one_double->double1  = init_val;
-}
-
-/*****************************************************************
- * INIT_TWO_FLOATS : 
- * OUT struct two_floats_t *two_floats -- structure to be filled
- * IN  float init_val1 
- * IN  float init_val2 
- *****************************************************************/
-void init_two_floats ( two_floats, init_val1, init_val2 )
-     struct two_floats_t *two_floats; 
-     float init_val1;
-     float init_val2;
-{
-     two_floats->float1 = init_val1;
-     two_floats->float2 = init_val2;
-}
-
-/*****************************************************************
- * INIT_TWO_CHARS : 
- * OUT struct two_char_t *two_char -- structure to be filled
- * IN  char init_val1 
- * IN  char init_val2 
- *****************************************************************/
-void init_two_chars ( two_char, init_val1, init_val2 )
-     struct two_char_t *two_char;
-     char init_val1;
-     char init_val2; 
-{
-
-     two_char->ch1 = init_val1;
-     two_char->ch2 = init_val2;
-}
-
-/*****************************************************************
- * INIT_THREE_CHARS : 
- * OUT struct three_char_t *three_char -- structure to be filled
- * IN  char init_val1 
- * IN  char init_val2 
- * IN  char init_val3 
- *****************************************************************/
-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;
-{
-
-     three_char->ch1 = init_val1;
-     three_char->ch2 = init_val2;
-     three_char->ch3 = init_val3;
-}
-
-/*****************************************************************
- * INIT_FIVE_CHARS : 
- * OUT struct five_char_t *five_char -- structure to be filled
- * IN  char init_val1 
- * IN  char init_val2 
- * IN  char init_val3 
- * IN  char init_val4 
- * IN  char init_val5 
- *****************************************************************/
-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;
-{
-     five_char->ch1 = init_val1;
-     five_char->ch2 = init_val2;
-     five_char->ch3 = init_val3;
-     five_char->ch4 = init_val4;
-     five_char->ch5 = init_val5;
-}
-
-/*****************************************************************
- * INIT_INT_CHAR_COMBO : 
- * OUT struct int_char_combo_t *combo -- structure to be filled
- * IN  int  init_val1 
- * IN  char init_val2 
- *****************************************************************/
-void init_int_char_combo ( combo, init_val1, init_val2 )
-     struct int_char_combo_t *combo;
-     int init_val1; 
-     char init_val2; 
-{
-
-     combo->int1 = init_val1;
-     combo->ch1 = init_val2;
-}
-
-/*****************************************************************
- * INIT_STRUCT_REP : 
- * OUT struct small_rep_into_t *small_struct -- structure to be filled
- * IN  int  seed 
- *****************************************************************/
-void init_struct_rep( small_struct, seed )
-     struct small_rep_info_t *small_struct;
-     int    seed;
-
-{
-
-      small_struct->value = 2 + (seed*2); 
-      small_struct->head = 0; 
-}
-
-/*****************************************************************
- * INIT_SMALL_STRUCTS : 
- * Takes all the small structures as input and calls the appropriate
- * initialization routine for each structure
- *****************************************************************/
-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;
-
-{
-
-     init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, 
-		           (unsigned)0, (unsigned)1, (unsigned)0 ); 
-     init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y',
-				       (unsigned)1, (unsigned)0, 'n',
-                    		       (unsigned)1, (unsigned)0 ); 
-     init_three_chars(three_char, 'a', 'b', 'c');
-     init_five_chars(five_char, 'l', 'm', 'n', 'o', 'p');
-     init_int_char_combo(int_char_combo, 123, 'z');
-     init_struct_rep(struct1, 2);
-     init_struct_rep(struct2, 4);
-     init_struct_rep(struct3, 5);
-     init_struct_rep(struct4, 6);
-     init_one_double ( d1, 10.5); 
-     init_one_double ( d2, -3.34); 
-     init_one_double ( d3, 675.09123); 
-     init_two_floats ( f1, 45.234, 43.6); 
-     init_two_floats ( f2, 78.01, 122.10); 
-     init_two_floats ( f3, -1232.345, -199.21); 
-}
-
-/*****************************************************************
- * PRINT_TEN_DOUBLES : 
- * ?????????????????????????????
- ****************************************************************/
-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; 
-{
-
-  printf("Two Doubles : %f\t%f\n", d1, d2);
-  printf("Two Doubles : %f\t%f\n", d3, d4);
-  printf("Two Doubles : %f\t%f\n", d5, d6);
-  printf("Two Doubles : %f\t%f\n", d7, d8);
-  printf("Two Doubles : %f\t%f\n", d9, d10);
-}
-
-/*****************************************************************
- * PRINT_BIT_FLAGS : 
- * IN struct bit_flags_t bit_flags 
- ****************************************************************/
-void print_bit_flags ( bit_flags )
-struct bit_flags_t bit_flags;
-{
-
-     if (bit_flags.alpha) printf("alpha\n");
-     if (bit_flags.beta) printf("beta\n");
-     if (bit_flags.gamma) printf("gamma\n");
-     if (bit_flags.delta) printf("delta\n");
-     if (bit_flags.epsilon) printf("epsilon\n");
-     if (bit_flags.omega) printf("omega\n");
-}
-
-/*****************************************************************
- * PRINT_BIT_FLAGS_COMBO : 
- * IN struct bit_flags_combo_t bit_flags_combo 
- ****************************************************************/
-void print_bit_flags_combo ( bit_flags_combo )
-struct bit_flags_combo_t bit_flags_combo;
-{
-
-     if (bit_flags_combo.alpha) printf("alpha\n");
-     if (bit_flags_combo.beta) printf("beta\n");
-     if (bit_flags_combo.gamma) printf("gamma\n");
-     if (bit_flags_combo.delta) printf("delta\n");
-     if (bit_flags_combo.epsilon) printf("epsilon\n");
-     if (bit_flags_combo.omega) printf("omega\n");
-     printf("ch1: %c\tch2: %c\n", bit_flags_combo.ch1, bit_flags_combo.ch2);
-}
-
-/*****************************************************************
- * PRINT_ONE_DOUBLE : 
- * IN struct one_double_t one_double 
- ****************************************************************/
-void print_one_double ( one_double )
-struct one_double_t one_double;
-{
-
-     printf("Contents of one_double_t: \n\n");
-     printf("%f\n", one_double.double1);
-}
-
-/*****************************************************************
- * PRINT_TWO_FLOATS : 
- * IN struct two_floats_t two_floats 
- ****************************************************************/
-void print_two_floats ( two_floats )
-struct two_floats_t two_floats; 
-{
-
-     printf("Contents of two_floats_t: \n\n");
-     printf("%f\t%f\n", two_floats.float1, two_floats.float2);
-}
-
-/*****************************************************************
- * PRINT_TWO_CHARS : 
- * IN struct two_char_t two_char
- ****************************************************************/
-void print_two_chars ( two_char )
-struct two_char_t two_char; 
-{
-
-     printf("Contents of two_char_t: \n\n");
-     printf("%c\t%c\n", two_char.ch1, two_char.ch2);
-}
-
-/*****************************************************************
- * PRINT_THREE_CHARS : 
- * IN struct three_char_t three_char
- ****************************************************************/
-void print_three_chars ( three_char )
-struct three_char_t three_char;
-{
-
-     printf("Contents of three_char_t: \n\n");
-     printf("%c\t%c\t%c\n", three_char.ch1, three_char.ch2, three_char.ch3);
-}
-
-/*****************************************************************
- * PRINT_FIVE_CHARS : 
- * IN struct five_char_t five_char
- ****************************************************************/
-void print_five_chars ( five_char ) 
-struct five_char_t five_char; 
-{
-
-     printf("Contents of five_char_t: \n\n");
-     printf("%c\t%c\t%c\t%c\t%c\n", five_char.ch1, five_char.ch2, 
-				    five_char.ch3, five_char.ch4, 
-				    five_char.ch5);
-}
-
-/*****************************************************************
- * PRINT_INT_CHAR_COMBO : 
- * IN struct int_char_combo_t int_char_combo
- ****************************************************************/
-void print_int_char_combo ( int_char_combo )
-struct int_char_combo_t int_char_combo;
-{
-
-     printf("Contents of int_char_combo_t: \n\n");
-     printf("%d\t%c\n", int_char_combo.int1, int_char_combo.ch1);
-}     
-
-/*****************************************************************
- * PRINT_STRUCT_REP : 
- * The last parameter must go onto the stack rather than into a register.
- * This is a good function to call to test small structures.
- * IN struct small_rep_info_t  struct1
- * IN struct small_rep_info_t  struct2
- * IN struct small_rep_info_t  struct3
- ****************************************************************/
-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;
-
-{
-
-
-  printf("Contents of struct1: \n\n");
-  printf("%10d%10d\n", struct1.value, struct1.head); 
-  printf("Contents of struct2: \n\n");
-  printf("%10d%10d\n", struct2.value, struct2.head); 
-  printf("Contents of struct3: \n\n");
-  printf("%10d%10d\n", struct3.value, struct3.head); 
-
-}
-
-/*****************************************************************
- * SUM_STRUCT_PRINT : 
- * The last two parameters must go onto the stack rather than into a register.
- * This is a good function to call to test small structures.
- * IN struct small_rep_info_t  struct1
- * IN struct small_rep_info_t  struct2
- * IN struct small_rep_info_t  struct3
- * IN struct small_rep_info_t  struct4
- ****************************************************************/
-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; 
-
-{
-     int sum;
-
-     printf("Sum of the 4 struct values and seed : \n\n");
-     sum = seed + struct1.value + struct2.value + struct3.value + struct4.value;
-     printf("%10d\n", sum);
-}
-
-/*****************************************************************
- * PRINT_SMALL_STRUCTS : 
- * This is a good function to call to test small structures.
- * All of the small structures of odd sizes (40 bits, 8bits, etc.)
- * are pushed onto the stack.
- ****************************************************************/
-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;
-{
-   print_bit_flags(flags);
-   print_bit_flags_combo(flags_combo);
-   print_three_chars(three_char);
-   print_five_chars(five_char);
-   print_int_char_combo(int_char_combo);
-   sum_struct_print(10, struct1, struct2, struct3, struct4);
-   print_struct_rep(struct1, struct2, struct3);
-   print_one_double(d1);
-   print_one_double(d2);
-   print_one_double(d3);
-   print_two_floats(f1);
-   print_two_floats(f2);
-   print_two_floats(f3);
-}
-
-/*****************************************************************
- * PRINT_LONG_ARG_LIST : 
- * This is a good function to call to test small structures.
- * The first two parameters ( the doubles ) go into registers. The
- * remaining arguments are pushed onto the stack. Depending on where
- * print_long_arg_list is called from, the size of the argument list 
- * may force more space to be pushed onto the stack as part of the callers
- * frame.
- ****************************************************************/
-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;
-
-{
-    printf("double : %f\n", a);
-    printf("double : %f\n", b);
-    printf("int : %d\n", c);
-    printf("int : %d\n", d);
-    printf("int : %d\n", e);
-    printf("int : %d\n", f);
-    print_small_structs( struct1, struct2, struct3, struct4, flags, flags_combo,
-			 three_char, five_char, int_char_combo, d1, d2, d3, 
-			 f1, f2, f3);
-}
-
-
-void print_one_large_struct( linked_list1 )
-     struct array_rep_info_t linked_list1;
-
-{
-
- /* printf("Contents of linked list1: \n\n");
-  printf("Element Value | Index of Next Element\n");
-  printf("-------------------------------------\n");
-  printf("              |                      \n");*/
-  /*for (index = 0; index < 10; index++) {*/
-
-      printf("%10d%10d\n", linked_list1.values[0], 
-			   linked_list1.next_index[0]); 
-  /*}*/
-}
-
-/*****************************************************************
- * PRINT_ARRAY_REP : 
- * The three structure parameters should fit into registers. 
- * IN struct array_rep_info_t linked_list1
- * IN struct array_rep_info_t linked_list2
- * IN struct array_rep_info_t linked_list3
- ****************************************************************/
-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;
-
-{
-
-  int index;
-
-  printf("Contents of linked list1: \n\n");
-  printf("Element Value | Index of Next Element\n");
-  printf("-------------------------------------\n");
-  printf("              |                      \n");
-  for (index = 0; index < 10; index++) {
-
-      printf("%10d%10d\n", linked_list1.values[index], 
-			   linked_list1.next_index[index]); 
-  }
-
-  printf("Contents of linked list2: \n\n");
-  printf("Element Value | Index of Next Element\n");
-  printf("-------------------------------------\n");
-  printf("              |                      \n");
-  for (index = 0; index < 10; index++) {
-
-      printf("%10d%10d\n", linked_list2.values[index], 
-			   linked_list2.next_index[index]); 
-  }
-
-  printf("Contents of linked list3: \n\n");
-  printf("Element Value | Index of Next Element\n");
-  printf("-------------------------------------\n");
-  printf("              |                      \n");
-  for (index = 0; index < 10; index++) {
-
-      printf("%10d%10d\n", linked_list3.values[index], 
-			   linked_list3.next_index[index]); 
-  }
-
-}
-
-/*****************************************************************
- * SUM_ARRAY_PRINT : 
- * The last structure parameter must be pushed onto the stack 
- * IN int    seed
- * IN struct array_rep_info_t linked_list1
- * IN struct array_rep_info_t linked_list2
- * IN struct array_rep_info_t linked_list3
- * IN struct array_rep_info_t linked_list4
- ****************************************************************/
-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;
-
-{
-     int index;
-     int sum;
-
-     printf("Sum of 4 arrays, by element (add in seed as well): \n\n");
-     printf("Seed: %d\n", seed);
-     printf("Element Index | Sum \n");
-     printf("-------------------------\n");
-     printf("              |          \n");
-
-     for (index = 0; index < 10; index++) {
-
-         sum = seed + linked_list1.values[index] + linked_list2.values[index] +
-	       linked_list3.values[index] + linked_list4.values[index];
-         printf("%10d%10d\n", index, sum);
-     }
-}
-
-/*****************************************************************
- * INIT_ARRAY_REP : 
- * IN struct array_rep_info_t *linked_list
- * IN int    seed
- ****************************************************************/
-void init_array_rep( linked_list, seed )
-     struct array_rep_info_t *linked_list;
-     int    seed;
-
-{
-
-  int index;
-
-  for (index = 0; index < 10; index++) {
-
-      linked_list->values[index] = (2*index) + (seed*2); 
-      linked_list->next_index[index] = index + 1;
-  }
-  linked_list->head = 0; 
-}
-
-
-int main ()  {
-
-  /* variables for array and enumerated type testing
-   */
-  char     char_array[120];
-  double   double_array[100];
-  float    float_array[15];
-  int      integer_array[50]; 
-  int      index;
-  id_int   student_id = 23;
-  colors   my_shirt = YELLOW;
-    
-  /* variables for large structure testing
-   */
-  int number = 10;
-  struct array_rep_info_t *list1;
-  struct array_rep_info_t *list2;
-  struct array_rep_info_t *list3;
-  struct array_rep_info_t *list4;
-
-  /* variables for testing a very long argument list
-   */
-   double                    a;
-   double                    b;
-   int                       c;
-   int                       d;
-   int                       e;
-   int                       f;
-
-  /* variables for testing a small structures and a very long argument list
-   */
-   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;
-
-  /* Initialize arrays
-   */
-  for (index = 0; index < 120; index++) {
-      if ((index%2) == 0) char_array[index] = 'Z';
-	 else char_array[index] = 'a';
-  }
-
-  for (index = 0; index < 100; index++) {
-      double_array[index] = index*23.4567;
-  }
-
-  for (index = 0; index < 15; index++) {
-      float_array[index] = index/7.02;
-  }
-
-  for (index = 0; index < 50; index++) {
-      integer_array[index] = -index;
-  }
-
-  /* Print arrays
-   */
-  print_char_array(char_array);
-  print_double_array(double_array);
-  print_float_array(float_array);
-  print_student_id_shirt_color(student_id, my_shirt); 
-  print_int_array(integer_array);
-  print_all_arrays(integer_array, char_array, float_array, double_array);
-
-  /* Allocate space for large structures 
-   */
-  list1 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
-  list2 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
-  list3 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
-  list4 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
-
-  /* Initialize large structures 
-   */
-  init_array_rep(list1, 2);
-  init_array_rep(list2, 4);
-  init_array_rep(list3, 5);
-  init_array_rep(list4, 10);
-  printf("HELLO WORLD\n");
-  printf("BYE BYE FOR NOW\n");
-  printf("VERY GREEN GRASS\n");
-
-  /* Print large structures 
-   */
-  sum_array_print(10, *list1, *list2, *list3, *list4);
-  print_array_rep(*list1, *list2, *list3);
-  print_one_large_struct(*list1);
-
-  /* Allocate space for small structures 
-   */
-  struct1     = (struct small_rep_info_t  *)malloc(sizeof(struct small_rep_info_t));
-  struct2     = (struct small_rep_info_t  *)malloc(sizeof(struct small_rep_info_t));
-  struct3     = (struct small_rep_info_t  *)malloc(sizeof(struct small_rep_info_t));
-  struct4     = (struct small_rep_info_t  *)malloc(sizeof(struct small_rep_info_t));
-  flags       = (struct bit_flags_t *)malloc(sizeof(struct bit_flags_t));
-  flags_combo = (struct bit_flags_combo_t *)malloc(sizeof(struct bit_flags_combo_t));
-  three_char  = (struct three_char_t *)malloc(sizeof(struct three_char_t));
-  five_char   = (struct five_char_t *)malloc(sizeof(struct five_char_t));
-  int_char_combo = (struct int_char_combo_t *)malloc(sizeof(struct int_char_combo_t));
-
-  d1 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
-  d2 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
-  d3 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
-
-  f1 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
-  f2 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
-  f3 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
-
-  /* Initialize small structures 
-   */
-  init_small_structs ( struct1, struct2, struct3, struct4, flags, 
-		       flags_combo, three_char, five_char, int_char_combo,
-		       d1, d2, d3, f1, f2, f3);
-
-  /* Print small structures 
-   */
-  print_small_structs ( *struct1, *struct2, *struct3, *struct4, *flags, 
-			*flags_combo, *three_char, *five_char, *int_char_combo,
-			*d1, *d2, *d3, *f1, *f2, *f3);
-
-  /* Print a very long arg list 
-   */
-  a = 22.22;
-  b = 33.333;
-  c = 0;
-  d = -25;
-  e = 100;
-  f = 2345;
-
-  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);
-
-  /* Initialize small structures 
-   */
-  init_one_double ( d1, 1.11111); 
-  init_one_double ( d2, -345.34); 
-  init_one_double ( d3, 546464.2); 
-  init_two_floats ( f1, 0.234, 453.1); 
-  init_two_floats ( f2, 78.345, 23.09); 
-  init_two_floats ( f3, -2.345, 1.0); 
-  init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, 
-		 (unsigned)0, (unsigned)1, (unsigned)0 ); 
-  init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y',
-				     (unsigned)1, (unsigned)0, 'n',
-				     (unsigned)1, (unsigned)0 ); 
-  init_three_chars(three_char, 'x', 'y', 'z');
-  init_five_chars(five_char, 'h', 'e', 'l', 'l', 'o');
-  init_int_char_combo(int_char_combo, 13, '!');
-  init_struct_rep(struct1, 10);
-  init_struct_rep(struct2, 20);
-  init_struct_rep(struct3, 30);
-  init_struct_rep(struct4, 40);
-
-  compute_with_small_structs(35);
-  loop_count();
-  printf("HELLO WORLD\n");
-  printf("BYE BYE FOR NOW\n");
-  printf("VERY GREEN GRASS\n");
-
-  /* Print small structures 
-   */
-  print_one_double(*d1);
-  print_one_double(*d2);
-  print_one_double(*d3);
-  print_two_floats(*f1);
-  print_two_floats(*f2);
-  print_two_floats(*f3);
-  print_bit_flags(*flags);
-  print_bit_flags_combo(*flags_combo);
-  print_three_chars(*three_char);
-  print_five_chars(*five_char);
-  print_int_char_combo(*int_char_combo);
-  sum_struct_print(10, *struct1, *struct2, *struct3, *struct4);
-  print_struct_rep(*struct1, *struct2, *struct3);
-
-  return 0;
-}
-
-
-
-
-
diff --git a/gdb/testsuite/gdb.base/call-return-struct.c b/gdb/testsuite/gdb.base/call-return-struct.c
deleted file mode 100644
index c89cb11..0000000
--- a/gdb/testsuite/gdb.base/call-return-struct.c
+++ /dev/null
@@ -1,530 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <strings.h>
-
-/**************************************************************************
- * TESTS :
- * function returning large structures, which go on the stack
- * functions returning varied sized structs which go on in the registers.
- ***************************************************************************/
-
-
-/* A large structure (> 64 bits) used to test passing large structures as
- * parameters
- */
-
-struct array_rep_info_t {
-   int   next_index[10]; 
-   int   values[10];
-   int   head;
-};
-
-/*****************************************************************************
- * Small structures ( <= 64 bits). These are used to test passing small 
- * structures as parameters and test argument size promotion.
- *****************************************************************************/
-
- /* 64 bits
-  */
-struct small_rep_info_t {
-   int   value;
-   int   head;
-};
-
-/* 6 bits : really fits in 8 bits and is promoted to 32 bits
- */
-struct bit_flags_t {
-       unsigned alpha   :1;
-       unsigned beta    :1;
-       unsigned gamma   :1;
-       unsigned delta   :1;
-       unsigned epsilon :1;
-       unsigned omega   :1;
-};
-
-/* 22 bits : really fits in 40 bits and is promoted to 64 bits
- */
-struct bit_flags_combo_t {
-       unsigned alpha   :1;
-       unsigned beta    :1;
-       char     ch1;
-       unsigned gamma   :1;
-       unsigned delta   :1;
-       char     ch2;
-       unsigned epsilon :1;
-       unsigned omega   :1;
-};
-
-/* 64 bits
- */
-struct one_double_t {
-       double double1;
-};
-
-/* 64 bits
- */
-struct two_floats_t {
-       float float1;
-       float float2;
-};
-
-
-/* 24 bits : promoted to 32 bits
- */
-struct three_char_t {
-       char ch1;
-       char ch2;
-       char ch3;
-};
-
-/* 40 bits : promoted to 64 bits
- */
-struct five_char_t {
-       char ch1;
-       char ch2;
-       char ch3;
-       char ch4;
-       char ch5;
-};
-
-/* 40 bits : promoted to 64 bits
- */
-struct int_char_combo_t {
-       int  int1;
-       char ch1;
-};
-
-
-/*****************************************************************
- * LOOP_COUNT : 
- * A do nothing function. Used to provide a point at which calls can be made.  
- *****************************************************************/
-void loop_count () {
-
-     int index;
-
-     for (index=0; index<4; index++);
-}
-
-/*****************************************************************
- * INIT_BIT_FLAGS :
- * Initializes a bit_flags_t structure. Can call this function see
- * the call command behavior when integer arguments do not fit into
- * registers and must be placed on the stack.
- * OUT struct bit_flags_t *bit_flags -- structure to be filled
- * IN  unsigned a  -- 0 or 1 
- * IN  unsigned b  -- 0 or 1 
- * IN  unsigned g  -- 0 or 1 
- * IN  unsigned d  -- 0 or 1 
- * IN  unsigned e  -- 0 or 1 
- * IN  unsigned o  -- 0 or 1 
- *****************************************************************/
-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; 
-{
-
-   bit_flags->alpha = a;
-   bit_flags->beta = b;
-   bit_flags->gamma = g;
-   bit_flags->delta = d;
-   bit_flags->epsilon = e;
-   bit_flags->omega = o;
-}
-
-/*****************************************************************
- * INIT_BIT_FLAGS_COMBO :
- * Initializes a bit_flags_combo_t structure. Can call this function
- * to see the call command behavior when integer and character arguments
- * do not fit into registers and must be placed on the stack.
- * OUT struct bit_flags_combo_t *bit_flags_combo -- structure to fill
- * IN  unsigned a  -- 0 or 1 
- * IN  unsigned b  -- 0 or 1 
- * IN  char     ch1
- * IN  unsigned g  -- 0 or 1 
- * IN  unsigned d  -- 0 or 1 
- * IN  char     ch2
- * IN  unsigned e  -- 0 or 1 
- * IN  unsigned o  -- 0 or 1 
- *****************************************************************/
-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;
-{
-
-   bit_flags_combo->alpha = a;
-   bit_flags_combo->beta = b;
-   bit_flags_combo->ch1 = ch1;
-   bit_flags_combo->gamma = g;
-   bit_flags_combo->delta = d;
-   bit_flags_combo->ch2 = ch2;
-   bit_flags_combo->epsilon = e;
-   bit_flags_combo->omega = o;
-}
-
-
-/*****************************************************************
- * INIT_ONE_DOUBLE : 
- * OUT  struct one_double_t *one_double  -- structure to fill 
- * IN   double init_val
- *****************************************************************/
-void init_one_double (one_double, init_val)
-struct one_double_t *one_double; 
-double init_val;
-{
-
-     one_double->double1  = init_val;
-}
-
-/*****************************************************************
- * INIT_TWO_FLOATS : 
- * OUT struct two_floats_t *two_floats -- structure to be filled
- * IN  float init_val1 
- * IN  float init_val2 
- *****************************************************************/
-void init_two_floats (two_floats, init_val1, init_val2)
-struct two_floats_t *two_floats;
-float init_val1;
-float init_val2;
-{
-
-     two_floats->float1 = init_val1;
-     two_floats->float2 = init_val2;
-}
-
-/*****************************************************************
- * INIT_THREE_CHARS : 
- * OUT struct three_char_t *three_char -- structure to be filled
- * IN  char init_val1 
- * IN  char init_val2 
- * IN  char init_val3 
- *****************************************************************/
-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;
-{
-
-     three_char->ch1 = init_val1;
-     three_char->ch2 = init_val2;
-     three_char->ch3 = init_val3;
-}
-
-/*****************************************************************
- * INIT_FIVE_CHARS : 
- * OUT struct five_char_t *five_char -- structure to be filled
- * IN  char init_val1 
- * IN  char init_val2 
- * IN  char init_val3 
- * IN  char init_val4 
- * IN  char init_val5 
- *****************************************************************/
-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;
-{
-
-     five_char->ch1 = init_val1;
-     five_char->ch2 = init_val2;
-     five_char->ch3 = init_val3;
-     five_char->ch4 = init_val4;
-     five_char->ch5 = init_val5;
-}
-
-/*****************************************************************
- * INIT_INT_CHAR_COMBO : 
- * OUT struct int_char_combo_t *combo -- structure to be filled
- * IN  int  init_val1 
- * IN  char init_val2 
- *****************************************************************/
-void init_int_char_combo ( combo, init_val1, init_val2)
-struct int_char_combo_t *combo;
-int init_val1;
-char init_val2;
-{
-
-     combo->int1 = init_val1;
-     combo->ch1 = init_val2;
-}
-
-/*****************************************************************
- * INIT_STRUCT_REP : 
- * OUT struct small_rep_into_t *small_struct -- structure to be filled
- * IN  int  seed 
- *****************************************************************/
-void init_struct_rep( small_struct, seed)
-struct small_rep_info_t *small_struct;
-int    seed;
-
-{
-
-      small_struct->value = 2 + (seed*2); 
-      small_struct->head = 0; 
-}
-
-/*****************************************************************
- * PRINT_BIT_FLAGS : 
- * IN struct bit_flags_t bit_flags 
- ****************************************************************/
-struct bit_flags_t print_bit_flags ( bit_flags)
-struct bit_flags_t bit_flags;
-{
-
-     if (bit_flags.alpha) printf("alpha\n");
-     if (bit_flags.beta) printf("beta\n");
-     if (bit_flags.gamma) printf("gamma\n");
-     if (bit_flags.delta) printf("delta\n");
-     if (bit_flags.epsilon) printf("epsilon\n");
-     if (bit_flags.omega) printf("omega\n");
-     return bit_flags;
-     
-}
-
-/*****************************************************************
- * PRINT_BIT_FLAGS_COMBO : 
- * IN struct bit_flags_combo_t bit_flags_combo 
- ****************************************************************/
-struct bit_flags_combo_t print_bit_flags_combo ( bit_flags_combo )
-struct bit_flags_combo_t bit_flags_combo;
-{
-
-     if (bit_flags_combo.alpha) printf("alpha\n");
-     if (bit_flags_combo.beta) printf("beta\n");
-     if (bit_flags_combo.gamma) printf("gamma\n");
-     if (bit_flags_combo.delta) printf("delta\n");
-     if (bit_flags_combo.epsilon) printf("epsilon\n");
-     if (bit_flags_combo.omega) printf("omega\n");
-     printf("ch1: %c\tch2: %c\n", bit_flags_combo.ch1, bit_flags_combo.ch2);
-     return bit_flags_combo;
-     
-}
-
-/*****************************************************************
- * PRINT_ONE_DOUBLE : 
- * IN struct one_double_t one_double 
- ****************************************************************/
-struct one_double_t print_one_double ( one_double )
-struct one_double_t one_double;
-{
-
-     printf("Contents of one_double_t: \n\n");
-     printf("%f\n", one_double.double1);
-     return one_double;
-     
-}
-
-/*****************************************************************
- * PRINT_TWO_FLOATS : 
- * IN struct two_floats_t two_floats 
- ****************************************************************/
-struct two_floats_t print_two_floats ( two_floats ) 
-struct two_floats_t two_floats;
-{
-
-     printf("Contents of two_floats_t: \n\n");
-     printf("%f\t%f\n", two_floats.float1, two_floats.float2);
-     return two_floats;
-     
-}
-
-/*****************************************************************
- * PRINT_THREE_CHARS : 
- * IN struct three_char_t three_char
- ****************************************************************/
-struct three_char_t print_three_chars ( three_char ) 
-struct three_char_t three_char;
-{
-
-     printf("Contents of three_char_t: \n\n");
-     printf("%c\t%c\t%c\n", three_char.ch1, three_char.ch2, three_char.ch3);
-     return three_char;
-     
-}
-
-/*****************************************************************
- * PRINT_FIVE_CHARS : 
- * IN struct five_char_t five_char
- ****************************************************************/
-struct five_char_t print_five_chars ( five_char )
-struct five_char_t five_char;
-{
-
-     printf("Contents of five_char_t: \n\n");
-     printf("%c\t%c\t%c\t%c\t%c\n", five_char.ch1, five_char.ch2, 
-				    five_char.ch3, five_char.ch4, 
-				    five_char.ch5);
-     return five_char;
-     
-}
-
-/*****************************************************************
- * PRINT_INT_CHAR_COMBO : 
- * IN struct int_char_combo_t int_char_combo
- ****************************************************************/
-struct int_char_combo_t print_int_char_combo ( int_char_combo )
-struct int_char_combo_t int_char_combo;
-{
-
-     printf("Contents of int_char_combo_t: \n\n");
-     printf("%d\t%c\n", int_char_combo.int1, int_char_combo.ch1);
-     return int_char_combo;
-     
-}     
-
-/*****************************************************************
- * PRINT_STRUCT_REP : 
- ****************************************************************/
-struct small_rep_info_t print_struct_rep( struct1 )
-struct small_rep_info_t struct1;
-
-{
-
-  printf("Contents of struct1: \n\n");
-  printf("%10d%10d\n", struct1.value, struct1.head); 
-  struct1.value =+5;
-  
-  return struct1;
-  
-
-}
-
-
-struct array_rep_info_t print_one_large_struct( linked_list1 )
-struct array_rep_info_t linked_list1;
-{
-
-
-      printf("%10d%10d\n", linked_list1.values[0], 
-			   linked_list1.next_index[0]); 
- 
-      return linked_list1;
-      
-}
-
-/*****************************************************************
- * INIT_ARRAY_REP :
- * IN struct array_rep_info_t *linked_list
- * IN int    seed
- ****************************************************************/
-void init_array_rep( linked_list, seed )
-struct array_rep_info_t *linked_list;
-int    seed;
-
-{
-
-  int index;
-
-  for (index = 0; index < 10; index++) {
-
-      linked_list->values[index] = (2*index) + (seed*2);
-      linked_list->next_index[index] = index + 1;
-  }
-  linked_list->head = 0;
-}
-
-
-int main ()  {
-   
-  /* variables for large structure testing
-   */
-  int number = 10;
-  struct array_rep_info_t *list1;
-
-  /* variables for testing a small structures and a very long argument list
-   */
-   struct small_rep_info_t  *struct1;
-   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 two_floats_t      *f3;
-
-
-  /* Allocate space for large structures 
-   */
-  list1 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
-
-  /* Initialize large structures 
-   */
-  init_array_rep(list1, 2);
-
-  /* Print large structures 
-   */
-  print_one_large_struct(*list1);
-
-  /* Allocate space for small structures 
-   */
-  struct1     = (struct small_rep_info_t  *)malloc(sizeof(struct small_rep_info_t));
-  flags       = (struct bit_flags_t *)malloc(sizeof(struct bit_flags_t));
-  flags_combo = (struct bit_flags_combo_t *)malloc(sizeof(struct bit_flags_combo_t));
-  three_char  = (struct three_char_t *)malloc(sizeof(struct three_char_t));
-  five_char   = (struct five_char_t *)malloc(sizeof(struct five_char_t));
-  int_char_combo = (struct int_char_combo_t *)malloc(sizeof(struct int_char_combo_t));
-
-  d1 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
-  f3 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
-
-  /* Initialize small structures 
-   */
-  init_one_double ( d1, 1.11111); 
-  init_two_floats ( f3, -2.345, 1.0); 
-  init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1, 
-		 (unsigned)0, (unsigned)1, (unsigned)0 ); 
-  init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y',
-				     (unsigned)1, (unsigned)0, 'n',
-				     (unsigned)1, (unsigned)0 ); 
-  init_three_chars(three_char, 'x', 'y', 'z');
-  init_five_chars(five_char, 'h', 'e', 'l', 'l', 'o');
-  init_int_char_combo(int_char_combo, 13, '!');
-  init_struct_rep(struct1, 10);
- 
- 
-  /* Print small structures 
-   */
-  print_one_double(*d1);
-  print_two_floats(*f3);
-  print_bit_flags(*flags);
-  print_bit_flags_combo(*flags_combo);
-  print_three_chars(*three_char);
-  print_five_chars(*five_char);
-  print_int_char_combo(*int_char_combo);
-  print_struct_rep(*struct1);
-
-  loop_count();
-
-  return 0;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/gdb/testsuite/gdb.base/call-strings.c b/gdb/testsuite/gdb.base/call-strings.c
deleted file mode 100644
index 9ba875b..0000000
--- a/gdb/testsuite/gdb.base/call-strings.c
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <stdio.h>
-char buf[100];
-char bigbuf[1000];
-char * s;
-
-char * str_func1(s1)
-char *s1;
-{
-  printf("first string arg is: %s\n", s1);
-  strcpy(bigbuf, s1);
-  return bigbuf;
-}
-
-char * str_func(s1, 
-                s2,
-               s3,
-               s4,
-               s5,
-               s6,
-               s7)
-char * s1; 
-char * s2;
-char * s3;
-char * s4;
-char * s5;
-char * s6;
-char * s7;
-{
-  printf("first string arg is: %s\n", s1);
-  printf("second string arg is: %s\n", s2);
-  printf("third string arg is: %s\n", s3);
-  printf("fourth string arg is: %s\n", s4);
-  printf("fifth string arg is: %s\n", s5);
-  printf("sixth string arg is: %s\n", s6);
-  printf("seventh string arg is: %s\n", s7);
-  strcpy(bigbuf, s1);
-  strcat(bigbuf, s2);
-  strcat(bigbuf, s3);
-  strcat(bigbuf, s4);
-  strcat(bigbuf, s5);
-  strcat(bigbuf, s6);
-  strcat(bigbuf, s7);
-  return bigbuf;
-}
-
-
-main()
-{
-  s = &buf[0];
-  strcpy(buf, "test string");
-  str_func("abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx", "yz12");
-  str_func1("abcd");
-}
-
diff --git a/gdb/testsuite/gdb.base/enable-disable-break.exp b/gdb/testsuite/gdb.base/enable-disable-break.exp
deleted file mode 100644
index 6593d82..0000000
--- a/gdb/testsuite/gdb.base/enable-disable-break.exp
+++ /dev/null
@@ -1,525 +0,0 @@
-#   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
-
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-# Please email any bugs, comments, and/or additions to this file to:
-# bug-gdb@prep.ai.mit.edu
-
-if $tracelevel then {
-	strace $tracelevel
-	}
-
-global usestubs
-
-#
-# test running programs
-#
-set prms_id 0
-set bug_id 0
-
-set testfile "break"
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
-
-if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
-     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
-}
-
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
-
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
-
-# Verify that we can set a breakpoint (the location is irrelevant),
-# then enable it (yes, it's already enabled by default), then hit it.
-#
-send_gdb "break marker1\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 41.*$gdb_prompt $"\
-          {pass "break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "break marker1"}
-  timeout {fail "(timeout) break marker1"}
-}
-
-send_gdb "enable $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "enable break marker1"}
-  timeout {fail "(timeout) enable break marker1"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+keep\[ \t\]+y.*$gdb_prompt $"\
-          {pass "info break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "info break marker1"}
-  timeout {fail "(timeout) info break marker1"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re "Breakpoint \[0-9\]*, marker1.*$gdb_prompt $"\
-          {pass "continue to break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "continue to break marker1"}
-  timeout {fail "(timeout) continue to break marker1"}
-}
-
-send_gdb "delete $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "delete break marker1"}
-  timeout {fail "(timeout) delete break marker1"}
-}
-
-# Verify that we can set a breakpoint to be self-disabling after
-# the first time it triggers.
-#
-send_gdb "break marker2\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 42.*$gdb_prompt $"\
-          {pass "break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "break marker2"}
-  timeout {fail "(timeout) break marker2"}
-}
-
-send_gdb "enable once $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "enable once break marker2"}
-  timeout {fail "(timeout) enable once break marker2"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+dis\[ \t\]+y.*$gdb_prompt $"\
-          {pass "info auto-disabled break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "info auto-disabled break marker2"}
-  timeout {fail "(timeout) info auto-disabled break marker2"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re "Breakpoint \[0-9\]*, marker2.*$gdb_prompt $"\
-          {pass "continue to auto-disabled break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "continue to auto-disabled break marker2"}
-  timeout {fail "(timeout) continue to auto-disabled break marker2"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+dis\[ \t\]+n.*$gdb_prompt $"\
-          {pass "info auto-disabled break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "info auto-disabled break marker2"}
-  timeout {fail "(timeout) info auto-disabled break marker2"}
-}
-
-# Verify that we don't stop at a disabled breakpoint.
-#
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop"}
-  -re "$gdb_prompt $"\
-          {fail "no stop"}
-  timeout {fail "(timeout) no stop"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at auto-disabled break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at auto-disabled break marker2"}
-  timeout {fail "(timeout) no stop at auto-disabled break marker2"}
-}
-
-# Verify that we can set a breakpoint to be self-deleting after
-# the first time it triggers.
-#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
-
-send_gdb "break marker3\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 43.*$gdb_prompt $"\
-          {pass "break marker3"}
-  -re "$gdb_prompt $"\
-          {fail "break marker3"}
-  timeout {fail "(timeout) break marker3"}
-}
-
-send_gdb "enable del $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "enable del break marker3"}
-  timeout {fail "(timeout) enable del break marker3"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+del\[ \t\]+y.*$gdb_prompt $"\
-          {pass "info auto-deleted break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "info auto-deleted break marker2"}
-  timeout {fail "(timeout) info auto-deleted break marker2"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*marker3 .*:43.*$gdb_prompt $"\
-          {pass "continue to auto-deleted break marker3"}
-  -re "Breakpoint \[0-9\]*, marker3.*$gdb_prompt $"\
-          {fail "continue to auto-deleted break marker3"}
-  -re "$gdb_prompt $"\
-          {fail "continue to auto-deleted break marker3"}
-  timeout {fail "(timeout) continue to break marker3"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re ".*No breakpoint or watchpoint number.*$gdb_prompt $"\
-          {pass "info auto-deleted break marker3"}
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\].*$gdb_prompt $"\
-          {fail "info auto-deleted break marker3"}
-  -re "$gdb_prompt $"\
-          {fail "info auto-deleted break marker3"}
-  timeout {fail "(timeout) info auto-deleted break marker3"}
-}
-
-# Verify that we can set a breakpoint and manually disable it (we've
-# already proven that disabled bp's don't trigger).
-#
-send_gdb "break marker4\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 44.*$gdb_prompt $"\
-          {pass "break marker4"}
-  -re "$gdb_prompt $"\
-          {fail "break marker4"}
-  timeout {fail "(timeout) break marker4"}
-}
-
-send_gdb "disable $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "disable break marker4"}
-  timeout {fail "(timeout) disable break marker4"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+keep\[ \t\]+n.*$gdb_prompt $"\
-          {pass "info break marker4"}
-  -re "$gdb_prompt $"\
-          {fail "info break marker4"}
-  timeout {fail "(timeout) info break marker4"}
-}
-
-# Verify that we can set a breakpoint with an ignore count N, which
-# should cause the next N triggers of the bp to be ignored.  (This is
-# a flavor of enablement/disablement, after all.)
-#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
-
-send_gdb "break marker1\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 41.*$gdb_prompt $"\
-          {pass "break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "break marker1"}
-  timeout {fail "(timeout) break marker1"}
-}
-
-# Verify that an ignore of a non-existent breakpoint is gracefully
-# handled.
-#
-send_gdb "ignore 999 2\n"
-gdb_expect {
-  -re "No breakpoint number 999..*$gdb_prompt $"\
-          {pass "ignore non-existent break"}
-  -re "$gdb_prompt $"\
-          {fail "ignore non-existent break"}
-  timeout {fail "(timeout) ignore non-existent break"}
-}
-
-# Verify that a missing ignore count is gracefully handled.
-#
-send_gdb "ignore $expect_out(1,string) \n"
-gdb_expect {
-  -re "Second argument .specified ignore-count. is missing..*$gdb_prompt $"\
-          {pass "ignore break with missing ignore count"}
-  -re "$gdb_prompt $"\
-          {fail "ignore break with missing ignore count"}
-  timeout {fail "(timeout) ignore break with missing ignore count"}
-}
-
-# Verify that a negative or zero ignore count is handled gracefully
-# (they both are treated the same).
-#
-send_gdb "ignore $expect_out(1,string) -1\n"
-gdb_expect {
-  -re "Will stop next time breakpoint \[0-9\]* is reached..*$gdb_prompt $"\
-          {pass "ignore break marker1 -1"}
-  -re "$gdb_prompt $"\
-          {fail "ignore break marker1 -1"}
-  timeout {fail "(timeout) ignore break marker1 -1"}
-}
-
-send_gdb "ignore $expect_out(1,string) 0\n"
-gdb_expect {
-  -re "Will stop next time breakpoint \[0-9\]* is reached..*$gdb_prompt $"\
-          {pass "ignore break marker1 0"}
-  -re "$gdb_prompt $"\
-          {fail "ignore break marker1 0"}
-  timeout {fail "(timeout) ignore break marker1 0"}
-}
-
-send_gdb "ignore $expect_out(1,string) 1\n"
-gdb_expect {
-  -re "Will ignore next crossing of breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "ignore break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "ignore break marker1"}
-  timeout {fail "(timeout) ignore break marker1"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+keep\[ \t\]+y.*ignore next 1 hits.*$gdb_prompt $"\
-          {pass "info ignored break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "info ignored break marker1"}
-  timeout {fail "(timeout) info ignored break marker1"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at ignored break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at ignored break marker1"}
-  timeout {fail "(timeout) no stop at ignored break marker1"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re "Breakpoint \[0-9\]*, marker1.*$gdb_prompt $"\
-          {pass "continue to break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "continue to break marker1"}
-  timeout {fail "(timeout) continue to break marker1"}
-}
-
-# Verify that we can specify both an ignore count and an auto-delete.
-#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
-
-send_gdb "break marker1\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 41.*$gdb_prompt $"\
-          {pass "break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "break marker1"}
-  timeout {fail "(timeout) break marker1"}
-}
-
-send_gdb "ignore $expect_out(1,string) 1\n"
-gdb_expect {
-  -re "Will ignore next crossing of breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "ignore break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "ignore break marker1"}
-  timeout {fail "(timeout) ignore break marker1"}
-}
-
-send_gdb "enable del $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "enable del break marker1"}
-  timeout {fail "(timeout) enable del break marker1"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+del\[ \t\]+y.*ignore next 1 hits.*$gdb_prompt $"\
-          {pass "info break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "info break marker1"}
-  timeout {fail "(timeout) info break marker2"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at ignored & auto-deleted break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at ignored & auto-deleted break marker1"}
-  timeout {fail "(timeout) no stop at ignored & auto-deleted break marker1"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*marker1 .*:41.*$gdb_prompt $"\
-          {pass "continue to ignored & auto-deleted break marker1"}
-  -re "Breakpoint \[0-9\]*, marker1.*$gdb_prompt $"\
-          {fail "continue to ignored & auto-deleted break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "continue to ignored & auto-deleted break marker1"}
-  timeout {fail "(timeout) continue to ignored & auto-deleted break marker1"}
-}
-
-# Verify that a disabled breakpoint's ignore count isn't updated when
-# the bp is encountered.
-#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
-
-send_gdb "break marker1\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 41.*$gdb_prompt $"\
-          {pass "break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "break marker1"}
-  timeout {fail "(timeout) break marker1"}
-}
-
-send_gdb "ignore $expect_out(1,string) 10\n"
-gdb_expect {
-  -re "Will ignore next 10 crossings of breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "ignore break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "ignore break marker1"}
-  timeout {fail "(timeout) ignore break marker1"}
-}
-
-send_gdb "disable $expect_out(1,string)\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "disable break marker1"}
-  timeout {fail "(timeout) disable break marker1"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at ignored & disabled break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at ignored & disabled break marker1"}
-  timeout {fail "(timeout) no stop at ignored & disabled break marker1"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
-
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]+breakpoint\[ \t\]+keep\[ \t\]+n.*ignore next 10 hits.*$gdb_prompt $"\
-          {pass "info ignored & disabled break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "info ignored & disabled break marker1"}
-  timeout {fail "(timeout) info ignored & disabled break marker1"}
-}
-
-# Verify that GDB correctly handles the "continue" command with an argument,
-# which is an ignore count to set on the currently stopped-at breakpoint.
-# (Also verify that GDB gracefully handles the case where the inferior
-# isn't stopped at a breakpoint.)
-#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
-
-send_gdb "break 64\n"
-gdb_expect {
-  -re "Breakpoint \[0-9\]*.*, line 64.*$gdb_prompt $"\
-          {pass "prepare to continue with ignore count"}
-  -re "$gdb_prompt $"\
-          {fail "prepare to continue with ignore count"}
-  timeout {fail "(timeout) prepare to continue with ignore count"}
-}
-send_gdb "continue 2\n"
-gdb_expect {
-  -re "Will ignore next crossing of breakpoint \[0-9\]*.  Continuing..*$gdb_prompt $"\
-          {pass "continue with ignore count"}
-  -re "$gdb_prompt $"\
-          {fail "continue with ignore count"}
-  timeout {fail "(timeout) continue with ignore count"}
-}
-
-send_gdb "next\n"
-gdb_expect {
-  -re ".*66\[ \t\]*marker1.*$gdb_prompt $"\
-          {pass "step after continue with ignore count"}
-  -re "$gdb_prompt $"\
-          {fail "step after continue with ignore count"}
-  timeout {fail "(timeout) step after continue with ignore count"}
-}
-
-# ??rehrauer: Huh.  This appears to be an actual bug.  (No big
-# surprise, since this feature hasn't been tested...)  Looks like
-# GDB is currently trying to set the ignore count of bp # -1!
-#
-setup_xfail hppa_*_*
-send_gdb "continue 2\n"
-gdb_expect {
-  -re "Not stopped at any breakpoint; argument ignored..*$gdb_prompt $"\
-          {pass "continue with ignore count, not stopped at bpt"}
-  -re "No breakpoint number -1.*$gdb_prompt $"\
-          {xfail "(DTS'd) continue with ignore count, not stopped at bpt"}
-  -re "$gdb_prompt $"\
-          {fail "continue with ignore count, not stopped at bpt"}
-  timeout {fail "(timeout) step after continue with ignore count, not stopped at bpt"}
-}
-
-gdb_exit
-return 0