[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.hp / gdb.base-hp / callfwmall.c

/* 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

# include <string.h>

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 = (char *)"string 1";
char *string_val2 = (char *)"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. */
#ifdef PROTOTYPES
int add (int a, int b)
#else
int add (a, b) int a, b;
#endif
{
  return (a + b);
}

#ifdef PROTOTYPES
int doubleit (int a)
#else
int doubleit (a)
int a;
#endif
{
  return (a + a);
}

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;

#ifdef PROTOTYPES
int t_enum_value1 (enum enumtype enum_arg)
#else
t_enum_value1 (enum_arg)
enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val1);
}

#ifdef PROTOTYPES
int t_enum_value2 (enum enumtype enum_arg)
#else
t_enum_value2 (enum_arg)
enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val2);
}

#ifdef PROTOTYPES
int t_enum_value3 (enum enumtype enum_arg)
#else
t_enum_value3 (enum_arg)
enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val3);
}

/* A function that takes a vector of integers (along with an explicit
   count) and returns their sum. */

#ifdef PROTOTYPES
int sum_args (int argc, int argv[])
#else
int sum_args (argc, argv)
int argc;
int argv[];
#endif
{
  int sumval = 0;
  int idx;

  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 */

#ifdef PROTOTYPES
char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
char  *t_structs_a (struct struct1 tstruct)
{
  static char buf[8];
  strcpy (buf, tstruct.a);
  return buf;
}
#else
char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
char  *t_structs_a (tstruct) struct struct1 tstruct;
{
  static char buf[8];
  strcpy (buf, tstruct.a);
  return buf;
}
#endif

/* Test that calling functions works if there are a lot of arguments.  */
#ifdef PROTOTYPES
int sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
#else
int
sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
     int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
#endif
{
  return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
}

/* Gotta have a main to be able to generate a linked, runnable
   executable, and also provide a useful place to set a breakpoint. */

#ifdef PROTOTYPES
int main()
#else
main ()
#endif
{
  t_structs_c(struct_val1);
  return 0;
  
}

/* 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. */

#ifdef PROTOTYPES
int t_char_values (char char_arg1, char char_arg2)
#else
int t_char_values (char_arg1, char_arg2)
char char_arg1, char_arg2;
#endif
{
  return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
}

int
#ifdef PROTOTYPES
t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
		char arg6, short arg7, int arg8, short arg9, short arg10)
#else
t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
     char arg1;
     short arg2;
     int arg3;
     char arg4;
     short arg5;
     char arg6;
     short arg7;
     int arg8;
     short arg9;
     short arg10;
#endif
{
  return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
}

#ifdef PROTOTYPES
int t_short_values (short short_arg1, short short_arg2)
#else
int t_short_values (short_arg1, short_arg2)
short short_arg1, short_arg2;
#endif
{
  return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
}

#ifdef PROTOTYPES
int t_int_values (int int_arg1, int int_arg2)
#else
int t_int_values (int_arg1, int_arg2)
int int_arg1, int_arg2;
#endif
{
  return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
}

#ifdef PROTOTYPES
int t_long_values (long long_arg1, long long_arg2)
#else
int t_long_values (long_arg1, long_arg2)
long long_arg1, long_arg2;
#endif
{
  return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
}

/* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
   There must be one version of "t_float_values" (this one)
   that is not prototyped, and one (if supported) that is (following).
   That way GDB can be tested against both cases.  */
   
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);
}

#ifdef PROTOTYPES
int t_double_values (double double_arg1, double double_arg2)
#else
int t_double_values (double_arg1, double_arg2)
double double_arg1, double_arg2;
#endif
{
  return ((double_arg1 - double_val1) < DELTA
	  && (double_arg1 - double_val1) > -DELTA
	  && (double_arg2 - double_val2) < DELTA
	  && (double_arg2 - double_val2) > -DELTA);
}

#ifdef PROTOTYPES
int t_string_values (char *string_arg1, char *string_arg2)
#else
int t_string_values (string_arg1, string_arg2)
char *string_arg1, *string_arg2;
#endif
{
  return (!strcmp (string_arg1, string_val1) &&
	  !strcmp (string_arg2, string_val2));
}

