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. */
6 #define PARAMS(paramlist) ()
8 #define PARAMS(paramlist) paramlist
17 short short_val1 = 10;
18 short short_val2 = -23;
24 long long_val2 = -321;
26 float float_val1 = 3.14159;
27 float float_val2 = -2.3765;
29 double double_val1 = 45.654;
30 double double_val2 = -67.66;
34 char *string_val1 = (char *)"string 1";
35 char *string_val2 = (char *)"string 2";
37 char char_array_val1[] = "carray 1";
38 char char_array_val2[] = "carray 2";
48 } struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
50 /* Some functions that can be passed as arguments to other test
51 functions, or called directly. */
53 int add (int a, int b)
55 int add (a, b) int a, b;
64 int doubleit (a) int a;
70 int (*func_val1) PARAMS((int,int)) = add;
71 int (*func_val2) PARAMS((int)) = doubleit;
73 /* An enumeration and functions that test for specific values. */
75 enum enumtype { enumval1, enumval2, enumval3 };
76 enum enumtype enum_val1 = enumval1;
77 enum enumtype enum_val2 = enumval2;
78 enum enumtype enum_val3 = enumval3;
81 int t_enum_value1 (enum enumtype enum_arg)
83 int t_enum_value1 (enum_arg) enum enumtype enum_arg;
86 return (enum_arg == enum_val1);
90 int t_enum_value2 (enum enumtype enum_arg)
92 int t_enum_value2 (enum_arg) enum enumtype enum_arg;
95 return (enum_arg == enum_val2);
99 int t_enum_value3 (enum enumtype enum_arg)
101 int t_enum_value3 (enum_arg) enum enumtype enum_arg;
104 return (enum_arg == enum_val3);
107 /* A function that takes a vector of integers (along with an explicit
108 count) and returns their sum. */
111 int sum_args (int argc, int argv[])
113 int sum_args (argc, argv) int argc; int argv[];
119 for (idx = 0; idx < argc; idx++)
126 /* Test that we can call functions that take structs and return
127 members from that struct */
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); }
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); }
147 /* Test that calling functions works if there are a lot of arguments. */
150 sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
153 sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
154 int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
157 return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
160 /* Test that args are passed in the right order. */
163 cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
166 cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
167 int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
171 (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
172 (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
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() ;
186 t_structs_c(struct_val1);
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. */
195 int t_char_values (char char_arg1, char char_arg2)
197 int t_char_values (char_arg1, char_arg2)
198 char char_arg1, char_arg2;
201 return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
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)
209 t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
222 return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
226 int t_short_values (short short_arg1, short short_arg2)
228 int t_short_values (short_arg1, short_arg2)
229 short short_arg1, short_arg2;
232 return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
236 int t_int_values (int int_arg1, int int_arg2)
238 int t_int_values (int_arg1, int_arg2)
239 int int_arg1, int_arg2;
242 return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
246 int t_long_values (long long_arg1, long long_arg2)
248 int t_long_values (long_arg1, long_arg2)
249 long long_arg1, long_arg2;
252 return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
256 int t_float_values (float float_arg1, float float_arg2)
258 int t_float_values (float_arg1, float_arg2)
259 float float_arg1, float_arg2;
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);
270 t_float_values2 (float float_arg1, float float_arg2)
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;
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);
285 int t_double_values (double double_arg1, double double_arg2)
287 int t_double_values (double_arg1, double_arg2)
288 double double_arg1, double_arg2;
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);
298 int t_string_values (char *string_arg1, char *string_arg2)
300 int t_string_values (string_arg1, string_arg2)
301 char *string_arg1, *string_arg2;
304 return (!strcmp (string_arg1, string_val1) &&
305 !strcmp (string_arg2, string_val2));
309 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
311 int t_char_array_values (char_array_arg1, char_array_arg2)
312 char char_array_arg1[], char_array_arg2[];
315 return (!strcmp (char_array_arg1, char_array_val1) &&
316 !strcmp (char_array_arg2, char_array_val2));
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.
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
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.
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
339 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
341 int t_func_values (func_arg1, func_arg2)
342 int (*func_arg1) PARAMS ((int, int));
343 int (*func_arg2) PARAMS ((int));
346 return ((*func_arg1) (5,5) == (*func_val1) (5,5)
347 && (*func_arg2) (6) == (*func_val2) (6));
351 int t_call_add (int (*func_arg1)(int, int), int a, int b)
353 int t_call_add (func_arg1, a, b)
354 int (*func_arg1) PARAMS ((int, int));
358 return ((*func_arg1)(a, b));