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
)
139 strcpy (buf
, tstruct
.a
);
143 char t_structs_c (tstruct
) struct struct1 tstruct
; { return (tstruct
.c
); }
144 short t_structs_s (tstruct
) struct struct1 tstruct
; { return (tstruct
.s
); }
145 int t_structs_i (tstruct
) struct struct1 tstruct
; { return (tstruct
.i
); }
146 long t_structs_l (tstruct
) struct struct1 tstruct
; { return (tstruct
.l
); }
147 float t_structs_f (tstruct
) struct struct1 tstruct
; { return (tstruct
.f
); }
148 double t_structs_d (tstruct
) struct struct1 tstruct
; { return (tstruct
.d
); }
149 char *t_structs_a (tstruct
) struct struct1 tstruct
;
152 strcpy (buf
, tstruct
.a
);
157 /* Test that calling functions works if there are a lot of arguments. */
160 sum10 (int i0
, int i1
, int i2
, int i3
, int i4
, int i5
, int i6
, int i7
, int i8
, int i9
)
163 sum10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
164 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
167 return i0
+ i1
+ i2
+ i3
+ i4
+ i5
+ i6
+ i7
+ i8
+ i9
;
170 /* Test that args are passed in the right order. */
173 cmp10 (int i0
, int i1
, int i2
, int i3
, int i4
, int i5
, int i6
, int i7
, int i8
, int i9
)
176 cmp10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
177 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
181 (i0
== 0) && (i1
== 1) && (i2
== 2) && (i3
== 3) && (i4
== 4) &&
182 (i5
== 5) && (i6
== 6) && (i7
== 7) && (i8
== 8) && (i9
== 9);
185 /* Functions that expect specific values to be passed and return
186 either 0 or 1, depending upon whether the values were
187 passed incorrectly or correctly, respectively. */
190 int t_char_values (char char_arg1
, char char_arg2
)
192 int t_char_values (char_arg1
, char_arg2
)
193 char char_arg1
, char_arg2
;
196 return ((char_arg1
== char_val1
) && (char_arg2
== char_val2
));
201 t_small_values (char arg1
, short arg2
, int arg3
, char arg4
, short arg5
,
202 char arg6
, short arg7
, int arg8
, short arg9
, short arg10
)
204 t_small_values (arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
, arg9
, arg10
)
217 return arg1
+ arg2
+ arg3
+ arg4
+ arg5
+ arg6
+ arg7
+ arg8
+ arg9
+ arg10
;
221 int t_short_values (short short_arg1
, short short_arg2
)
223 int t_short_values (short_arg1
, short_arg2
)
224 short short_arg1
, short_arg2
;
227 return ((short_arg1
== short_val1
) && (short_arg2
== short_val2
));
231 int t_int_values (int int_arg1
, int int_arg2
)
233 int t_int_values (int_arg1
, int_arg2
)
234 int int_arg1
, int_arg2
;
237 return ((int_arg1
== int_val1
) && (int_arg2
== int_val2
));
241 int t_long_values (long long_arg1
, long long_arg2
)
243 int t_long_values (long_arg1
, long_arg2
)
244 long long_arg1
, long_arg2
;
247 return ((long_arg1
== long_val1
) && (long_arg2
== long_val2
));
250 /* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
251 There must be one version of "t_float_values" (this one)
252 that is not prototyped, and one (if supported) that is (following).
253 That way GDB can be tested against both cases. */
255 int t_float_values (float_arg1
, float_arg2
)
256 float float_arg1
, float_arg2
;
258 return ((float_arg1
- float_val1
) < DELTA
259 && (float_arg1
- float_val1
) > -DELTA
260 && (float_arg2
- float_val2
) < DELTA
261 && (float_arg2
- float_val2
) > -DELTA
);
266 /* In this case we are just duplicating t_float_values, but that is the
267 easiest way to deal with either ANSI or non-ANSI. */
268 t_float_values2 (float_arg1
, float_arg2
)
269 float float_arg1
, float_arg2
;
271 t_float_values2 (float float_arg1
, float float_arg2
)
274 return ((float_arg1
- float_val1
) < DELTA
275 && (float_arg1
- float_val1
) > -DELTA
276 && (float_arg2
- float_val2
) < DELTA
277 && (float_arg2
- float_val2
) > -DELTA
);
281 int t_double_values (double double_arg1
, double double_arg2
)
283 int t_double_values (double_arg1
, double_arg2
)
284 double double_arg1
, double_arg2
;
287 return ((double_arg1
- double_val1
) < DELTA
288 && (double_arg1
- double_val1
) > -DELTA
289 && (double_arg2
- double_val2
) < DELTA
290 && (double_arg2
- double_val2
) > -DELTA
);
294 int t_string_values (char *string_arg1
, char *string_arg2
)
296 int t_string_values (string_arg1
, string_arg2
)
297 char *string_arg1
, *string_arg2
;
300 return (!strcmp (string_arg1
, string_val1
) &&
301 !strcmp (string_arg2
, string_val2
));
305 int t_char_array_values (char char_array_arg1
[], char char_array_arg2
[])
307 int t_char_array_values (char_array_arg1
, char_array_arg2
)
308 char char_array_arg1
[], char_array_arg2
[];
311 return (!strcmp (char_array_arg1
, char_array_val1
) &&
312 !strcmp (char_array_arg2
, char_array_val2
));
316 /* This used to simply compare the function pointer arguments with
317 known values for func_val1 and func_val2. Doing so is valid ANSI
318 code, but on some machines (RS6000, HPPA, others?) it may fail when
319 called directly by GDB.
321 In a nutshell, it's not possible for GDB to determine when the address
322 of a function or the address of the function's stub/trampoline should
325 So, to avoid GDB lossage in the common case, we perform calls through the
326 various function pointers and compare the return values. For the HPPA
327 at least, this allows the common case to work.
329 If one wants to try something more complicated, pass the address of
330 a function accepting a "double" as one of its first 4 arguments. Call
331 that function indirectly through the function pointer. This would fail
335 int t_func_values (int (*func_arg1
)(int, int), int (*func_arg2
)(int))
337 int t_func_values (func_arg1
, func_arg2
)
338 int (*func_arg1
) PARAMS ((int, int));
339 int (*func_arg2
) PARAMS ((int));
342 return ((*func_arg1
) (5,5) == (*func_val1
) (5,5)
343 && (*func_arg2
) (6) == (*func_val2
) (6));
347 int t_call_add (int (*func_arg1
)(int, int), int a
, int b
)
349 int t_call_add (func_arg1
, a
, b
)
350 int (*func_arg1
) PARAMS ((int, int));
354 return ((*func_arg1
)(a
, b
));
358 /* Gotta have a main to be able to generate a linked, runnable
359 executable, and also provide a useful place to set a breakpoint. */
360 extern void * malloc() ;
368 t_double_values(double_val1
, double_val2
);
369 t_structs_c(struct_val1
);
This page took 0.038107 seconds and 4 git commands to generate.