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

/* Support program for testing gdb's ability to call functions
   in the inferior, pass appropriate arguments to those functions,
   and get the returned result. */

#ifdef NO_PROTOTYPES
#define PARAMS(paramlist) ()
#else
#define PARAMS(paramlist) paramlist
#endif

# include <stdlib.h>
# 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
int t_enum_value1 (enum_arg) enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val1);
}

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

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

/* 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) { return (tstruct.a); }
#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; { return (tstruct.a); }
#endif

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

/* Test that args are passed in the right order. */
#ifdef PROTOTYPES
int
cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
#else
int
cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
  int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
#endif
{
  return
    (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
    (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
}


/* Gotta have a main to be able to generate a linked, runnable
   executable, and also provide a useful place to set a breakpoint. */
extern void * malloc() ;
int main ()
{
#ifdef usestubs
  set_debug_traps();
  breakpoint();
#endif
  malloc(1);
  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));
}

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