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. */
6 #define PARAMS(paramlist) ()
8 #define PARAMS(paramlist) paramlist
14 short short_val1 = 10;
15 short short_val2 = -23;
21 long long_val2 = -321;
23 float float_val1 = 3.14159;
24 float float_val2 = -2.3765;
26 double double_val1 = 45.654;
27 double double_val2 = -67.66;
31 char *string_val1 = "string 1";
32 char *string_val2 = "string 2";
34 char char_array_val1[] = "carray 1";
35 char char_array_val2[] = "carray 2";
45 } struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
47 /* Some functions that can be passed as arguments to other test
48 functions, or called directly. */
62 int (*func_val1) PARAMS((int,int)) = add;
63 int (*func_val2) PARAMS((int)) = doubleit;
65 /* An enumeration and functions that test for specific values. */
67 enum enumtype { enumval1, enumval2, enumval3 };
68 enum enumtype enum_val1 = enumval1;
69 enum enumtype enum_val2 = enumval2;
70 enum enumtype enum_val3 = enumval3;
72 t_enum_value1 (enum_arg)
73 enum enumtype enum_arg;
75 return (enum_arg == enum_val1);
78 t_enum_value2 (enum_arg)
79 enum enumtype enum_arg;
81 return (enum_arg == enum_val2);
84 t_enum_value3 (enum_arg)
85 enum enumtype enum_arg;
87 return (enum_arg == enum_val3);
90 /* A function that takes a vector of integers (along with an explicit
91 count) and returns their sum. */
93 int sum_args (argc, argv)
100 for (idx = 0; idx < argc; idx++)
107 /* Test that we can call functions that take structs and return
108 members from that struct */
110 char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
111 short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
112 int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
113 long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
114 float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
115 double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
116 char *t_structs_a (tstruct) struct struct1 tstruct; { return (tstruct.a); }
118 /* Test that calling functions works if there are a lot of arguments. */
120 sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
121 int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
123 return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
126 /* Gotta have a main to be able to generate a linked, runnable
127 executable, and also provide a useful place to set a breakpoint. */
135 t_structs_c(struct_val1);
138 /* Functions that expect specific values to be passed and return
139 either 0 or 1, depending upon whether the values were
140 passed incorrectly or correctly, respectively. */
142 int t_char_values (char_arg1, char_arg2)
143 char char_arg1, char_arg2;
145 return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
150 t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
162 t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
163 char arg6, short arg7, int arg8, short arg9, short arg10)
166 return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
169 int t_short_values (short_arg1, short_arg2)
170 short short_arg1, short_arg2;
172 return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
175 int t_int_values (int_arg1, int_arg2)
176 int int_arg1, int_arg2;
178 return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
181 int t_long_values (long_arg1, long_arg2)
182 long long_arg1, long_arg2;
184 return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
187 int t_float_values (float_arg1, float_arg2)
188 float float_arg1, float_arg2;
190 return ((float_arg1 - float_val1) < DELTA
191 && (float_arg1 - float_val1) > -DELTA
192 && (float_arg2 - float_val2) < DELTA
193 && (float_arg2 - float_val2) > -DELTA);
198 /* In this case we are just duplicating t_float_values, but that is the
199 easiest way to deal with either ANSI or non-ANSI. */
200 t_float_values2 (float_arg1, float_arg2)
201 float float_arg1, float_arg2;
203 t_float_values2 (float float_arg1, float float_arg2)
206 return ((float_arg1 - float_val1) < DELTA
207 && (float_arg1 - float_val1) > -DELTA
208 && (float_arg2 - float_val2) < DELTA
209 && (float_arg2 - float_val2) > -DELTA);
212 int t_double_values (double_arg1, double_arg2)
213 double double_arg1, double_arg2;
215 return ((double_arg1 - double_val1) < DELTA
216 && (double_arg1 - double_val1) > -DELTA
217 && (double_arg2 - double_val2) < DELTA
218 && (double_arg2 - double_val2) > -DELTA);
221 int t_string_values (string_arg1, string_arg2)
222 char *string_arg1, *string_arg2;
224 return (!strcmp (string_arg1, string_val1) &&
225 !strcmp (string_arg2, string_val2));
228 int t_char_array_values (char_array_arg1, char_array_arg2)
229 char char_array_arg1[], char_array_arg2[];
231 return (!strcmp (char_array_arg1, char_array_val1) &&
232 !strcmp (char_array_arg2, char_array_val2));
236 /* This used to simply compare the function pointer arguments with
237 known values for func_val1 and func_val2. Doing so is valid ANSI
238 code, but on some machines (RS6000, HPPA, others?) it may fail when
239 called directly by GDB.
241 In a nutshell, it's not possible for GDB to determine when the address
242 of a function or the address of the function's stub/trampoline should
245 So, to avoid GDB lossage in the common case, we perform calls through the
246 various function pointers and compare the return values. For the HPPA
247 at least, this allows the common case to work.
249 If one wants to try something more complicated, pass the address of
250 a function accepting a "double" as one of its first 4 arguments. Call
251 that function indirectly through the function pointer. This would fail
254 int t_func_values (func_arg1, func_arg2)
255 int (*func_arg1) PARAMS ((int, int));
256 int (*func_arg2) PARAMS ((int));
258 return ((*func_arg1) (5,5) == (*func_val1) (5,5)
259 && (*func_arg2) (6) == (*func_val2) (6));
262 int t_call_add (func_arg1, a, b)
263 int (*func_arg1) PARAMS ((int, int));
266 return ((*func_arg1)(a, b));