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

/* This testcase is part of GDB, the GNU debugger.

   Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2004, 2007, 2008
   Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.

   Please email any bugs, comments, and/or additions to this file to:
   bug-gdb@prep.ai.mit.edu  */

/* 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)
{
  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;
}

/* 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);
}

/* 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));
}

#ifdef PROTOTYPES
int t_double_int (double double_arg1, int int_arg2)
#else
int t_double_int (double_arg1, int_arg2)
double double_arg1;
int int_arg2;
#endif
{
  return ((double_arg1 - int_arg2) < DELTA
	  && (double_arg1 - int_arg2) > -DELTA);
}

#ifdef PROTOTYPES
int t_int_double (int int_arg1, double double_arg2)
#else
int t_int_double (int_arg1, double_arg2)
int int_arg1;
double double_arg2;
#endif
{
  return ((int_arg1 - double_arg2) < DELTA
	  && (int_arg1 - double_arg2) > -DELTA);
}

/* 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));
}


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

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