#ifdef PROTOTYPES
int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
#else
int t_char_array_values (char_array_arg1, char_array_arg2)
char char_array_arg1[], char_array_arg2[];
#endif
{
  return (!strcmp (char_array_arg1, char_array_val1) &&
	  !strcmp (char_array_arg2, char_array_val2));
}


/* 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.  */

#ifdef PROTOTYPES
int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
#else
int t_func_values (func_arg1, func_arg2)
int (*func_arg1) PARAMS ((int, int));
int (*func_arg2) PARAMS ((int));
#endif
{
  return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
          && (*func_arg2) (6) == (*func_val2) (6));
}

#ifdef PROTOTYPES
int t_call_add (int (*func_arg1)(int, int), int a, int b)
#else
int t_call_add (func_arg1, a, b)
int (*func_arg1) PARAMS ((int, int));
int a, b;
#endif
{
  return ((*func_arg1)(a, b));
}
Commit	Line	Data
daf3f280 JM	1	/* Support program for testing gdb's ability to call functions
	2	in an inferior which doesn't itself call malloc, pass appropriate
	3	arguments to those functions, and get the returned result. */
	4
	5	#ifdef NO_PROTOTYPES
	6	#define PARAMS(paramlist) ()
	7	#else
	8	#define PARAMS(paramlist) paramlist
	9	#endif
	10
	11	# include <string.h>
	12
	13	char char_val1 = 'a';
	14	char char_val2 = 'b';
	15
	16	short short_val1 = 10;
	17	short short_val2 = -23;
	18
	19	int int_val1 = 87;
	20	int int_val2 = -26;
	21
	22	long long_val1 = 789;
	23	long long_val2 = -321;
	24
	25	float float_val1 = 3.14159;
	26	float float_val2 = -2.3765;
	27
	28	double double_val1 = 45.654;
	29	double double_val2 = -67.66;
	30
	31	#define DELTA (0.001)
	32
	33	char string_val1 = (char )"string 1";
	34	char string_val2 = (char )"string 2";
	35
	36	char char_array_val1[] = "carray 1";
	37	char char_array_val2[] = "carray 2";
	38
	39	struct struct1 {
	40	char c;
	41	short s;
	42	int i;
	43	long l;
	44	float f;
	45	double d;
	46	char a[4];
	47	} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
	48
	49	/* Some functions that can be passed as arguments to other test
	50	functions, or called directly. */
	51	#ifdef PROTOTYPES
	52	int add (int a, int b)
	53	#else
	54	int add (a, b) int a, b;
	55	#endif
	56	{
	57	return (a + b);
	58	}
	59
	60	#ifdef PROTOTYPES
	61	int doubleit (int a)
	62	#else
	63	int doubleit (a)
	64	int a;
65	#endif
66	{
67	return (a + a);
68	}
69
70	int (*func_val1) PARAMS((int,int)) = add;
71	int (*func_val2) PARAMS((int)) = doubleit;
72
73	/* An enumeration and functions that test for specific values. */
74
75	enum enumtype { enumval1, enumval2, enumval3 };
76	enum enumtype enum_val1 = enumval1;
77	enum enumtype enum_val2 = enumval2;
78	enum enumtype enum_val3 = enumval3;
79
80	#ifdef PROTOTYPES
81	int t_enum_value1 (enum enumtype enum_arg)
82	#else
83	t_enum_value1 (enum_arg)
84	enum enumtype enum_arg;
85	#endif
86	{
87	return (enum_arg == enum_val1);
88	}
89
90	#ifdef PROTOTYPES
91	int t_enum_value2 (enum enumtype enum_arg)
92	#else
93	t_enum_value2 (enum_arg)
94	enum enumtype enum_arg;
95	#endif
96	{
97	return (enum_arg == enum_val2);
98	}
99
100	#ifdef PROTOTYPES
101	int t_enum_value3 (enum enumtype enum_arg)
102	#else
103	t_enum_value3 (enum_arg)
104	enum enumtype enum_arg;
105	#endif
106	{
107	return (enum_arg == enum_val3);
108	}
109
110	/* A function that takes a vector of integers (along with an explicit
111	count) and returns their sum. */
112
113	#ifdef PROTOTYPES
114	int sum_args (int argc, int argv[])
115	#else
116	int sum_args (argc, argv)
117	int argc;
118	int argv[];
119	#endif
120	{
121	int sumval = 0;
122	int idx;
123
124	for (idx = 0; idx < argc; idx++)
125	{
126	sumval += argv[idx];
127	}
128	return (sumval);
129	}
130
131	/* Test that we can call functions that take structs and return
132	members from that struct */
133
134	#ifdef PROTOTYPES
135	char t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
136	short t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
137	int t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
138	long t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
139	float t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
140	double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
184d0bc8 FN	141	char *t_structs_a (struct struct1 tstruct)
	142	{
	143	static char buf[8];
	144	strcpy (buf, tstruct.a);
	145	return buf;
	146	}
