From e2fb40b3b6d9af839aedc20db1ff7ed57fe12f7c Mon Sep 17 00:00:00 2001 From: David Taylor Date: Fri, 8 Jan 1999 23:38:29 +0000 Subject: [PATCH] renamed to have names 14 characters long or shorter. --- gdb/testsuite/gdb.base/call-array-struct.c | 1137 ----------------- gdb/testsuite/gdb.base/call-return-struct.c | 530 -------- gdb/testsuite/gdb.base/call-strings.c | 54 - .../gdb.base/enable-disable-break.exp | 525 -------- 4 files changed, 2246 deletions(-) delete mode 100644 gdb/testsuite/gdb.base/call-array-struct.c delete mode 100644 gdb/testsuite/gdb.base/call-return-struct.c delete mode 100644 gdb/testsuite/gdb.base/call-strings.c delete mode 100644 gdb/testsuite/gdb.base/enable-disable-break.exp 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 da5015b1891..00000000000 --- a/gdb/testsuite/gdb.base/call-array-struct.c +++ /dev/null @@ -1,1137 +0,0 @@ - -#include -#include -#include - -/************************************************************************** - * 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 c89cb11f511..00000000000 --- a/gdb/testsuite/gdb.base/call-return-struct.c +++ /dev/null @@ -1,530 +0,0 @@ -#include -#include -#include - -/************************************************************************** - * 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 9ba875b5d32..00000000000 --- a/gdb/testsuite/gdb.base/call-strings.c +++ /dev/null @@ -1,54 +0,0 @@ -#include -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 6593d824294..00000000000 --- 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 -- 2.30.2