aboutsummaryrefslogtreecommitdiff
path: root/gdb
diff options
context:
space:
mode:
authorDavid Taylor <taylor@redhat.com>1999-01-04 15:37:21 +0000
committerDavid Taylor <taylor@redhat.com>1999-01-04 15:37:21 +0000
commit8e260d5270d6b2228b710ba2dc0b24ad6eb98222 (patch)
tree2ee753aef4d6179db32b4dffc378a9b6cb7c114e /gdb
parent7cada34aec73e03dbbbb95fbfb07c6fc5c5ed4bb (diff)
downloadgdb-8e260d5270d6b2228b710ba2dc0b24ad6eb98222.zip
gdb-8e260d5270d6b2228b710ba2dc0b24ad6eb98222.tar.gz
gdb-8e260d5270d6b2228b710ba2dc0b24ad6eb98222.tar.bz2
new files -- part of HP merge.
Diffstat (limited to 'gdb')
-rw-r--r--gdb/testsuite/gdb.base/call-array-struct.c1137
-rw-r--r--gdb/testsuite/gdb.base/call-return-struct.c530
-rw-r--r--gdb/testsuite/gdb.base/call-strings.c54
-rw-r--r--gdb/testsuite/gdb.base/callfuncs2.c267
-rw-r--r--gdb/testsuite/gdb.base/condbreak.c81
-rw-r--r--gdb/testsuite/gdb.base/constvars.c178
-rw-r--r--gdb/testsuite/gdb.base/pointers2.c51
-rw-r--r--gdb/testsuite/gdb.base/shmain.c47
-rw-r--r--gdb/testsuite/gdb.hp/attach.c19
-rw-r--r--gdb/testsuite/gdb.hp/attach2.c23
-rw-r--r--gdb/testsuite/gdb.hp/average.c39
-rw-r--r--gdb/testsuite/gdb.hp/compiler.c31
-rw-r--r--gdb/testsuite/gdb.hp/compiler.cc34
-rw-r--r--gdb/testsuite/gdb.hp/execd-program.c28
-rw-r--r--gdb/testsuite/gdb.hp/follow-exec.c35
-rw-r--r--gdb/testsuite/gdb.hp/follow-fork.c25
-rw-r--r--gdb/testsuite/gdb.hp/follow-vfork-and-exec.c15
-rw-r--r--gdb/testsuite/gdb.hp/misc-hp.cc514
-rw-r--r--gdb/testsuite/gdb.hp/more-steps.c140
-rw-r--r--gdb/testsuite/gdb.hp/optimize.c76
-rw-r--r--gdb/testsuite/gdb.hp/quicksort.c284
-rw-r--r--gdb/testsuite/gdb.hp/run-hp.c70
-rw-r--r--gdb/testsuite/gdb.hp/start-stop.c161
-rw-r--r--gdb/testsuite/gdb.hp/sum.c15
-rw-r--r--gdb/testsuite/gdb.hp/templates-hp.cc785
-rw-r--r--gdb/testsuite/gdb.hp/thread-local-in-lib.c79
-rw-r--r--gdb/testsuite/gdb.hp/thread-local-in-lib.h7
-rw-r--r--gdb/testsuite/gdb.hp/thread-local-in-lib.lib.c92
-rw-r--r--gdb/testsuite/gdb.hp/vforked-program.c6
-rw-r--r--gdb/testsuite/gdb.hp/virtfunc-hp.cc192
-rw-r--r--gdb/testsuite/gdb.hp/watchpoint-hp.c166
-rw-r--r--gdb/testsuite/gdb.hp/xdb.c20
-rw-r--r--gdb/testsuite/gdb.hp/xdb0.c42
-rw-r--r--gdb/testsuite/gdb.hp/xdb0.h36
-rw-r--r--gdb/testsuite/gdb.hp/xdb1.c33
35 files changed, 5312 insertions, 0 deletions
diff --git a/gdb/testsuite/gdb.base/call-array-struct.c b/gdb/testsuite/gdb.base/call-array-struct.c
new file mode 100644
index 0000000..da5015b
--- /dev/null
+++ b/gdb/testsuite/gdb.base/call-array-struct.c
@@ -0,0 +1,1137 @@
+
+#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
new file mode 100644
index 0000000..c89cb11
--- /dev/null
+++ b/gdb/testsuite/gdb.base/call-return-struct.c
@@ -0,0 +1,530 @@
+#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
new file mode 100644
index 0000000..9ba875b
--- /dev/null
+++ b/gdb/testsuite/gdb.base/call-strings.c
@@ -0,0 +1,54 @@
+#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/callfuncs2.c b/gdb/testsuite/gdb.base/callfuncs2.c
new file mode 100644
index 0000000..ac14d45
--- /dev/null
+++ b/gdb/testsuite/gdb.base/callfuncs2.c
@@ -0,0 +1,267 @@
+/* Support program for testing gdb's ability to call functions
+ in an inferior which doesn't itself call malloc, pass appropriate
+ arguments to those functions, and get the returned result. */
+
+#ifdef NO_PROTOTYPES
+#define PARAMS(paramlist) ()
+#else
+#define PARAMS(paramlist) paramlist
+#endif
+
+char char_val1 = 'a';
+char char_val2 = 'b';
+
+short short_val1 = 10;
+short short_val2 = -23;
+
+int int_val1 = 87;
+int int_val2 = -26;
+
+long long_val1 = 789;
+long long_val2 = -321;
+
+float float_val1 = 3.14159;
+float float_val2 = -2.3765;
+
+double double_val1 = 45.654;
+double double_val2 = -67.66;
+
+#define DELTA (0.001)
+
+char *string_val1 = "string 1";
+char *string_val2 = "string 2";
+
+char char_array_val1[] = "carray 1";
+char char_array_val2[] = "carray 2";
+
+struct struct1 {
+ char c;
+ short s;
+ int i;
+ long l;
+ float f;
+ double d;
+ char a[4];
+} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
+
+/* Some functions that can be passed as arguments to other test
+ functions, or called directly. */
+
+int add (a, b)
+int a, b;
+{
+ return (a + b);
+}
+
+int doubleit (a)
+int a;
+{
+ return (a + a);
+}
+
+int (*func_val1) PARAMS((int,int)) = add;
+int (*func_val2) PARAMS((int)) = doubleit;
+
+/* An enumeration and functions that test for specific values. */
+
+enum enumtype { enumval1, enumval2, enumval3 };
+enum enumtype enum_val1 = enumval1;
+enum enumtype enum_val2 = enumval2;
+enum enumtype enum_val3 = enumval3;
+
+t_enum_value1 (enum_arg)
+enum enumtype enum_arg;
+{
+ return (enum_arg == enum_val1);
+}
+
+t_enum_value2 (enum_arg)
+enum enumtype enum_arg;
+{
+ return (enum_arg == enum_val2);
+}
+
+t_enum_value3 (enum_arg)
+enum enumtype enum_arg;
+{
+ return (enum_arg == enum_val3);
+}
+
+/* A function that takes a vector of integers (along with an explicit
+ count) and returns their sum. */
+
+int sum_args (argc, argv)
+int argc;
+int argv[];
+{
+ int sumval = 0;
+ int idx;
+
+ for (idx = 0; idx < argc; idx++)
+ {
+ sumval += argv[idx];
+ }
+ return (sumval);
+}
+
+/* Test that we can call functions that take structs and return
+ members from that struct */
+
+char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
+short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
+int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
+long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
+float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
+double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
+char *t_structs_a (tstruct) struct struct1 tstruct; { return (tstruct.a); }
+
+/* Test that calling functions works if there are a lot of arguments. */
+int
+sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
+ int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
+{
+ return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
+}
+
+/* Gotta have a main to be able to generate a linked, runnable
+ executable, and also provide a useful place to set a breakpoint. */
+
+main ()
+{
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ t_structs_c(struct_val1);
+}
+
+/* Functions that expect specific values to be passed and return
+ either 0 or 1, depending upon whether the values were
+ passed incorrectly or correctly, respectively. */
+
+int t_char_values (char_arg1, char_arg2)
+char char_arg1, char_arg2;
+{
+ return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
+}
+
+int
+#ifdef NO_PROTOTYPES
+t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
+ char arg1;
+ short arg2;
+ int arg3;
+ char arg4;
+ short arg5;
+ char arg6;
+ short arg7;
+ int arg8;
+ short arg9;
+ short arg10;
+#else
+t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
+ char arg6, short arg7, int arg8, short arg9, short arg10)
+#endif
+{
+ return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
+}
+
+int t_short_values (short_arg1, short_arg2)
+short short_arg1, short_arg2;
+{
+ return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
+}
+
+int t_int_values (int_arg1, int_arg2)
+int int_arg1, int_arg2;
+{
+ return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
+}
+
+int t_long_values (long_arg1, long_arg2)
+long long_arg1, long_arg2;
+{
+ return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
+}
+
+int t_float_values (float_arg1, float_arg2)
+float float_arg1, float_arg2;
+{
+ return ((float_arg1 - float_val1) < DELTA
+ && (float_arg1 - float_val1) > -DELTA
+ && (float_arg2 - float_val2) < DELTA
+ && (float_arg2 - float_val2) > -DELTA);
+}
+
+int
+#ifdef NO_PROTOTYPES
+/* In this case we are just duplicating t_float_values, but that is the
+ easiest way to deal with either ANSI or non-ANSI. */
+t_float_values2 (float_arg1, float_arg2)
+ float float_arg1, float_arg2;
+#else
+t_float_values2 (float float_arg1, float float_arg2)
+#endif
+{
+ return ((float_arg1 - float_val1) < DELTA
+ && (float_arg1 - float_val1) > -DELTA
+ && (float_arg2 - float_val2) < DELTA
+ && (float_arg2 - float_val2) > -DELTA);
+}
+
+int t_double_values (double_arg1, double_arg2)
+double double_arg1, double_arg2;
+{
+ return ((double_arg1 - double_val1) < DELTA
+ && (double_arg1 - double_val1) > -DELTA
+ && (double_arg2 - double_val2) < DELTA
+ && (double_arg2 - double_val2) > -DELTA);
+}
+
+int t_string_values (string_arg1, string_arg2)
+char *string_arg1, *string_arg2;
+{
+ return (!strcmp (string_arg1, string_val1) &&
+ !strcmp (string_arg2, string_val2));
+}
+
+int t_char_array_values (char_array_arg1, char_array_arg2)
+char char_array_arg1[], char_array_arg2[];
+{
+ return (!strcmp (char_array_arg1, char_array_val1) &&
+ !strcmp (char_array_arg2, char_array_val2));
+}
+
+
+/* This used to simply compare the function pointer arguments with
+ known values for func_val1 and func_val2. Doing so is valid ANSI
+ code, but on some machines (RS6000, HPPA, others?) it may fail when
+ called directly by GDB.
+
+ In a nutshell, it's not possible for GDB to determine when the address
+ of a function or the address of the function's stub/trampoline should
+ be passed.
+
+ So, to avoid GDB lossage in the common case, we perform calls through the
+ various function pointers and compare the return values. For the HPPA
+ at least, this allows the common case to work.
+
+ If one wants to try something more complicated, pass the address of
+ a function accepting a "double" as one of its first 4 arguments. Call
+ that function indirectly through the function pointer. This would fail
+ on the HPPA. */
+
+int t_func_values (func_arg1, func_arg2)
+int (*func_arg1) PARAMS ((int, int));
+int (*func_arg2) PARAMS ((int));
+{
+ return ((*func_arg1) (5,5) == (*func_val1) (5,5)
+ && (*func_arg2) (6) == (*func_val2) (6));
+}
+
+int t_call_add (func_arg1, a, b)
+int (*func_arg1) PARAMS ((int, int));
+int a, b;
+{
+ return ((*func_arg1)(a, b));
+}
diff --git a/gdb/testsuite/gdb.base/condbreak.c b/gdb/testsuite/gdb.base/condbreak.c
new file mode 100644
index 0000000..491d6e5
--- /dev/null
+++ b/gdb/testsuite/gdb.base/condbreak.c
@@ -0,0 +1,81 @@
+#ifdef vxworks
+
+# include <stdio.h>
+
+/* VxWorks does not supply atoi. */
+static int
+atoi (z)
+ char *z;
+{
+ int i = 0;
+
+ while (*z >= '0' && *z <= '9')
+ i = i * 10 + (*z++ - '0');
+ return i;
+}
+
+/* I don't know of any way to pass an array to VxWorks. This function
+ can be called directly from gdb. */
+
+vxmain (arg)
+char *arg;
+{
+ char *argv[2];
+
+ argv[0] = "";
+ argv[1] = arg;
+ main (2, argv, (char **) 0);
+}
+
+#else /* ! vxworks */
+# include <stdio.h>
+#endif /* ! vxworks */
+
+/*
+ * The following functions do nothing useful. They are included simply
+ * as places to try setting breakpoints at. They are explicitly
+ * "one-line functions" to verify that this case works (some versions
+ * of gcc have or have had problems with this).
+ */
+
+int marker1 () { return (0); }
+int marker2 (a) int a; { return (1); }
+void marker3 (a, b) char *a, *b; {}
+void marker4 (d) long d; {}
+
+/*
+ * This simple classical example of recursion is useful for
+ * testing stack backtraces and such.
+ */
+
+int
+main (argc, argv, envp)
+int argc;
+char *argv[], **envp;
+{
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ if (argc == 123456) {
+ fprintf (stderr, "usage: factorial <number>\n");
+ return 1;
+ }
+ printf ("%d\n", factorial (atoi ("6")));
+
+ marker1 ();
+ marker2 (43);
+ marker3 ("stack", "trace");
+ marker4 (177601976L);
+ return 0;
+}
+
+int factorial (value)
+int value;
+{
+ if (value > 1) {
+ value *= factorial (value - 1);
+ }
+ return (value);
+}
+
diff --git a/gdb/testsuite/gdb.base/constvars.c b/gdb/testsuite/gdb.base/constvars.c
new file mode 100644
index 0000000..4fe9dad
--- /dev/null
+++ b/gdb/testsuite/gdb.base/constvars.c
@@ -0,0 +1,178 @@
+void marker1 (void)
+{
+
+}
+
+// misc. function params
+
+int qux1 (const char cc, const char & ccr, const char * ccp, char * const cpc)
+{
+ return 33;
+}
+
+int qux2 (volatile unsigned char vuc, const volatile int cvi,
+ volatile short & vsr, volatile long * vlp, float * volatile fpv,
+ const volatile signed char * const volatile cvscpcv)
+{
+ return 400;
+}
+
+
+int main(void)
+{
+ char lave = 'B';
+ unsigned char lavish = 10;
+ short lax = 20;
+ unsigned short lecherous = 30;
+ long lechery = 40;
+ unsigned long lectern = 50;
+ float leeway = 60;
+ double legacy = 70;
+ signed char lemonade = 35;
+
+ const char laconic = 'A';
+ const unsigned char laggard = 1;
+ const short lagoon = 2;
+ const unsigned short laity = 3;
+ const long lambent = 4;
+ const unsigned long laminated = 5;
+ const float lampoon = 6;
+ const double languid = 7;
+
+ // pointers to constant variables
+ const char *legend = &lave;
+ const unsigned char *legerdemain = &lavish;
+ const short *leniency = &lax;
+ const unsigned short *leonine = &lecherous;
+ const long *lesion = &lechery;
+ const unsigned long *lethal = &lectern;
+ const float *lethargic = &leeway;
+ const double *levity = &legacy;
+
+ // constant pointers to constant variables
+ const char *const lewd = &laconic;
+ const unsigned char *const lexicographer = &laggard;
+ const short *const lexicon = &lagoon;
+ const unsigned short *const liaison = &laity;
+ const long *const libation = &lambent;
+ const unsigned long *const libelous = &laminated;
+ const float *const libertine = &lampoon;
+ const double *const libidinous = &languid;
+
+ // this is the same as const char * legend ....
+ char const *languish = &laconic;
+ unsigned char const *languor = &laggard;
+ short const *lank = &lagoon;
+ unsigned short const *lapidary = &laity;
+ long const *larceny = &lambent;
+ unsigned long const *largess = &laminated;
+ float const *lascivious = &lampoon;
+ double const *lassitude = &languid;
+
+ // constant pointers to variable
+ char *const lamprey = &lave;
+ unsigned char *const lariat = &lavish;
+ short *const laudanum = &lax;
+ unsigned short *const lecithin = &lecherous;
+ long *const leviathan = &lechery;
+ unsigned long *const libretto = &lectern;
+ float *const lissome = &leeway;
+ double *const locust = &legacy;
+
+ // volatile variables
+
+ volatile char vox = 'X';
+ volatile unsigned char victuals = 13;
+ volatile short vixen = 200;
+ volatile unsigned short vitriol = 300;
+ volatile long vellum = 1000;
+ volatile unsigned long valve = 2000;
+ volatile float vacuity = 3.0;
+ volatile double vertigo = 10.3;
+
+ // pointers to volatile variables
+
+ volatile char * vampire = &vox;
+ volatile unsigned char * viper = &victuals;
+ volatile short * vigour = &vixen;
+ volatile unsigned short * vapour = &vitriol;
+ volatile long * ventricle = &vellum;
+ volatile unsigned long * vigintillion = &valve;
+ volatile float * vocation = &vacuity;
+ volatile double * veracity = &vertigo;
+
+ // volatile pointers to volatile variables
+
+ volatile char * volatile vapidity = &vox;
+ volatile unsigned char * volatile velocity = &victuals;
+ volatile short * volatile veneer = &vixen;
+ volatile unsigned short * volatile video = &vitriol;
+ volatile long * volatile vacuum = &vellum;
+ volatile unsigned long * volatile veniality = &valve;
+ volatile float * volatile vitality = &vacuity;
+ volatile double * volatile voracity = &vertigo;
+
+ // const volatile vars
+
+ const volatile char victor = 'Y';
+ const volatile unsigned char vicar = 11;
+
+ // pointers to const volatiles
+
+ const volatile char * victory = &victor;
+ const volatile unsigned char * vicarage = &vicar;
+
+ // const pointers to volatile vars
+
+ volatile char * const vein = &vox;
+ volatile unsigned char * const vogue = &victuals;
+
+ // const pointers to const volatile vars
+
+ const volatile char * const cavern = &victor;
+ const volatile unsigned char * const coverlet = &vicar;
+
+ // volatile pointers to const vars
+
+ const char * volatile caveat = &laconic;
+ const unsigned char * volatile covenant = &laggard;
+
+ // volatile pointers to const volatile vars
+
+ const volatile char * volatile vizier = &victor;
+ const volatile unsigned char * volatile vanadium = &vicar;
+
+ // const volatile pointers
+
+ char * const volatile vane = &lave;
+ unsigned char * const volatile veldt = &lavish;
+
+ // const volatile pointers to const vars
+
+ const char * const volatile cove = &laconic;
+ const unsigned char * const volatile cavity = &laggard;
+
+ // const volatile pointers to volatile vars
+
+ volatile char * const volatile vagus = &vox;
+ volatile unsigned char * const volatile vagrancy = &victuals;
+
+ // const volatile pointers to const volatile
+
+ const volatile char * const volatile vagary = &victor;
+ const volatile unsigned char * const volatile vendor = &vicar;
+
+ // misc. references
+
+ const char & radiation = laconic;
+ volatile signed char & remuneration = lemonade;
+
+ #ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+ #endif
+ marker1();
+
+
+ return 0;
+}
diff --git a/gdb/testsuite/gdb.base/pointers2.c b/gdb/testsuite/gdb.base/pointers2.c
new file mode 100644
index 0000000..6c30621
--- /dev/null
+++ b/gdb/testsuite/gdb.base/pointers2.c
@@ -0,0 +1,51 @@
+void marker1 ()
+{
+
+}
+
+
+int main()
+{
+ char C, *pC, **ppC, ***pppC, ****ppppC, *****pppppC, ******ppppppC;
+ unsigned char UC, *pUC;
+ short S, *pS;
+ unsigned short US, *pUS;
+ int I, *pI;
+ unsigned int UI, *pUI;
+ long L, *pL;
+ unsigned long UL, *pUL;
+ float F, *pF;
+ double D, *pD;
+ C = 'A';
+ UC = 21;
+ S = -14;
+ US = 7;
+ I = 102;
+ UI = 1002;
+ L = -234;
+ UL = 234;
+ F = 1.25E10;
+ D = -1.375E-123;
+ pC = &C;
+ ppC = &pC;
+ pppC = &ppC;
+ ppppC = &pppC;
+ pppppC = &ppppC;
+ ppppppC = &pppppC;
+ pUC = &UC;
+ pS = &S;
+ pUS = &US;
+ pI = &I;
+ pUI = &UI;
+ pL = &L;
+ pUL = &UL;
+ pF = &F;
+ pD = &D;
+
+ #ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+ #endif
+ marker1();
+ return 0;
+}
diff --git a/gdb/testsuite/gdb.base/shmain.c b/gdb/testsuite/gdb.base/shmain.c
new file mode 100644
index 0000000..954c3db
--- /dev/null
+++ b/gdb/testsuite/gdb.base/shmain.c
@@ -0,0 +1,47 @@
+/* A test */
+
+#include "ss.h"
+#include <stdio.h>
+
+extern int shr1();
+extern int shr2();
+extern float sg;
+
+int eglob;
+
+struct {
+ int a;
+ int b;
+} s;
+
+int g;
+
+int local_structarg(x)
+struct s x;
+{
+ return x.b;
+}
+
+main()
+{
+ struct s y;
+ g = 1;
+ g = shr1(g);
+ g = shr2(g);
+ g = mainshr1(g);
+ sg = 1.1;
+ printf("address of sg is 0x%x\n", &sg);
+ y.a = 3;
+ y.b = 4;
+ g = local_structarg(y);
+ g = structarg(y);
+ g = pstructarg(&y);
+}
+
+int mainshr1(g)
+int g;
+{
+ return 2*g;
+}
+
+
diff --git a/gdb/testsuite/gdb.hp/attach.c b/gdb/testsuite/gdb.hp/attach.c
new file mode 100644
index 0000000..1aad3c1
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/attach.c
@@ -0,0 +1,19 @@
+/* This program is intended to be started outside of gdb, and then
+ attached to by gdb. Thus, it simply spins in a loop. The loop
+ is exited when & if the variable 'should_exit' is non-zero. (It
+ is initialized to zero in this program, so the loop will never
+ exit unless/until gdb sets the variable to non-zero.)
+ */
+#include <stdio.h>
+
+int should_exit = 0;
+
+main ()
+{
+ int local_i = 0;
+
+ while (! should_exit)
+ {
+ local_i++;
+ }
+}
diff --git a/gdb/testsuite/gdb.hp/attach2.c b/gdb/testsuite/gdb.hp/attach2.c
new file mode 100644
index 0000000..8eb7a05
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/attach2.c
@@ -0,0 +1,23 @@
+/* This program is intended to be started outside of gdb, and then
+ attached to by gdb. Thus, it simply spins in a loop. The loop
+ is exited when & if the variable 'should_exit' is non-zero. (It
+ is initialized to zero in this program, so the loop will never
+ exit unless/until gdb sets the variable to non-zero.)
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+int should_exit = 0;
+
+main ()
+{
+ int local_i = 0;
+
+ sleep( 10 ); /* System call causes register fetch to fail */
+ /* This is a known HPUX "feature" */
+ while (! should_exit)
+ {
+ local_i++;
+ }
+ return (0);
+}
diff --git a/gdb/testsuite/gdb.hp/average.c b/gdb/testsuite/gdb.hp/average.c
new file mode 100644
index 0000000..070eaef
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/average.c
@@ -0,0 +1,39 @@
+/* This is a sample program for the HP WDB debugger. */
+
+#include <stdio.h>
+
+#define num 10
+
+static int my_list[num] = {3,4,2,0,2,1,8,3,6,7};
+
+#ifdef __STDC__
+void print_average(int list[], int low, int high)
+#else
+void print_average(list, low, high)
+int list[], low, high;
+#endif
+ {
+ int total, num_elements, average;
+ total = sum(list, low, high);
+ num_elements = high - low; /* note this is an off-by-one bug */
+
+ average = total / num_elements;
+ printf("%10.d\n", average);
+ }
+
+#ifdef __STDC__
+int main(void)
+#else
+main ()
+#endif
+{
+ char c;
+ int first = 0;
+ int last = num-1;
+
+ /* Try two test cases. */
+ print_average (my_list, first, last);
+ print_average (my_list, first, last - 3);
+foo:
+ exit(0);
+}
diff --git a/gdb/testsuite/gdb.hp/compiler.c b/gdb/testsuite/gdb.hp/compiler.c
new file mode 100644
index 0000000..8eb0d47
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/compiler.c
@@ -0,0 +1,31 @@
+/* Often the behavior of any particular test depends upon what compiler was
+ used to compile the test. As each test is compiled, this file is
+ preprocessed by the same compiler used to compile that specific test
+ (different tests might be compiled by different compilers, particularly
+ if compiled at different times), and used to generate a *.ci (compiler
+ info) file for that test.
+
+ I.E., when callfuncs is compiled, a callfuncs.ci file will be generated,
+ which can then be sourced by callfuncs.exp to give callfuncs.exp access
+ to information about the compilation environment.
+
+ TODO: It might be a good idea to add expect code that tests each
+ definition made with 'set" to see if one already exists, and if so
+ warn about conflicts if it is being set to something else. */
+
+/* This needs to be kept in sync with whatis.c and gdb.exp(get_compiler_info).
+ If this ends up being hairy, we could use a common header file. */
+
+#if defined (__STDC__) || defined (_AIX)
+set signed_keyword_not_used 0
+#else
+set signed_keyword_not_used 1
+#endif
+
+#if defined (__GNUC__)
+set gcc_compiled __GNUC__
+#else
+set gcc_compiled 0
+#endif
+
+return 0
diff --git a/gdb/testsuite/gdb.hp/compiler.cc b/gdb/testsuite/gdb.hp/compiler.cc
new file mode 100644
index 0000000..aa35c75
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/compiler.cc
@@ -0,0 +1,34 @@
+/* Often the behavior of any particular test depends upon what compiler was
+ used to compile the test. As each test is compiled, this file is
+ preprocessed by the same compiler used to compile that specific test
+ (different tests might be compiled by different compilers, particularly
+ if compiled at different times), and used to generate a *.ci (compiler
+ info) file for that test.
+
+ I.E., when callfuncs is compiled, a callfuncs.ci file will be generated,
+ which can then be sourced by callfuncs.exp to give callfuncs.exp access
+ to information about the compilation environment.
+
+ TODO: It might be a good idea to add expect code that tests each
+ definition made with 'set" to see if one already exists, and if so
+ warn about conflicts if it is being set to something else. */
+
+#if defined(__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 6
+set supports_template_debugging 1
+#else
+set supports_template_debugging 0
+#endif
+
+#if defined(__cplusplus)
+set supports_template_debugging 1
+#else
+set supports_template_debugging 0
+#endif
+
+#if defined (__GNUC__)
+set gcc_compiled __GNUC__
+#else
+set gcc_compiled 0
+#endif
+
+return 0
diff --git a/gdb/testsuite/gdb.hp/execd-program.c b/gdb/testsuite/gdb.hp/execd-program.c
new file mode 100644
index 0000000..0320991
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/execd-program.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+/* There is a global_i in follow_exec, which exec's us. We
+ should not be able to see that other definition of global_i
+ after we are exec'd.
+ */
+int global_i = 0;
+
+main (argc, argv)
+ int argc;
+ char * argv[];
+{
+ /* There is a local_j in follow_exec, which exec's us. We
+ should not be able to see that other definition of local_j
+ after we are exec'd.
+ */
+ int local_j = argc;
+ char * s;
+
+ printf ("Hello from execd_program...\n");
+ if (argc != 2)
+ {
+ printf ("expected one string argument\n");
+ exit (-1);
+ }
+ s = argv[1];
+ printf ("argument received: %s\n", s);
+}
diff --git a/gdb/testsuite/gdb.hp/follow-exec.c b/gdb/testsuite/gdb.hp/follow-exec.c
new file mode 100644
index 0000000..c51fa52
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/follow-exec.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+
+int global_i = 100;
+
+main ()
+{
+ int local_j = global_i+1;
+ int local_k = local_j+1;
+
+ printf ("follow-exec is about to execlp(execd-program)...\n");
+
+ execlp ("gdb.hp/execd-program",
+ "gdb.hp/execd-program",
+ "execlp arg1 from follow-exec",
+ (char *)0);
+
+ printf ("follow-exec is about to execl(execd-program)...\n");
+
+ execl ("gdb.hp/execd-program",
+ "gdb.hp/execd-program",
+ "execl arg1 from follow-exec",
+ "execl arg2 from follow-exec",
+ (char *)0);
+
+ {
+ static char * argv[] = {
+ "gdb.hp/execd-program",
+ "execv arg1 from follow-exec",
+ 0};
+
+ printf ("follow-exec is about to execv(execd-program)...\n");
+
+ execv ("gdb.hp/execd-program", argv);
+ }
+}
diff --git a/gdb/testsuite/gdb.hp/follow-fork.c b/gdb/testsuite/gdb.hp/follow-fork.c
new file mode 100644
index 0000000..89f92ae
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/follow-fork.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+void callee (i)
+ int i;
+{
+ printf("callee: %d\n", i);
+}
+
+main ()
+{
+ int pid;
+ int v = 5;
+
+ pid = fork ();
+ if (pid == 0)
+ {
+ v++;
+ /* printf ("I'm the child!\n"); */
+ }
+ else
+ {
+ v--;
+ /* printf ("I'm the proud parent of child #%d!\n", pid); */
+ }
+}
diff --git a/gdb/testsuite/gdb.hp/follow-vfork-and-exec.c b/gdb/testsuite/gdb.hp/follow-vfork-and-exec.c
new file mode 100644
index 0000000..c7e6cd3
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/follow-vfork-and-exec.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+main ()
+{
+ int pid;
+
+ pid = vfork ();
+ if (pid == 0) {
+ printf ("I'm the child!\n");
+ execlp ("gdb.hp/vforked-program", "gdb.hp/vforked-program", (char *)0);
+ }
+ else {
+ printf ("I'm the proud parent of child #%d!\n", pid);
+ }
+}
diff --git a/gdb/testsuite/gdb.hp/misc-hp.cc b/gdb/testsuite/gdb.hp/misc-hp.cc
new file mode 100644
index 0000000..af46830
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/misc-hp.cc
@@ -0,0 +1,514 @@
+// Test various -*- C++ -*- things.
+
+typedef struct fleep fleep;
+struct fleep { int a; } s;
+
+// ====================== simple class structures =======================
+
+struct default_public_struct {
+ // defaults to public:
+ int a;
+ int b;
+};
+
+struct explicit_public_struct {
+ public:
+ int a;
+ int b;
+};
+
+struct protected_struct {
+ protected:
+ int a;
+ int b;
+};
+
+struct private_struct {
+ private:
+ int a;
+ int b;
+};
+
+struct mixed_protection_struct {
+ public:
+ int a;
+ int b;
+ private:
+ int c;
+ int d;
+ protected:
+ int e;
+ int f;
+ public:
+ int g;
+ private:
+ int h;
+ protected:
+ int i;
+};
+
+class public_class {
+ public:
+ int a;
+ int b;
+};
+
+class protected_class {
+ protected:
+ int a;
+ int b;
+};
+
+class default_private_class {
+ // defaults to private:
+ int a;
+ int b;
+};
+
+class explicit_private_class {
+ private:
+ int a;
+ int b;
+};
+
+class mixed_protection_class {
+ public:
+ int a;
+ int b;
+ private:
+ int c;
+ int d;
+ protected:
+ int e;
+ int f;
+ public:
+ int g;
+ private:
+ int h;
+ protected:
+ int i;
+};
+
+class const_vol_method_class {
+public:
+ int a;
+ int b;
+ int foo (int &) const;
+ int bar (int &) volatile;
+ int baz (int &) const volatile;
+};
+
+int const_vol_method_class::foo (int & ir) const
+{
+ return ir + 3;
+}
+int const_vol_method_class::bar (int & ir) volatile
+{
+ return ir + 4;
+}
+int const_vol_method_class::baz (int & ir) const volatile
+{
+ return ir + 5;
+}
+
+// ========================= simple inheritance ==========================
+
+class A {
+ public:
+ int a;
+ int x;
+};
+
+A g_A;
+
+class B : public A {
+ public:
+ int b;
+ int x;
+};
+
+B g_B;
+
+class C : public A {
+ public:
+ int c;
+ int x;
+};
+
+C g_C;
+
+class D : public B, public C {
+ public:
+ int d;
+ int x;
+};
+
+D g_D;
+
+class E : public D {
+ public:
+ int e;
+ int x;
+};
+
+E g_E;
+
+class class_with_anon_union
+{
+ public:
+ int one;
+ union
+ {
+ int a;
+ long b;
+ };
+};
+
+class_with_anon_union g_anon_union;
+
+void inheritance2 (void)
+{
+}
+
+void inheritance1 (void)
+{
+ int ival;
+ int *intp;
+
+ // {A::a, A::x}
+
+ g_A.A::a = 1;
+ g_A.A::x = 2;
+
+ // {{A::a,A::x},B::b,B::x}
+
+ g_B.A::a = 3;
+ g_B.A::x = 4;
+ g_B.B::b = 5;
+ g_B.B::x = 6;
+
+ // {{A::a,A::x},C::c,C::x}
+
+ g_C.A::a = 7;
+ g_C.A::x = 8;
+ g_C.C::c = 9;
+ g_C.C::x = 10;
+
+ // {{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}
+
+ // The following initialization code is non-portable, but allows us
+ // to initialize all members of g_D until we can fill in the missing
+ // initialization code with legal C++ code.
+
+ for (intp = (int *) &g_D, ival = 11;
+ intp < ((int *) &g_D + sizeof (g_D) / sizeof (int));
+ intp++, ival++)
+ {
+ *intp = ival;
+ }
+
+ // Overlay the nonportable initialization with legal initialization.
+
+ // ????? = 11; (g_D.A::a = 11; is ambiguous)
+ // ????? = 12; (g_D.A::x = 12; is ambiguous)
+ g_D.B::b = 13;
+ g_D.B::x = 14;
+ // ????? = 15;
+ // ????? = 16;
+ g_D.C::c = 17;
+ g_D.C::x = 18;
+ g_D.D::d = 19;
+ g_D.D::x = 20;
+
+
+ // {{{{A::a,A::x},B::b,B::x},{{A::a,A::x},C::c,C::x},D::d,D::x}},E::e,E::x}
+
+ // The following initialization code is non-portable, but allows us
+ // to initialize all members of g_D until we can fill in the missing
+ // initialization code with legal C++ code.
+
+ for (intp = (int *) &g_E, ival = 21;
+ intp < ((int *) &g_E + sizeof (g_E) / sizeof (int));
+ intp++, ival++)
+ {
+ *intp = ival;
+ }
+
+ // Overlay the nonportable initialization with legal initialization.
+
+ // ????? = 21; (g_E.A::a = 21; is ambiguous)
+ // ????? = 22; (g_E.A::x = 22; is ambiguous)
+ g_E.B::b = 23;
+ g_E.B::x = 24;
+ // ????? = 25;
+ // ????? = 26;
+ g_E.C::c = 27;
+ g_E.C::x = 28;
+ g_E.D::d = 29;
+ g_E.D::x = 30;
+ g_E.E::e = 31;
+ g_E.E::x = 32;
+
+ g_anon_union.one = 1;
+ g_anon_union.a = 2;
+
+ inheritance2 ();
+}
+
+// ======================== virtual base classes=========================
+
+class vA {
+ public:
+ int va;
+ int vx;
+};
+
+vA g_vA;
+
+class vB : public virtual vA {
+ public:
+ int vb;
+ int vx;
+};
+
+vB g_vB;
+
+class vC : public virtual vA {
+ public:
+ int vc;
+ int vx;
+};
+
+vC g_vC;
+
+class vD : public virtual vB, public virtual vC {
+ public:
+ int vd;
+ int vx;
+};
+
+vD g_vD;
+
+class vE : public virtual vD {
+ public:
+ int ve;
+ int vx;
+};
+
+vE g_vE;
+
+void inheritance4 (void)
+{
+}
+
+void inheritance3 (void)
+{
+ int ival;
+ int *intp;
+
+ // {vA::va, vA::vx}
+
+ g_vA.vA::va = 1;
+ g_vA.vA::vx = 2;
+
+ // {{vA::va, vA::vx}, vB::vb, vB::vx}
+
+ g_vB.vA::va = 3;
+ g_vB.vA::vx = 4;
+ g_vB.vB::vb = 5;
+ g_vB.vB::vx = 6;
+
+ // {{vA::va, vA::vx}, vC::vc, vC::vx}
+
+ g_vC.vA::va = 7;
+ g_vC.vA::vx = 8;
+ g_vC.vC::vc = 9;
+ g_vC.vC::vx = 10;
+
+ // {{{{vA::va, vA::vx}, vB::vb, vB::vx}, vC::vc, vC::vx}, vD::vd,vD::vx}
+
+ g_vD.vA::va = 11;
+ g_vD.vA::vx = 12;
+ g_vD.vB::vb = 13;
+ g_vD.vB::vx = 14;
+ g_vD.vC::vc = 15;
+ g_vD.vC::vx = 16;
+ g_vD.vD::vd = 17;
+ g_vD.vD::vx = 18;
+
+
+ // {{{{{vA::va,vA::vx},vB::vb,vB::vx},vC::vc,vC::vx},vD::vd,vD::vx},vE::ve,vE::vx}
+
+ g_vD.vA::va = 19;
+ g_vD.vA::vx = 20;
+ g_vD.vB::vb = 21;
+ g_vD.vB::vx = 22;
+ g_vD.vC::vc = 23;
+ g_vD.vC::vx = 24;
+ g_vD.vD::vd = 25;
+ g_vD.vD::vx = 26;
+ g_vE.vE::ve = 27;
+ g_vE.vE::vx = 28;
+
+ inheritance4 ();
+}
+
+// ======================================================================
+
+class Base1 {
+ public:
+ int x;
+ Base1(int i) { x = i; }
+};
+
+class Foo
+{
+ public:
+ int x;
+ int y;
+ static int st;
+ Foo (int i, int j) { x = i; y = j; }
+ int operator! ();
+ operator int ();
+ int times (int y);
+};
+
+class Bar : public Base1, public Foo {
+ public:
+ int z;
+ Bar (int i, int j, int k) : Base1 (10*k), Foo (i, j) { z = k; }
+};
+
+class ClassWithEnum {
+public:
+ enum PrivEnum { red, green, blue, yellow = 42 };
+ PrivEnum priv_enum;
+ int x;
+};
+
+int Foo::operator! () { return !x; }
+
+int Foo::times (int y) { return x * y; }
+
+int Foo::st = 100;
+
+Foo::operator int() { return x; }
+
+Foo foo(10, 11);
+Bar bar(20, 21, 22);
+
+class Contains_static_instance
+{
+ public:
+ int x;
+ int y;
+ Contains_static_instance (int i, int j) { x = i; y = j; }
+ static Contains_static_instance null;
+};
+
+Contains_static_instance Contains_static_instance::null(0,0);
+Contains_static_instance csi(10,20);
+
+class Contains_nested_static_instance
+{
+ public:
+ class Nested
+ {
+ public:
+ Nested(int i) : z(i) {}
+ int z;
+ static Contains_nested_static_instance xx;
+ };
+
+ Contains_nested_static_instance(int i, int j) : x(i), y(j) {}
+
+ int x;
+ int y;
+
+ static Contains_nested_static_instance null;
+ static Nested yy;
+};
+
+Contains_nested_static_instance Contains_nested_static_instance::null(0, 0);
+Contains_nested_static_instance::Nested Contains_nested_static_instance::yy(5);
+Contains_nested_static_instance
+ Contains_nested_static_instance::Nested::xx(1,2);
+Contains_nested_static_instance cnsi(30,40);
+
+typedef struct {
+ int one;
+ int two;
+} tagless_struct;
+tagless_struct v_tagless;
+
+/* Try to get the compiler to allocate a class in a register. */
+class small {
+ public:
+ int x;
+ int method ();
+};
+int small::method ()
+{
+ return x + 5;
+}
+void marker_reg1 () {}
+
+int
+register_class ()
+{
+ /* We don't call any methods for v, so gcc version cygnus-2.3.3-930220
+ might put this variable in a register. This is a lose, though, because
+ it means that GDB can't call any methods for that variable. */
+ register small v;
+
+ int i;
+
+ /* Perform a computation sufficiently complicated that optimizing compilers
+ won't optimized out the variable. If some compiler constant-folds this
+ whole loop, maybe using a parameter to this function here would help. */
+ v.x = 0;
+ for (i = 0; i < 13; ++i)
+ v.x += i;
+ --v.x; /* v.x is now 77 */
+ marker_reg1 ();
+ return v.x + 5;
+}
+
+int
+main()
+{
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ inheritance1 ();
+ inheritance3 ();
+ register_class ();
+
+ /* FIXME: pmi gets optimized out. Need to do some more computation with
+ it or something. (No one notices, because the test is xfail'd anyway,
+ but that probably won't always be true...). */
+ int Foo::* pmi = &Foo::y;
+
+ /* Make sure the AIX linker doesn't remove the variable. */
+ v_tagless.one = 5;
+
+ /* Class with enumeration inside it */
+ ClassWithEnum obj_with_enum;
+ obj_with_enum.priv_enum = ClassWithEnum::green;
+
+ return foo.*pmi;
+}
+
+/* Create an instance for some classes, otherwise they get optimized away. */
+
+default_public_struct default_public_s;
+explicit_public_struct explicit_public_s;
+protected_struct protected_s;
+private_struct private_s;
+mixed_protection_struct mixed_protection_s;
+public_class public_c;
+protected_class protected_c;
+default_private_class default_private_c;
+explicit_private_class explicit_private_c;
+mixed_protection_class mixed_protection_c;
diff --git a/gdb/testsuite/gdb.hp/more-steps.c b/gdb/testsuite/gdb.hp/more-steps.c
new file mode 100644
index 0000000..c5ba1e2
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/more-steps.c
@@ -0,0 +1,140 @@
+/* BeginSourceFile more_steps.c
+
+ This file creates a lot of threads which then execute
+ in parallel, so that wdb can be tested on handling
+ simultaneous thread events.
+
+ To compile:
+
+ cc -Ae +DA1.0 -g -o more_steps -lpthread more_steps.c
+
+ To run:
+
+ more_threads
+*/
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <pthread.h>
+
+#define TRUE 1
+#define FALSE 0
+#define N_THREADS 3
+#define PHASES 3
+
+typedef enum {
+ ZERO,
+ ONE,
+ TWO,
+ THREE
+} phase_t;
+
+/* Uncomment to turn on debugging output */
+/* #define DEBUG */
+
+/* Locks.
+ */
+int lock_one; /* Main W, others R */
+int lock_two; /* ditto */
+int lock_end[ N_THREADS ]; /* Main R, others R[i] */
+int phase[ N_THREADS ];
+
+/* Routine for each thread to run.
+ */
+void *spin( vp )
+ void * vp;
+{
+ int me = (int) vp;
+ int i;
+
+ lock_end[ me ] = TRUE;
+
+ phase[ me ] = ONE;
+
+ while( lock_one );
+
+ phase[ me ] = TWO;
+
+ while( lock_two );
+
+ phase[ me ] = THREE;
+
+ lock_end[ me ] = FALSE;
+}
+
+void
+do_pass()
+{
+ int i;
+ pthread_t t[ N_THREADS ];
+ int err;
+ int done;
+
+ /* Start N_THREADS threads, then join them so
+ * that they are terminated.
+ */
+ for( i = 0; i < N_THREADS; i++ ) {
+ err = pthread_create( &t[i], NULL, spin, (void *)i );
+ if( err != 0 ) {
+ printf( "== Start/stop, error in thread %d create\n", i );
+ }
+ }
+
+ /* Do phase 1.
+ */
+ lock_one = FALSE;
+
+ /* Do phase 2.
+ */
+ lock_two = FALSE;
+
+ /* Be done.
+ */
+ done = 0;
+ while( !done ) {
+
+ /* Be optimistic.
+ */
+ done = 1;
+ for( i = 0; i < N_THREADS; i++ ) {
+ if( lock_end[i] ) {
+ /* Thread "i" is not ready yet.
+ */
+ done = 0;
+ break;
+ }
+ }
+ }
+
+ /* Finish up
+ */
+ for( i = 0; i < N_THREADS; i++ ) {
+ err = pthread_join(t[i], NULL ); /* Line 105 */
+ if( err != 0 ) { /* Line 106 */
+ printf( "== Start/stop, error in thread %d join\n", i );
+ }
+ }
+
+ i = 10; /* Line 109. Null line for setting bpts on. */
+}
+
+main( argc, argv )
+int argc;
+char **argv;
+{
+ int i;
+
+ /* Init
+ */
+ lock_one = TRUE;
+ lock_two = TRUE;
+ for( i = 0; i < N_THREADS; i++ ) {
+ lock_end[i] = TRUE;
+ phase[i] = ZERO;
+ }
+
+ do_pass();
+ return(0);
+}
diff --git a/gdb/testsuite/gdb.hp/optimize.c b/gdb/testsuite/gdb.hp/optimize.c
new file mode 100644
index 0000000..2a8daa8
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/optimize.c
@@ -0,0 +1,76 @@
+/* Source for debugging optimimzed code test.
+
+ cc -g -O -o optimize optimize.c
+*/
+int callee();
+int test_opt;
+
+int main()
+{
+ int a,b,c,d,e,f,g,h;
+
+ a = 10;;
+
+ /* Value propagate
+ */
+ b = 2 * a + 1;
+ c = 3 * b + 2;
+
+ /* Re-use expressions
+ */
+ d = (2 * a + 1) * (3 * b + 2);
+ e = (2 * a + 1) * (3 * b + 2);
+
+ /* Create dead stores--do lines still exist?
+ */
+ d = (2 * a + 1) * (3 * b + 2);
+ e = (2 * a + 1) * (3 * b + 2);
+ d = (2 * a + 1) * (3 * b + 2);
+ e = (2 * a + 1) * (3 * b + 2);
+
+ /* Alpha and psi motion
+ */
+ if( test_opt ) {
+ f = e - d;
+ f = f--;
+ }
+ else {
+ f = e - d;
+ f = f + d * e;
+ }
+
+ /* Chi and Rho motion
+ */
+ h = 0;
+ do {
+ h++;
+ a = b * c + d * e; /* Chi */
+ f = f + d * e;
+ g = f + d * e; /* Rho */
+ callee( g+1 );
+ test_opt = (test_opt != 1); /* Cycles */
+ } while( g && h < 10);
+
+ /* Opps for tail recursion, unrolling,
+ * folding, evaporating
+ */
+ for( a = 0; a < 100; a++ ) {
+ callee( callee ( callee( a )));
+ callee( callee ( callee( a )));
+ callee( callee ( callee( a )));
+ }
+
+ return callee( test_opt );
+}
+
+/* defined late to keep line numbers the same
+*/
+int callee( x )
+ int x; /* not used! */
+{
+ test_opt++; /* side effect */
+
+ return test_opt;
+}
+
+/* end */ \ No newline at end of file
diff --git a/gdb/testsuite/gdb.hp/quicksort.c b/gdb/testsuite/gdb.hp/quicksort.c
new file mode 100644
index 0000000..b44b828
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/quicksort.c
@@ -0,0 +1,284 @@
+/* BeginSourceFile quicksort.c
+
+ This file is take from the DDE test system. It spawns six
+ threads to do a sort of an array of random numbers.
+
+ The locations marked "quick N" are used in the test "quicksort.exp".
+
+ The locations marked "att N" are used in the test "attach.exp".
+
+ To compile:
+
+ cc -Ae +DA1.0 -g -o quicksort -lpthread quicksort.c
+
+ To run:
+
+ quicksort --normal run
+ quicksort 1 --waits before starting to allow attach
+*/
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <pthread.h>
+
+#define TRUE 1
+#define FALSE 0
+#define SORTSET 100000
+
+/* Uncomment to turn on debugging output */
+/* #define QUICK_DEBUG */
+
+/* Uncomment to turn on wait on each thread create */
+/* #define THREAD_WAIT */
+
+/* Fewer than SORT_DIRECT items are sorted with an insertion sort. */
+#define SORT_DIRECT 20
+
+/* Work at this depth or less generates a separate work item. */
+#define DEFER_DEPTH 6
+
+/* Workpile controller */
+typedef void (*work_proc_t)(void *);
+
+typedef struct workpile_struct {
+ pthread_mutex_t lock; /* mutex for this structure */
+ pthread_cond_t work_wait; /* workers waiting for work */
+ pthread_cond_t finish_wait; /* to wait for workers to finish */
+ int max_pile; /* length of workpile array */
+ work_proc_t worker_proc; /* work procedure */
+ int n_working; /* number of workers working */
+ int n_waiting; /* number of workers waiting for work */
+ int n_pile; /* number of pointers in the workpile */
+ int inp; /* FIFO input pointer */
+ int outp; /* FIFO output pointer */
+ void *pile[1]; /* array of pointers - the workpile */
+} *workpile_t;
+
+typedef struct {
+ float *data; /* Array to sort */
+ int n; /* Number of elements in the array */
+ int depth; /* Depth of recursion */
+ workpile_t wp; /* Workpile to use */
+} quick_sort_args;
+
+/* True if waiting for attach.
+ */
+int wait_here = FALSE;
+
+static workpile_t quick_sort_workpile = NULL;
+
+void *worker(void * wptr);
+
+/* Allocates and initializes a workpile that holds max_pile entries.
+ * worker_proc is called to process each work item on the queue.
+ */
+workpile_t
+work_init(int max_pile, work_proc_t worker_proc, int n_threads)
+{
+ int err;
+ pthread_t t;
+ workpile_t wp = (workpile_t)
+ malloc(sizeof (struct workpile_struct) +
+ (max_pile * sizeof (void *)));
+
+ if (wp != NULL) {
+ pthread_mutex_init(&wp->lock, NULL);
+ pthread_cond_init(&wp->work_wait, NULL);
+ pthread_cond_init(&wp->finish_wait, NULL);
+ wp->max_pile = max_pile;
+ wp->worker_proc = worker_proc;
+ wp->n_working = wp->n_waiting = wp->n_pile = 0;
+ wp->inp = wp->outp = 0;
+ while (n_threads--) {
+ err = pthread_create(&t, NULL,
+ worker, (void *)&wp);
+#ifdef QUICK_DEBUG
+ printf( "== Quicksort: created new thread\n" );
+#ifdef THREAD_WAIT
+ if( n_threads > 0 ) {
+ int i;
+ printf( "== Quicksort: waiting on user input of an integer\n" );
+ scanf( "%d", &i );
+ printf( "== Quicksort: continuing with quicksort\n" );
+ }
+#endif
+#endif
+
+ assert(err == 0); /* quick 1 */
+ }
+ /* All the threads have now been created.
+ */
+ assert( n_threads == -1 ); /* att 1 */
+ if( wait_here ) {
+#ifdef QUICK_DEBUG
+ printf( "== Quicksort: waiting for attach\n" );
+#endif
+ sleep( 25 );
+ }
+ wait_here = 99; /* att 2, otherwise useless */
+ }
+ return (wp); /* quick 2 */
+}
+
+/*
+ * Worker thread routine. Continuously looks for work, calls the
+ * worker_proc associated with the workpile to do work.
+ */
+void *
+worker(void * wptr)
+{
+ workpile_t wp;
+ void *ptr;
+
+ wp = * (workpile_t *) wptr;
+
+ pthread_mutex_lock(&wp->lock);
+ wp->n_working++;
+ for (;;) {
+ while (wp->n_pile == 0) { /* wait for new work */
+ if (--wp->n_working == 0)
+ pthread_cond_signal(&wp->finish_wait);
+ wp->n_waiting++;
+ pthread_cond_wait(&wp->work_wait, &wp->lock);
+ wp->n_waiting--; /* quick 3 */
+ wp->n_working++;
+ }
+ wp->n_pile--;
+ ptr = wp->pile[wp->outp];
+ wp->outp = (wp->outp + 1) % wp->max_pile;
+ pthread_mutex_unlock(&wp->lock);
+ /* Call application worker routine. */
+ (*wp->worker_proc)(ptr);
+ pthread_mutex_lock(&wp->lock); /* quick 4 */
+ }
+ /* NOTREACHED */
+}
+
+/* Puts ptr in workpile. Called at the outset, or within a worker. */
+void
+work_put(workpile_t wp, void *ptr)
+{
+ pthread_mutex_lock(&wp->lock);
+ if (wp->n_waiting) {
+ /* idle workers to be awakened */
+ pthread_cond_signal(&wp->work_wait);
+ }
+ assert(wp->n_pile != wp->max_pile); /* check for room */
+ wp->n_pile++;
+ wp->pile[wp->inp] = ptr;
+ wp->inp = (wp->inp + 1) % wp->max_pile;
+ pthread_mutex_unlock(&wp->lock);
+}
+
+
+/* Wait until all work is done and workers quiesce. */
+void
+work_wait(workpile_t wp)
+{
+ pthread_mutex_lock(&wp->lock);
+ while(wp->n_pile !=0 || wp->n_working != 0)
+ pthread_cond_wait(&wp->finish_wait, &wp->lock);
+ pthread_mutex_unlock(&wp->lock);
+}
+
+void
+quick_sort_aux(float *data, int n, int depth, workpile_t wp, int deferrable)
+{
+ int i,j;
+
+ /* If array small, use insertion sort */
+ if (n <= SORT_DIRECT) {
+ for (j = 1; j < n; j++) {
+ /* data[0..j-1] in sort; find a spot for data[j] */
+ float key = data[j];
+ for (i = j - 1; i >= 0 && key < data[i]; i--)
+ data[i+1] = data[i];
+ data[i+1] = key;
+ }
+ return;
+ }
+ /* Defer this work to work queue if policy says so */
+ if (deferrable && depth <= DEFER_DEPTH) {
+ quick_sort_args *q = (quick_sort_args *)
+ malloc(sizeof (quick_sort_args));
+ assert(q != NULL);
+ q->data = data; q->n = n; q->depth = depth; q->wp = wp;
+ work_put(wp, (void *)q);
+ return;
+ }
+ /* Otherwise, partition data based on a median estimate */
+#define swap(i,j) {float t = data[i]; data[i] = data[j]; data[j] = t;}
+ i = 0;
+ j = n - 1;
+ for (;;) {
+ while (data[i] < data[j]) j--;
+ if (i >= j) break;
+ swap(i, j); i++;
+ while (data[i] < data[j]) i++;
+ if (i >= j) { i = j; break; }
+ swap(i, j); j--;
+ }
+ /* Median value is now at data[i] */
+ /* Partitioned so that data[0..i-1] <= median <= data[i+1..n-1] */
+ quick_sort_aux(data, i, depth+1, wp, TRUE);
+ quick_sort_aux(&data[i+1], n-i-1, depth+1, wp, TRUE);
+}
+/* Called from workpile controller with argument pointing to work. */
+void
+quick_sort_worker(void *a)
+{
+ quick_sort_args *q = (quick_sort_args *)a;
+ quick_sort_aux(q->data, q->n, q->depth, q->wp, FALSE);
+ free(q);
+}
+/* Main routine, called by client to do a sort. */
+void
+quick_sort(float *data, int n)
+{
+ if (quick_sort_workpile == NULL) {
+ int n_threads = 6;
+ quick_sort_workpile = work_init(2 << DEFER_DEPTH,
+ quick_sort_worker, n_threads);
+ assert(quick_sort_workpile != NULL);
+ }
+
+ quick_sort_aux(data, n, 0, quick_sort_workpile, FALSE);
+
+ /* Wait for all work to finish */
+ work_wait(quick_sort_workpile);
+
+#ifdef QUICK_DEBUG
+ printf( "== Quicksort: done sorting\n" );
+#endif
+}
+
+
+main( argc, argv )
+int argc;
+char **argv;
+{
+ float data[SORTSET];
+ int i; int debugging = 0;
+
+ if((argc > 1) && (0 != argv )) {
+ if( 1 == atoi( argv[1] ) )
+ wait_here = TRUE;
+ }
+
+ for(i = 0; i < SORTSET; i++)
+ data[SORTSET -1 -i] = drand48();
+
+ for(i = 0; i < SORTSET; i++)
+ if (debugging)
+ printf("data[%d] = %f\n", i, data[i]);
+
+ quick_sort(data, SORTSET);
+ for(i = 0; i < SORTSET; i++)
+ if (debugging)
+ printf("data[%d] = %f\n", i, data[i]);
+
+ return(0);
+}
+/* EndSourceFile */
diff --git a/gdb/testsuite/gdb.hp/run-hp.c b/gdb/testsuite/gdb.hp/run-hp.c
new file mode 100644
index 0000000..91da1e0
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/run-hp.c
@@ -0,0 +1,70 @@
+/*
+ * This simple classical example of recursion is useful for
+ * testing stack backtraces and such.
+ */
+
+#ifdef vxworks
+
+# include <stdio.h>
+
+/* VxWorks does not supply atoi. */
+static int
+atoi (z)
+ char *z;
+{
+ int i = 0;
+
+ while (*z >= '0' && *z <= '9')
+ i = i * 10 + (*z++ - '0');
+ return i;
+}
+
+/* I don't know of any way to pass an array to VxWorks. This function
+ can be called directly from gdb. */
+
+vxmain (arg)
+char *arg;
+{
+ char *argv[2];
+
+ argv[0] = "";
+ argv[1] = arg;
+ main (2, argv, (char **) 0);
+}
+
+#else /* ! vxworks */
+# include <stdio.h>
+#endif /* ! vxworks */
+
+main (argc, argv, envp)
+int argc;
+char *argv[], **envp;
+{
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+#ifdef FAKEARGV
+ printf ("%d\n", factorial (1));
+#else
+ if (argc != 2) {
+ printf ("usage: factorial <number>\n");
+ return 1;
+ } else {
+ printf ("%d\n", factorial (atoi (argv[1])));
+ }
+#endif
+ return 0;
+}
+
+int factorial (value)
+int value;
+{
+ int local_var;
+
+ if (value > 1) {
+ value *= factorial (value - 1);
+ }
+ local_var = value;
+ return (value);
+}
diff --git a/gdb/testsuite/gdb.hp/start-stop.c b/gdb/testsuite/gdb.hp/start-stop.c
new file mode 100644
index 0000000..dcf2c7e
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/start-stop.c
@@ -0,0 +1,161 @@
+/* BeginSourceFile start_stop.c
+
+ This file creates and deletes threads, so that wdb
+ can be tested on thread delete.
+
+ To compile:
+
+ cc -Ae +DA1.0 -g -o start_stop -lpthread start_stop.c
+
+ To run:
+
+ start_stop --normal run
+ start_stop 1 --waits in each thread to keep it alive.
+*/
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <pthread.h>
+
+#define TRUE 1
+#define FALSE 0
+#define OUTER_LOOP_COUNT 3
+#define N_THREADS 3
+#define MAX_LOCAL_VAL 40
+
+/* Uncomment to turn on debugging output */
+/* #define START_DEBUG */
+
+/* True if waiting for attach.
+ */
+int wait_here;
+
+/* Thing to check for debugging purposes.
+*/
+int a_global = 0;
+
+/* Thread-local storage.
+ */
+__thread int a_thread_local;
+
+/* Check the results of thread-local storage.
+ */
+int thread_local_val[ N_THREADS ];
+int val_debugger_saw[ N_THREADS ];
+
+/* Routine for each thread to run, does nothing.
+ */
+void *spin( vp )
+ void * vp;
+{
+ int me = (int) vp;
+ int i;
+
+#ifdef START_DEBUG
+ printf( "== In thread %d\n", me );
+#endif
+
+ a_global++;
+
+ a_thread_local = 0;
+ for( i = 0; i < a_global; i++ ) {
+ a_thread_local += i;
+ }
+
+ thread_local_val[ me ] = a_thread_local; /* Line 67 */
+
+ printf( "== Thread %d, a_thread_local is %d\n",
+ (int) vp, a_thread_local );
+
+ if( wait_here ) {
+ /* Extend life of thread to extend life of thread-local var.
+ * This makes life easier for human debugging (though you'd
+ * probably want to make the delay longer).
+ */
+ sleep( 5 );
+ }
+}
+
+void
+do_pass( pass )
+ int pass;
+{
+ int i;
+ pthread_t t[ N_THREADS ];
+ int err;
+
+ for( i = 0; i < N_THREADS; i++) {
+ thread_local_val[i] = 0;
+ val_debugger_saw[i] = 0;
+ }
+
+ /* Start N_THREADS threads, then join them so
+ * that they are terminated.
+ */
+ for( i = 0; i < N_THREADS; i++ ) {
+ err = pthread_create( &t[i], NULL, spin, (void *)i );
+ if( err != 0 ) {
+ printf( "== Start/stop, error in thread %d create\n", i );
+ }
+ }
+
+ for( i = 0; i < N_THREADS; i++ ) {
+ err = pthread_join(t[i], NULL ); /* Line 105 */
+ if( err != 0 ) { /* Line 106 */
+ printf( "== Start/stop, error in thread %d join\n", i );
+ }
+ }
+
+ i = 10; /* Line 109. Null line for setting bpts on. */
+
+/*#ifdef START_DEBUG*/
+ for( i = 0; i < N_THREADS; i++) {
+ printf( " Local in thread %d was %d, debugger saw %d\n",
+ i, thread_local_val[i], val_debugger_saw[i] );
+ }
+ printf( "== Pass %d done\n", pass );
+/*#endif*/
+
+}
+
+void
+do_it()
+{
+ /* We want to start some threads and then
+ * end them, and then do it again and again
+ */
+ int i;
+ int dummy;
+
+ for( i = 0; i < OUTER_LOOP_COUNT; i++ ) {
+ do_pass( i );
+ dummy = i; /* Line 134, null line for setting bps on */
+ }
+}
+
+main( argc, argv )
+int argc;
+char **argv;
+{
+ wait_here = FALSE;
+ if((argc > 1) && (0 != argv )) {
+ if( 1 == atoi( argv[1] ) )
+ wait_here = TRUE;
+ }
+
+#ifdef START_DEBUG
+ printf( "== Test starting\n" );
+#endif
+
+ do_it();
+
+#ifdef START_DEBUG
+ printf( "== Test done\n" );
+#endif
+
+ return(0);
+}
+
+/* EndSourceFile */
diff --git a/gdb/testsuite/gdb.hp/sum.c b/gdb/testsuite/gdb.hp/sum.c
new file mode 100644
index 0000000..c28afa5
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/sum.c
@@ -0,0 +1,15 @@
+/* This is a sample program for the HP/DDE debugger. */
+#include <stdio.h>
+
+#ifdef __STDC__
+int sum(int list[], int low, int high)
+#else
+int sum(list, low, high)
+int list[], low, high;
+#endif
+ {
+ int i, s = 0;
+ for (i = low; i <= high; i++)
+ s += list[i];
+ return(s);
+ }
diff --git a/gdb/testsuite/gdb.hp/templates-hp.cc b/gdb/testsuite/gdb.hp/templates-hp.cc
new file mode 100644
index 0000000..25241dc
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/templates-hp.cc
@@ -0,0 +1,785 @@
+/* This test code is from Wendell Baker (wbaker@comet.berkeley.edu) */
+
+#include <stddef.h>
+
+int a_i;
+char a_c;
+double a_d;
+
+typedef void *Pix;
+
+int
+f(int i)
+{ return 0; }
+
+int
+f(int i, char c)
+{ return 0; }
+
+int
+f(int i, char c, double d)
+{ return 0; }
+
+int
+f(int i, char c, double d, char *cs)
+{ return 0; }
+
+int
+f(int i, char c, double d, char *cs, void (*fig)(int, char))
+{ return 0; }
+
+int
+f(int i, char c, double d, char *cs, void (*fig)(char, int))
+{ return 0; }
+
+class R {
+public:
+ int i;
+};
+class S {
+public:
+ int i;
+};
+class T {
+public:
+ int i;
+};
+
+char g(char, const char, volatile char)
+{ return 'c'; }
+char g(R, char&, const char&, volatile char&)
+{ return 'c'; }
+char g(char*, const char*, volatile char*)
+{ return 'c'; }
+char g(S, char*&, const char*&, volatile char*&)
+{ return 'c'; }
+
+signed char g(T,signed char, const signed char, volatile signed char)
+{ return 'c'; }
+signed char g(T, R, signed char&, const signed char&, volatile signed char&)
+{ return 'c'; }
+signed char g(T, signed char*, const signed char*, volatile signed char*)
+{ return 'c'; }
+signed char g(T, S, signed char*&, const signed char*&, volatile signed char*&)
+{ return 'c'; }
+
+unsigned char g(unsigned char, const unsigned char, volatile unsigned char)
+{ return 'c'; }
+unsigned char g(R, unsigned char&, const unsigned char&, volatile unsigned char&)
+{ return 'c'; }
+unsigned char g(unsigned char*, const unsigned char*, volatile unsigned char*)
+{ return 'c'; }
+unsigned char g(S, unsigned char*&, const unsigned char*&, volatile unsigned char*&)
+{ return 'c'; }
+
+short g(short, const short, volatile short)
+{ return 0; }
+short g(R, short&, const short&, volatile short&)
+{ return 0; }
+short g(short*, const short*, volatile short*)
+{ return 0; }
+short g(S, short*&, const short*&, volatile short*&)
+{ return 0; }
+
+signed short g(T, signed short, const signed short, volatile signed short)
+{ return 0; }
+signed short g(T, R, signed short&, const signed short&, volatile signed short&)
+{ return 0; }
+signed short g(T, signed short*, const signed short*, volatile signed short*)
+{ return 0; }
+signed short g(T, S, double, signed short*&, const signed short*&, volatile signed short*&)
+{ return 0; }
+
+unsigned short g(unsigned short, const unsigned short, volatile unsigned short)
+{ return 0; }
+unsigned short g(R, unsigned short&, const unsigned short&, volatile unsigned short&)
+{ return 0; }
+unsigned short g(unsigned short*, const unsigned short*, volatile unsigned short*)
+{ return 0; }
+unsigned short g(S, unsigned short*&, const unsigned short*&, volatile unsigned short*&)
+{ return 0; }
+
+int g(int, const int, volatile int)
+{ return 0; }
+int g(R, int&, const int&, volatile int&)
+{ return 0; }
+int g(int*, const int*, volatile int*)
+{ return 0; }
+int g(S, int*&, const int*&, volatile int*&)
+{ return 0; }
+
+signed int g(T, signed int, const signed int, volatile signed int)
+{ return 0; }
+signed int g(T, R, signed int&, const signed int&, volatile signed int&)
+{ return 0; }
+signed int g(T, signed int*, const signed int*, volatile signed int*)
+{ return 0; }
+signed int g(T, S, signed int*&, const signed int*&, volatile signed int*&)
+{ return 0; }
+
+unsigned int g(unsigned int, const unsigned int, volatile unsigned int)
+{ return 0; }
+unsigned int g(R, unsigned int&, const unsigned int&, volatile unsigned int&)
+{ return 0; }
+unsigned int g(unsigned int*, const unsigned int*, volatile unsigned int*)
+{ return 0; }
+unsigned int g(S, unsigned int*&, const unsigned int*&, volatile unsigned int*&)
+{ return 0; }
+
+long g(long, const long, volatile long)
+{ return 0; }
+long g(R, long&, const long&, volatile long&)
+{ return 0; }
+long g(long*, const long*, volatile long*)
+{ return 0; }
+long g(S, long*&, const long*&, volatile long*&)
+{ return 0; }
+
+signed long g(T, signed long, const signed long, volatile signed long)
+{ return 0; }
+signed long g(T, R, signed long&, const signed long&, volatile signed long&)
+{ return 0; }
+signed long g(T, signed long*, const signed long*, volatile signed long*)
+{ return 0; }
+signed long g(T, S, signed long*&, const signed long*&, volatile signed long*&)
+{ return 0; }
+
+unsigned long g(unsigned long, const unsigned long, volatile unsigned long)
+{ return 0; }
+unsigned long g(S, unsigned long&, const unsigned long&, volatile unsigned long&)
+{ return 0; }
+unsigned long g(unsigned long*, const unsigned long*, volatile unsigned long*)
+{ return 0; }
+unsigned long g(S, unsigned long*&, const unsigned long*&, volatile unsigned long*&)
+{ return 0; }
+
+#ifdef __GNUC__
+long long g(long long, const long long, volatile long long)
+{ return 0; }
+long long g(S, long long&, const long long&, volatile long long&)
+{ return 0; }
+long long g(long long*, const long long*, volatile long long*)
+{ return 0; }
+long long g(R, long long*&, const long long*&, volatile long long*&)
+{ return 0; }
+
+signed long long g(T, signed long long, const signed long long, volatile signed long long)
+{ return 0; }
+signed long long g(T, R, signed long long&, const signed long long&, volatile signed long long&)
+{ return 0; }
+signed long long g(T, signed long long*, const signed long long*, volatile signed long long*)
+{ return 0; }
+signed long long g(T, S, signed long long*&, const signed long long*&, volatile signed long long*&)
+{ return 0; }
+
+unsigned long long g(unsigned long long, const unsigned long long, volatile unsigned long long)
+{ return 0; }
+unsigned long long g(R, unsigned long long*, const unsigned long long*, volatile unsigned long long*)
+{ return 0; }
+unsigned long long g(unsigned long long&, const unsigned long long&, volatile unsigned long long&)
+{ return 0; }
+unsigned long long g(S, unsigned long long*&, const unsigned long long*&, volatile unsigned long long*&)
+{ return 0; }
+#endif
+
+float g(float, const float, volatile float)
+{ return 0; }
+float g(char, float&, const float&, volatile float&)
+{ return 0; }
+float g(float*, const float*, volatile float*)
+{ return 0; }
+float g(char, float*&, const float*&, volatile float*&)
+{ return 0; }
+
+double g(double, const double, volatile double)
+{ return 0; }
+double g(char, double&, const double&, volatile double&)
+{ return 0; }
+double g(double*, const double*, volatile double*)
+{ return 0; }
+double g(char, double*&, const double*&, volatile double*&)
+{ return 0; }
+
+#ifdef __GNUC__
+long double g(long double, const long double, volatile long double)
+{ return 0; }
+long double g(char, long double&, const long double&, volatile long double&)
+{ return 0; }
+long double g(long double*, const long double*, volatile long double*)
+{ return 0; }
+long double g(char, long double*&, const long double*&, volatile long double*&)
+{ return 0; }
+#endif
+
+class c {
+public:
+ c(int) {};
+ int i;
+};
+
+class c g(c, const c, volatile c)
+{ return 0; }
+c g(char, c&, const c&, volatile c&)
+{ return 0; }
+c g(c*, const c*, volatile c*)
+{ return 0; }
+c g(char, c*&, const c*&, volatile c*&)
+{ return 0; }
+
+/*
+void h(char = 'a')
+{ }
+void h(char, signed char = 'a')
+{ }
+void h(unsigned char = 'a')
+{ }
+*/
+/*
+void h(char = (char)'a')
+{ }
+void h(char, signed char = (signed char)'a')
+{ }
+void h(unsigned char = (unsigned char)'a')
+{ }
+
+
+void h(short = (short)43)
+{ }
+void h(char, signed short = (signed short)43)
+{ }
+void h(unsigned short = (unsigned short)43)
+{ }
+
+void h(int = (int)43)
+{ }
+void h(char, signed int = (signed int)43)
+{ }
+void h(unsigned int = (unsigned int)43)
+{ }
+
+
+void h(long = (long)43)
+{ }
+void h(char, signed long = (signed long)43)
+{ }
+void h(unsigned long = (unsigned long)43)
+{ }
+
+#ifdef __GNUC__
+void h(long long = 43)
+{ }
+void h(char, signed long long = 43)
+{ }
+void h(unsigned long long = 43)
+{ }
+#endif
+
+void h(float = 4.3e-10)
+{ }
+void h(double = 4.3)
+{ }
+#ifdef __GNUC__
+void h(long double = 4.33e33)
+{ }
+#endif
+*/
+void printf(const char *format, ... )
+{
+ // elipsis
+}
+
+class T1 {
+public:
+ static void* operator new(size_t);
+ static void operator delete(void *pointer);
+
+ void operator=(const T1&);
+ T1& operator=(int);
+
+ int operator==(int) const;
+ int operator==(const T1&) const;
+ int operator!=(int) const;
+ int operator!=(const T1&) const;
+
+ int operator<=(int) const;
+ int operator<=(const T1&) const;
+ int operator<(int) const;
+ int operator<(const T1&) const;
+ int operator>=(int) const;
+ int operator>=(const T1&) const;
+ int operator>(int) const;
+ int operator>(const T1&) const;
+
+ void operator+(int) const;
+ T1& operator+(const T1&) const;
+ void operator+=(int) const;
+ T1& operator+=(const T1&) const;
+
+ T1& operator++() const;
+
+ void operator-(int) const;
+ T1& operator-(const T1&) const;
+ void operator-=(int) const;
+ T1& operator-=(const T1&) const;
+
+ T1& operator--() const;
+
+ void operator*(int) const;
+ T1& operator*(const T1&) const;
+ void operator*=(int) const;
+ T1& operator*=(const T1&) const;
+
+ void operator/(int) const;
+ T1& operator/(const T1&) const;
+ void operator/=(int) const;
+ T1& operator/=(const T1&) const;
+
+ void operator%(int) const;
+ T1& operator%(const T1&) const;
+ void operator%=(int) const;
+ T1& operator%=(const T1&) const;
+
+ void operator&&(int) const;
+ T1& operator&&(const T1&) const;
+
+ void operator||(int) const;
+ T1& operator||(const T1&) const;
+
+ void operator&(int) const;
+ T1& operator&(const T1&) const;
+ void operator&=(int) const;
+ T1& operator&=(const T1&) const;
+
+ void operator|(int) const;
+ T1& operator|(const T1&) const;
+ void operator|=(int) const;
+ T1& operator|=(const T1&) const;
+
+ void operator^(int) const;
+ T1& operator^(const T1&) const;
+ void operator^=(int) const;
+ T1& operator^=(const T1&) const;
+
+ T1& operator!() const;
+ T1& operator~() const;
+};
+
+void*
+T1::operator new(size_t)
+{ return 0; }
+
+void
+T1::operator delete(void *pointer)
+{ }
+
+class T2 {
+public:
+ T2(int i): integer(i)
+ { }
+ int integer;
+};
+
+int operator==(const T2&, const T2&)
+{ return 0; }
+int operator==(const T2&, char)
+{ return 0; }
+int operator!=(const T2&, const T2&)
+{ return 0; }
+int operator!=(const T2&, char)
+{ return 0; }
+
+int operator<=(const T2&, const T2&)
+{ return 0; }
+int operator<=(const T2&, char)
+{ return 0; }
+int operator<(const T2&, const T2&)
+{ return 0; }
+int operator<(const T2&, char)
+{ return 0; }
+int operator>=(const T2&, const T2&)
+{ return 0; }
+int operator>=(const T2&, char)
+{ return 0; }
+int operator>(const T2&, const T2&)
+{ return 0; }
+int operator>(const T2&, char)
+{ return 0; }
+
+T2 operator+(const T2 t, int i)
+{ return t.integer + i; }
+T2 operator+(const T2 a, const T2& b)
+{ return a.integer + b.integer; }
+T2& operator+=(T2& t, int i)
+{ t.integer += i; return t; }
+T2& operator+=(T2& a, const T2& b)
+{ a.integer += b.integer; return a; }
+
+T2 operator-(const T2 t, int i)
+{ return t.integer - i; }
+T2 operator-(const T2 a, const T2& b)
+{ return a.integer - b.integer; }
+T2& operator-=(T2& t, int i)
+{ t.integer -= i; return t; }
+T2& operator-=(T2& a, const T2& b)
+{ a.integer -= b.integer; return a; }
+
+T2 operator*(const T2 t, int i)
+{ return t.integer * i; }
+T2 operator*(const T2 a, const T2& b)
+{ return a.integer * b.integer; }
+T2& operator*=(T2& t, int i)
+{ t.integer *= i; return t; }
+T2& operator*=(T2& a, const T2& b)
+{ a.integer *= b.integer; return a; }
+
+T2 operator/(const T2 t, int i)
+{ return t.integer / i; }
+T2 operator/(const T2 a, const T2& b)
+{ return a.integer / b.integer; }
+T2& operator/=(T2& t, int i)
+{ t.integer /= i; return t; }
+T2& operator/=(T2& a, const T2& b)
+{ a.integer /= b.integer; return a; }
+
+T2 operator%(const T2 t, int i)
+{ return t.integer % i; }
+T2 operator%(const T2 a, const T2& b)
+{ return a.integer % b.integer; }
+T2& operator%=(T2& t, int i)
+{ t.integer %= i; return t; }
+T2& operator%=(T2& a, const T2& b)
+{ a.integer %= b.integer; return a; }
+
+template<class T>
+class T5 {
+public:
+ T5(int);
+ T5(const T5<T>&);
+ ~T5();
+ static void* operator new(size_t);
+ static void operator delete(void *pointer);
+ int value();
+
+ static T X;
+ T x;
+ int val;
+};
+
+template<class T>
+T5<T>::T5(int v)
+{ val = v; }
+
+template<class T>
+T5<T>::T5(const T5<T>&)
+{}
+
+template<class T>
+T5<T>::~T5()
+{}
+
+template<class T>
+void*
+T5<T>::operator new(size_t)
+{ return 0; }
+
+template<class T>
+void
+T5<T>::operator delete(void *pointer)
+{ }
+
+template<class T>
+int
+T5<T>::value()
+{ return val; }
+
+
+#if ! defined(__GNUC__) || defined(GCC_BUG)
+template<class T>
+T T5<T>::X;
+#endif
+
+
+
+
+T5<char> t5c(1);
+T5<int> t5i(2);
+T5<int (*)(char, void *)> t5fi1(3);
+T5<int (*)(int, double **, void *)> t5fi2(4);
+
+
+
+
+
+
+class x {
+public:
+ int (*manage[5])(double,
+ void *(*malloc)(unsigned size),
+ void (*free)(void *pointer));
+ int (*device[5])(int open(const char *, unsigned mode, unsigned perms, int extra = 0),
+ int *(*read)(int fd, void *place, unsigned size),
+ int *(*write)(int fd, void *place, unsigned size),
+ void (*close)(int fd));
+};
+T5<x> t5x(5);
+
+#if !defined(__GNUC__) || (__GNUC__ >= 2 && __GNUC_MINOR__ >= 6)
+template class T5<char>;
+template class T5<int>;
+template class T5<int (*)(char, void *)>;
+template class T5<int (*)(int, double **, void *)>;
+template class T5<x>;
+#endif
+
+class T7 {
+public:
+ static int get();
+ static void put(int);
+};
+
+int
+T7::get()
+{ return 1; }
+
+void
+T7::put(int i)
+{
+ // nothing
+}
+
+// More template kinds. GDB 4.16 didn't handle these, but
+// Wildebeest does. Note: Assuming HP aCC is used to compile
+// this file; with g++ or HP cfront or other compilers the
+// demangling may not get done correctly.
+
+// Ordinary template, to be instantiated with different types
+template<class T>
+class Foo {
+public:
+ int x;
+ T t;
+ T foo (int, T);
+};
+
+
+template<class T> T Foo<T>::foo (int i, T tt)
+{
+ return tt;
+}
+
+// Template with int parameter
+
+template<class T, int sz>
+class Bar {
+public:
+ int x;
+ T t;
+ T bar (int, T);
+};
+
+
+template<class T, int sz> T Bar<T, sz>::bar (int i, T tt)
+{
+ if (i < sz)
+ return tt;
+ else
+ return 0;
+}
+
+// function template with int parameter
+template<class T> int dummy (T tt, int i)
+{
+ return tt;
+}
+
+// Template with partial specializations
+template<class T1, class T2>
+class Spec {
+public:
+ int x;
+ T1 spec (T2);
+};
+
+template<class T1, class T2>
+T1 Spec<T1, T2>::spec (T2 t2)
+{
+ return 0;
+}
+
+template<class T>
+class Spec<T, T*> {
+public:
+ int x;
+ T spec (T*);
+};
+
+template<class T>
+T Spec<T, T*>::spec (T * tp)
+{
+ return *tp;
+}
+
+// Template with char parameter
+template<class T, char sz>
+class Baz {
+public:
+ int x;
+ T t;
+ T baz (int, T);
+};
+
+template<class T, char sz> T Baz<T, sz>::baz (int i, T tt)
+{
+ if (i < sz)
+ return tt;
+ else
+ return 0;
+}
+
+// Template with char * parameter
+template<class T, char * sz>
+class Qux {
+public:
+ int x;
+ T t;
+ T qux (int, T);
+};
+
+template<class T, char * sz> T Qux<T, sz>::qux (int i, T tt)
+{
+ if (sz[0] == 'q')
+ return tt;
+ else
+ return 0;
+}
+
+// Template with a function pointer parameter
+template<class T, int (*f)(int) >
+class Qux1 {
+public:
+ int x;
+ T t;
+ T qux (int, T);
+};
+
+template<class T, int (*f)(int)> T Qux1<T, f>::qux (int i, T tt)
+{
+ if (f != 0)
+ return tt;
+ else
+ return 0;
+}
+
+// Some functions to provide as arguments to template
+int gf1 (int a) {
+ return a * 2 + 13;
+}
+int gf2 (int a) {
+ return a * 2 + 26;
+}
+
+char string[3];
+
+
+// Template for nested instantiations
+
+template<class T>
+class Garply {
+public:
+ int x;
+ T t;
+ T garply (int, T);
+};
+
+template<class T> T Garply<T>::garply (int i, T tt)
+{
+ if (i > x)
+ return tt;
+ else
+ {
+ x += i;
+ return tt;
+ }
+}
+
+
+int main()
+{
+ int i;
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ i = i + 1;
+
+ // New tests added here
+
+ Foo<int> fint;
+ Foo<char> fchar;
+ Foo<volatile char *> fvpchar;
+
+ Bar<int, 33> bint;
+ Bar<int, (4 > 3)> bint2;
+
+ Baz<int, 's'> bazint;
+ Baz<char, 'a'> bazint2;
+
+ Qux<char, string> quxint2;
+ Qux<int, string> quxint;
+
+ Qux1<int, gf1> qux11;
+
+ int x = fint.foo(33, 47);
+ char c = fchar.foo(33, 'x');
+ volatile char * cp = fvpchar.foo(33, 0);
+
+ int y = dummy<int> (400, 600);
+
+ int z = bint.bar(55, 66);
+ z += bint2.bar(55, 66);
+
+ c = bazint2.baz(4, 'y');
+ c = quxint2.qux(4, 'z');
+
+ y = bazint.baz(4,3);
+ y = quxint.qux(4, 22);
+ y += qux11.qux(4, 22);
+
+ y *= gf1(y) - gf2(y);
+
+ Spec<int, char> sic;
+ Spec<int, int *> siip;
+
+ sic.spec ('c');
+ siip.spec (&x);
+
+ Garply<int> f;
+ Garply<char> fc;
+ f.x = 13;
+
+ Garply<Garply<char> > nf;
+ nf.x = 31;
+
+ x = f.garply (3, 4);
+
+ fc = nf.garply (3, fc);
+
+ y = x + fc.x;
+
+
+ return 0;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/gdb/testsuite/gdb.hp/thread-local-in-lib.c b/gdb/testsuite/gdb.hp/thread-local-in-lib.c
new file mode 100644
index 0000000..c42dce9
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/thread-local-in-lib.c
@@ -0,0 +1,79 @@
+/* Thread local in a library.
+*/
+#include "thread-local-in-lib.h"
+/*
+ * #define NTHREADS 4
+ * #define NUM_ELEMS 12
+ */
+
+extern void* adder( void * );
+
+pthread_mutex_t mutex; /* mutex for protecting global data total */
+
+int numbers[NUM_ELEMS] = {5, 4, 3, 2, 1, 6, 7, 8, 9, 10, 12, 11};
+int total = 0;
+
+int debugger_saw[NTHREADS][ELEMS_PER_THREAD]; /* [4][3] */
+int the_code_saw[NTHREADS][ELEMS_PER_THREAD];
+
+int get_number(i)
+int i;
+{
+ /* sleep to force context switch to another thread in non-MP system
+ * so that TLS symbols are used by multiple threads concurrently
+ * in some way.
+ */
+ sleep(1);
+ return numbers[i];
+}
+
+main()
+{
+ pthread_t thread[NTHREADS];
+ void *status;
+ int i, j, ret;
+
+ printf("== Thread: Test started\n");
+
+ for( i = 0; i < NTHREADS; i++ ) {
+ for( j = 0; j < ELEMS_PER_THREAD; j++ ) {
+ debugger_saw[i][j] = 0;
+ the_code_saw[i][j] = 0;
+ }
+ }
+
+ ret = pthread_mutex_init(&mutex, NULL);
+ if (ret != 0) {
+ printf("== Thread: pthread_mutex_init() error: %d\n", ret);
+ exit(1);
+ }
+
+ for (i=0; i < NTHREADS; i++) {
+ ret = pthread_create( &thread[i],
+ NULL,
+ adder,
+ (void *) i);
+ if (ret != 0) {
+ printf("== Thread: pthread_create() error: %d\n", ret);
+ exit(1);
+ }
+ printf("== Thread: thread %d created\n", i);
+ }
+
+ for (i=0; i < NTHREADS; i++) {
+ pthread_join( thread[i], &status);
+ }
+
+ printf("== Thread: total = %d\n", total); /* Expect "78" */
+
+ for( i = 0; i < NTHREADS; i++ ) {
+ for( j = 0; j < ELEMS_PER_THREAD; j++ ) {
+ printf( "== Thread: the debugger saw %d, the program saw %d\n",
+ debugger_saw[i][j],
+ the_code_saw[i][j] );
+ }
+ }
+
+ printf("== Thread: Test ended\n");
+ exit(0);
+}
diff --git a/gdb/testsuite/gdb.hp/thread-local-in-lib.h b/gdb/testsuite/gdb.hp/thread-local-in-lib.h
new file mode 100644
index 0000000..c9395df
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/thread-local-in-lib.h
@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include <pthread.h>
+
+#define NTHREADS 4
+#define NUM_ELEMS 12
+
+#define ELEMS_PER_THREAD (NUM_ELEMS/NTHREADS)
diff --git a/gdb/testsuite/gdb.hp/thread-local-in-lib.lib.c b/gdb/testsuite/gdb.hp/thread-local-in-lib.lib.c
new file mode 100644
index 0000000..0fe03b3
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/thread-local-in-lib.lib.c
@@ -0,0 +1,92 @@
+#include <stdio.h>
+
+/* Library code for thread local in lib test.
+*/
+#include "thread-local-in-lib.h"
+
+extern pthread_mutex_t mutex;
+extern int get_number();
+extern int total;
+extern int the_code_saw[NTHREADS][ELEMS_PER_THREAD];
+
+/* The debugger should see this without a declaration.
+ *
+ * extern int debugger_saw[NTHREADS][ELEMS_PER_THREAD];
+ */
+
+/* The actual thread locals.
+ */
+__thread int sum;
+__thread int x[ ELEMS_PER_THREAD ]; /* [3] */
+
+void sumup()
+{
+ int j;
+
+ sum = 0;
+ for (j = 0; j < ELEMS_PER_THREAD; j++) {
+ sum += x[j];
+ }
+
+ if( sum == x[0] )
+ /* It won't be "==", but this lets us set a breakpoint
+ * and look at the thread-local storage.
+ */
+ sum++;
+
+ x[0] = x[2]; /* Another no-op for debugger use */
+}
+
+void *adder( vid )
+ void * vid;
+{
+ int id;
+ int i, j;
+ int ret;
+
+ id = (int) vid;
+
+ /* printf( "== Thread: Welcome to adder %d\n", id ); */
+
+ for (j = 0; j < ELEMS_PER_THREAD; j++) {
+ x[j] = 0;
+ }
+
+ for (i = id, j = 0; i < NUM_ELEMS; i += NTHREADS, j++ ) {
+
+ /* printf( "== Thread: id %d, i %d, j %d\n", id, i, j );
+ fflush( stdout ); */
+
+ x[j] = get_number(i); /* {0,1,2,3} +0, +4, +8 */
+
+ /* Record for posterity; the debugger will gather
+ * the same data here, using "x[j]".
+ */
+ the_code_saw[ id ][ j ] = x[j];
+
+ /* printf( "== Thread %d, sample %d, val %d, i %d\n", id, j, x[j],i );
+ fflush( stdout ); */
+ }
+
+ sumup();
+ /* printf("== Thread: adder %d contributes total %d\n", id, sum); */
+
+ /* protect global data */
+ ret = pthread_mutex_lock(&mutex);
+ if (ret != 0) {
+ printf("== Thread: pthread_mutex_lock() error: %d\n", ret);
+ exit(1);
+ }
+
+ total += sum;
+
+ ret = pthread_mutex_unlock(&mutex);
+ if (ret != 0) {
+ printf("== Thread: pthread_mutex_unlock() error: %d\n", ret);
+ exit(1);
+ }
+
+ if( NTHREADS != 4 || ELEMS_PER_THREAD != 3 || NUM_ELEMS != 12 ) {
+ printf( "** ERROR in test code **\n" );
+ }
+}
diff --git a/gdb/testsuite/gdb.hp/vforked-program.c b/gdb/testsuite/gdb.hp/vforked-program.c
new file mode 100644
index 0000000..52c6cd2
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/vforked-program.c
@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+main()
+{
+ printf("Hello from vforked_program...\n");
+}
diff --git a/gdb/testsuite/gdb.hp/virtfunc-hp.cc b/gdb/testsuite/gdb.hp/virtfunc-hp.cc
new file mode 100644
index 0000000..6552a62
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/virtfunc-hp.cc
@@ -0,0 +1,192 @@
+// Pls try the following program on virtual functions and try to do print on
+// most of the code in main(). Almost none of them works !
+
+//
+// The inheritance structure is:
+//
+// V : VA VB
+// A : (V)
+// B : A
+// D : AD (V)
+// C : (V)
+// E : B (V) D C
+//
+
+class VA
+{
+public:
+ int va;
+};
+
+class VB
+{
+public:
+ int vb;
+ int fvb();
+ virtual vvb();
+};
+
+class V : public VA, public VB
+{
+public:
+ int f();
+ virtual vv();
+ int w;
+};
+
+class A : virtual public V
+{
+public:
+ virtual int f();
+private:
+ int a;
+};
+
+class B : public A
+{
+public:
+ int f();
+private:
+ int b;
+};
+
+class C : public virtual V
+{
+public:
+ int c;
+};
+
+class AD
+{
+public:
+ virtual int vg() = 0;
+};
+
+class D : public AD, virtual public V
+{
+public:
+ static void s();
+ virtual int vg();
+ virtual int vd();
+ int fd();
+ int d;
+};
+
+class E : public B, virtual public V, public D, public C
+{
+public:
+ int f();
+ int vg();
+ int vv();
+ int e;
+};
+
+D dd;
+D* ppd = &dd;
+AD* pAd = &dd;
+
+A a;
+B b;
+C c;
+D d;
+E e;
+V v;
+VB vb;
+
+
+A* pAa = &a;
+A* pAe = &e;
+
+B* pBe = &e;
+
+D* pDd = &d;
+D* pDe = &e;
+
+V* pVa = &a;
+V* pVv = &v;
+V* pVe = &e;
+V* pVd = &d;
+
+AD* pADe = &e;
+
+E* pEe = &e;
+
+VB* pVB = &vb;
+
+void init()
+{
+ a.vb = 1;
+ b.vb = 2;
+ c.vb = 3;
+ d.vb = 4;
+ e.vb = 5;
+ v.vb = 6;
+ vb.vb = 7;
+
+ d.d = 1;
+ e.d = 2;
+}
+
+extern "C" printf(const char *, ...);
+
+int all_count = 0;
+int failed_count = 0;
+
+#define TEST(EXPR, EXPECTED) \
+ ret = EXPR; \
+ if (ret != EXPECTED) {\
+ printf("Failed %s is %d, should be %d!\n", #EXPR, ret, EXPECTED); \
+ failed_count++; } \
+ all_count++;
+
+int ret;
+
+void test_calls()
+{
+ TEST(pAe->f(), 20);
+ TEST(pAa->f(), 1);
+
+ TEST(pDe->vg(), 202);
+ TEST(pADe->vg(), 202);
+ TEST(pDd->vg(), 101);
+
+ TEST(pEe->vvb(), 411);
+
+ TEST(pVB->vvb(), 407);
+
+ TEST(pBe->vvb(), 411);
+ TEST(pDe->vvb(), 411);
+
+ TEST(pEe->vd(), 282);
+ TEST(pEe->fvb(), 311);
+
+ TEST(pEe->D::vg(), 102);
+ printf("Did %d tests, of which %d failed.\n", all_count, failed_count);
+}
+
+int main()
+{
+
+ init();
+
+ e.w = 7;
+ e.vb = 11;
+
+ test_calls();
+ return 0;
+
+}
+
+int A::f() {return 1;}
+int B::f() {return 2;}
+void D::s() {}
+int E::f() {return 20;}
+int D::vg() {return 100+d;}
+int E::vg() {return 200+d;}
+int V::f() {return 600+w;}
+int V::vv() {return 400+w;}
+int E::vv() {return 450+w;}
+int D::fd() {return 250+d;}
+int D::vd() {return 280+d;}
+int VB::fvb() {return 300+vb;}
+int VB::vvb() {return 400+vb;}
diff --git a/gdb/testsuite/gdb.hp/watchpoint-hp.c b/gdb/testsuite/gdb.hp/watchpoint-hp.c
new file mode 100644
index 0000000..7336fe2
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/watchpoint-hp.c
@@ -0,0 +1,166 @@
+#include <stdio.h>
+/*
+ * Since using watchpoints can be very slow, we have to take some pains to
+ * ensure that we don't run too long with them enabled or we run the risk
+ * of having the test timeout. To help avoid this, we insert some marker
+ * functions in the execution stream so we can set breakpoints at known
+ * locations, without worrying about invalidating line numbers by changing
+ * this file. We use null bodied functions are markers since gdb does
+ * not support breakpoints at labeled text points at this time.
+ *
+ * One place we need is a marker for when we start executing our tests
+ * instructions rather than any process startup code, so we insert one
+ * right after entering main(). Another is right before we finish, before
+ * we start executing any process termination code.
+ *
+ * Another problem we have to guard against, at least for the test
+ * suite, is that we need to ensure that the line that causes the
+ * watchpoint to be hit is still the current line when gdb notices
+ * the hit. Depending upon the specific code generated by the compiler,
+ * the instruction after the one that triggers the hit may be part of
+ * the same line or part of the next line. Thus we ensure that there
+ * are always some instructions to execute on the same line after the
+ * code that should trigger the hit.
+ */
+
+int count = -1;
+int ival1 = -1;
+int ival2 = -1;
+int ival3 = -1;
+int ival4 = -1;
+int ival5 = -1;
+char buf[10];
+struct foo
+{
+ int val;
+};
+struct foo struct1, struct2, *ptr1, *ptr2;
+
+int doread = 0;
+
+void marker1 ()
+{
+}
+
+void marker2 ()
+{
+}
+
+void marker4 ()
+{
+}
+
+void marker5 ()
+{
+}
+
+void marker6 ()
+{
+}
+
+void recurser (x)
+ int x;
+{
+ int local_x;
+
+ if (x > 0)
+ recurser (x-1);
+ local_x = x;
+}
+
+void
+func2 ()
+{
+ int local_a;
+ static int static_b;
+
+ ival5++;
+ local_a = ival5;
+ static_b = local_a;
+}
+
+int
+func1 ()
+{
+ /* The point of this is that we will set a breakpoint at this call.
+
+ Then, if DECR_PC_AFTER_BREAK equals the size of a function call
+ instruction (true on a sun3 if this is gcc-compiled--FIXME we
+ should use asm() to make it work for any compiler, present or
+ future), then we will end up branching to the location just after
+ the breakpoint. And we better not confuse that with hitting the
+ breakpoint. */
+ func2 ();
+ return 73;
+}
+
+int main ()
+{
+ struct1.val = 1;
+ struct2.val = 2;
+ ptr1 = &struct1;
+ ptr2 = &struct2;
+ marker1 ();
+ func1 ();
+ for (count = 0; count < 4; count++) {
+ ival1 = count;
+ ival3 = count; ival4 = count;
+ }
+ ival1 = count; /* Outside loop */
+ ival2 = count;
+ ival3 = count; ival4 = count;
+ marker2 ();
+ if (doread)
+ {
+ static char msg[] = "type stuff for buf now:";
+ write (1, msg, sizeof (msg) - 1);
+ read (0, &buf[0], 5);
+ }
+ marker4 ();
+
+ /* We have a watchpoint on ptr1->val. It should be triggered if
+ ptr1's value changes. */
+ ptr1 = ptr2;
+
+ /* This should not trigger the watchpoint. If it does, then we
+ used the wrong value chain to re-insert the watchpoints or we
+ are not evaluating the watchpoint expression correctly. */
+ struct1.val = 5;
+ marker5 ();
+
+ /* We have a watchpoint on ptr1->val. It should be triggered if
+ ptr1's value changes. */
+ ptr1 = ptr2;
+
+ /* This should not trigger the watchpoint. If it does, then we
+ used the wrong value chain to re-insert the watchpoints or we
+ are not evaluating the watchpoint expression correctly. */
+ struct1.val = 5;
+ marker5 ();
+
+ /* We're going to watch locals of func2, to see that out-of-scope
+ watchpoints are detected and properly deleted.
+ */
+ marker6 ();
+
+ /* This invocation is used for watches of a single
+ local variable. */
+ func2 ();
+
+ /* This invocation is used for watches of an expression
+ involving a local variable. */
+ func2 ();
+
+ /* This invocation is used for watches of a static
+ (non-stack-based) local variable. */
+ func2 ();
+
+ /* This invocation is used for watches of a local variable
+ when recursion happens.
+ */
+ marker6 ();
+ recurser (2);
+
+ marker6 ();
+ return 0;
+}
diff --git a/gdb/testsuite/gdb.hp/xdb.c b/gdb/testsuite/gdb.hp/xdb.c
new file mode 100644
index 0000000..e3e3fc2
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/xdb.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+int callee( x )
+int x;
+{
+ int y = x * x;
+ return (y - 2);
+}
+
+main()
+{
+ int i;
+ for (i = 1; i < 10; i++)
+ {
+ printf( "%d ", callee( i ));
+
+ }
+ printf( " Goodbye!\n" );
+
+}
diff --git a/gdb/testsuite/gdb.hp/xdb0.c b/gdb/testsuite/gdb.hp/xdb0.c
new file mode 100644
index 0000000..fa5c76f
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/xdb0.c
@@ -0,0 +1,42 @@
+#include "xdb0.h"
+
+main ()
+{
+ int x;
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ x = 0;
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+ foo (x++);
+}
+
+static void
+unused ()
+{
+ /* Not used for anything */
+}
diff --git a/gdb/testsuite/gdb.hp/xdb0.h b/gdb/testsuite/gdb.hp/xdb0.h
new file mode 100644
index 0000000..c4d337c
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/xdb0.h
@@ -0,0 +1,36 @@
+/* An include file that actually causes code to be generated in the
+ including file. This is known to cause problems on some systems. */
+
+static void
+foo (x)
+int x;
+{
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+ bar (x++);
+}
diff --git a/gdb/testsuite/gdb.hp/xdb1.c b/gdb/testsuite/gdb.hp/xdb1.c
new file mode 100644
index 0000000..51632b9
--- /dev/null
+++ b/gdb/testsuite/gdb.hp/xdb1.c
@@ -0,0 +1,33 @@
+void
+bar (x)
+int x;
+{
+ printf ("%d\n", x);
+
+ long_line ();
+}
+
+static void
+unused ()
+{
+ /* Not used for anything */
+}
+
+
+/* This routine has a very long line that will break searching in older
+ versions of GDB. */
+
+long_line ()
+{
+ oof (67);
+
+ oof (6789);
+
+ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 5 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 10 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 15 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 20 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 25 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 30 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 35 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 40 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 45 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 50 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 55 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 60 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* 65 */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (12); /* */ oof (12); oof (12); oof (12); oof (12); oof (12); oof (1234); /* 70 */
+}
+
+oof (n)
+ int n;
+{
+ return n + 1;
+}