daf3f280 JM	147	#else
	148	char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
	149	short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
	150	int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
	151	long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
	152	float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
	153	double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
184d0bc8 FN	154	char *t_structs_a (tstruct) struct struct1 tstruct;
	155	{
	156	static char buf[8];
	157	strcpy (buf, tstruct.a);
	158	return buf;
	159	}
daf3f280 JM	160	#endif
	161
	162	/* Test that calling functions works if there are a lot of arguments. */
	163	#ifdef PROTOTYPES
	164	int sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
	165	#else
	166	int
	167	sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
	168	int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
	169	#endif
	170	{
	171	return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
	172	}
	173
	174	/* Gotta have a main to be able to generate a linked, runnable
	175	executable, and also provide a useful place to set a breakpoint. */
	176
	177	#ifdef PROTOTYPES
	178	int main()
	179	#else
	180	main ()
	181	#endif
	182	{
daf3f280 JM	183	t_structs_c(struct_val1);
	184	return 0;
	185
	186	}
	187
	188	/* Functions that expect specific values to be passed and return
	189	either 0 or 1, depending upon whether the values were
	190	passed incorrectly or correctly, respectively. */
	191
	192	#ifdef PROTOTYPES
	193	int t_char_values (char char_arg1, char char_arg2)
	194	#else
	195	int t_char_values (char_arg1, char_arg2)
	196	char char_arg1, char_arg2;
	197	#endif
	198	{
	199	return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
	200	}
	201
	202	int
	203	#ifdef PROTOTYPES
	204	t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
	205	char arg6, short arg7, int arg8, short arg9, short arg10)
	206	#else
	207	t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
	208	char arg1;
	209	short arg2;
	210	int arg3;
	211	char arg4;
	212	short arg5;
	213	char arg6;
	214	short arg7;
	215	int arg8;
	216	short arg9;
	217	short arg10;
	218	#endif
	219	{
	220	return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
	221	}
	222
	223	#ifdef PROTOTYPES
	224	int t_short_values (short short_arg1, short short_arg2)
	225	#else
	226	int t_short_values (short_arg1, short_arg2)
	227	short short_arg1, short_arg2;
	228	#endif
	229	{
	230	return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
	231	}
	232
	233	#ifdef PROTOTYPES
	234	int t_int_values (int int_arg1, int int_arg2)
	235	#else
	236	int t_int_values (int_arg1, int_arg2)
	237	int int_arg1, int_arg2;
	238	#endif
	239	{
	240	return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
	241	}
	242
	243	#ifdef PROTOTYPES
	244	int t_long_values (long long_arg1, long long_arg2)
	245	#else
	246	int t_long_values (long_arg1, long_arg2)
247	long long_arg1, long_arg2;
248	#endif
249	{
250	return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
251	}
252
3bf40917 MS	253	/* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
	254	There must be one version of "t_float_values" (this one)
	255	that is not prototyped, and one (if supported) that is (following).
	256	That way GDB can be tested against both cases. */
	257
daf3f280 JM	258	int t_float_values (float_arg1, float_arg2)
daf3f280 JM	259	float float_arg1, float_arg2;
daf3f280 JM	260	{
	261	return ((float_arg1 - float_val1) < DELTA
	262	&& (float_arg1 - float_val1) > -DELTA
	263	&& (float_arg2 - float_val2) < DELTA
	264	&& (float_arg2 - float_val2) > -DELTA);
	265	}
	266
	267	int
3bf40917	268	#ifdef NO_PROTOTYPES
daf3f280 JM	269	/* In this case we are just duplicating t_float_values, but that is the
	270	easiest way to deal with either ANSI or non-ANSI. */
	271	t_float_values2 (float_arg1, float_arg2)
	272	float float_arg1, float_arg2;
3bf40917 MS	273	#else
3bf40917 MS	274	t_float_values2 (float float_arg1, float float_arg2)
daf3f280 JM	275	#endif
	276	{
	277	return ((float_arg1 - float_val1) < DELTA
	278	&& (float_arg1 - float_val1) > -DELTA
	279	&& (float_arg2 - float_val2) < DELTA
	280	&& (float_arg2 - float_val2) > -DELTA);
	281	}
	282
	283	#ifdef PROTOTYPES
	284	int t_double_values (double double_arg1, double double_arg2)
	285	#else
	286	int t_double_values (double_arg1, double_arg2)
	287	double double_arg1, double_arg2;
	288	#endif
	289	{
	290	return ((double_arg1 - double_val1) < DELTA
	291	&& (double_arg1 - double_val1) > -DELTA
	292	&& (double_arg2 - double_val2) < DELTA
	293	&& (double_arg2 - double_val2) > -DELTA);
	294	}
	295
	296	#ifdef PROTOTYPES
	297	int t_string_values (char string_arg1, char string_arg2)
	298	#else
	299	int t_string_values (string_arg1, string_arg2)
	300	char string_arg1, string_arg2;
	301	#endif
	302	{
	303	return (!strcmp (string_arg1, string_val1) &&
	304	!strcmp (string_arg2, string_val2));
	305	}
	306
	307	#ifdef PROTOTYPES
	308	int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
	309	#else
	310	int t_char_array_values (char_array_arg1, char_array_arg2)
	311	char char_array_arg1[], char_array_arg2[];
	312	#endif
	313	{
	314	return (!strcmp (char_array_arg1, char_array_val1) &&
	315	!strcmp (char_array_arg2, char_array_val2));
	316	}
	317
	318
	319	/* This used to simply compare the function pointer arguments with
	320	known values for func_val1 and func_val2. Doing so is valid ANSI
	321	code, but on some machines (RS6000, HPPA, others?) it may fail when
	322	called directly by GDB.
	323
	324	In a nutshell, it's not possible for GDB to determine when the address
	325	of a function or the address of the function's stub/trampoline should
	326	be passed.
	327
	328	So, to avoid GDB lossage in the common case, we perform calls through the
	329	various function pointers and compare the return values. For the HPPA
	330	at least, this allows the common case to work.
	331
	332	If one wants to try something more complicated, pass the address of
	333	a function accepting a "double" as one of its first 4 arguments. Call
	334	that function indirectly through the function pointer. This would fail
	335	on the HPPA. */
	336
	337	#ifdef PROTOTYPES
	338	int t_func_values (int (func_arg1)(int, int), int (func_arg2)(int))
339	#else
340	int t_func_values (func_arg1, func_arg2)
341	int (*func_arg1) PARAMS ((int, int));
342	int (*func_arg2) PARAMS ((int));
343	#endif
344	{
345	return ((func_arg1) (5,5) == (func_val1) (5,5)
346	&& (func_arg2) (6) == (func_val2) (6));
347	}
348
349	#ifdef PROTOTYPES
350	int t_call_add (int (*func_arg1)(int, int), int a, int b)
351	#else
352	int t_call_add (func_arg1, a, b)
353	int (*func_arg1) PARAMS ((int, int));
354	int a, b;
355	#endif
356	{
357	return ((*func_arg1)(a, b));
358	}