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
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 int t_enum_value1 (enum_arg
)
73 enum enumtype enum_arg
;
75 return (enum_arg
== enum_val1
);
78 int t_enum_value2 (enum_arg
)
79 enum enumtype enum_arg
;
81 return (enum_arg
== enum_val2
);
84 int 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 /* Test that args are passed in the right order. */
128 cmp10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
129 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
132 (i0
== 0) && (i1
== 1) && (i2
== 2) && (i3
== 3) && (i4
== 4) &&
133 (i5
== 5) && (i6
== 6) && (i7
== 7) && (i8
== 8) && (i9
== 9);
137 /* Gotta have a main to be able to generate a linked, runnable
138 executable, and also provide a useful place to set a breakpoint. */
139 extern void * malloc() ;
147 t_structs_c(struct_val1
);
151 /* Functions that expect specific values to be passed and return
152 either 0 or 1, depending upon whether the values were
153 passed incorrectly or correctly, respectively. */
155 int t_char_values (char_arg1
, char_arg2
)
156 char char_arg1
, char_arg2
;
158 return ((char_arg1
== char_val1
) && (char_arg2
== char_val2
));
163 t_small_values (arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
, arg9
, arg10
)
175 t_small_values (char arg1
, short arg2
, int arg3
, char arg4
, short arg5
,
176 char arg6
, short arg7
, int arg8
, short arg9
, short arg10
)
179 return arg1
+ arg2
+ arg3
+ arg4
+ arg5
+ arg6
+ arg7
+ arg8
+ arg9
+ arg10
;
182 int t_short_values (short_arg1
, short_arg2
)
183 short short_arg1
, short_arg2
;
185 return ((short_arg1
== short_val1
) && (short_arg2
== short_val2
));
188 int t_int_values (int_arg1
, int_arg2
)
189 int int_arg1
, int_arg2
;
191 return ((int_arg1
== int_val1
) && (int_arg2
== int_val2
));
194 int t_long_values (long_arg1
, long_arg2
)
195 long long_arg1
, long_arg2
;
197 return ((long_arg1
== long_val1
) && (long_arg2
== long_val2
));
200 int t_float_values (float_arg1
, float_arg2
)
201 float float_arg1
, float_arg2
;
203 return ((float_arg1
- float_val1
) < DELTA
204 && (float_arg1
- float_val1
) > -DELTA
205 && (float_arg2
- float_val2
) < DELTA
206 && (float_arg2
- float_val2
) > -DELTA
);
211 /* In this case we are just duplicating t_float_values, but that is the
212 easiest way to deal with either ANSI or non-ANSI. */
213 t_float_values2 (float_arg1
, float_arg2
)
214 float float_arg1
, float_arg2
;
216 t_float_values2 (float float_arg1
, float float_arg2
)
219 return ((float_arg1
- float_val1
) < DELTA
220 && (float_arg1
- float_val1
) > -DELTA
221 && (float_arg2
- float_val2
) < DELTA
222 && (float_arg2
- float_val2
) > -DELTA
);
225 int t_double_values (double_arg1
, double_arg2
)
226 double double_arg1
, double_arg2
;
228 return ((double_arg1
- double_val1
) < DELTA
229 && (double_arg1
- double_val1
) > -DELTA
230 && (double_arg2
- double_val2
) < DELTA
231 && (double_arg2
- double_val2
) > -DELTA
);
234 int t_string_values (string_arg1
, string_arg2
)
235 char *string_arg1
, *string_arg2
;
237 return (!strcmp (string_arg1
, string_val1
) &&
238 !strcmp (string_arg2
, string_val2
));
241 int t_char_array_values (char_array_arg1
, char_array_arg2
)
242 char char_array_arg1
[], char_array_arg2
[];
244 return (!strcmp (char_array_arg1
, char_array_val1
) &&
245 !strcmp (char_array_arg2
, char_array_val2
));
249 /* This used to simply compare the function pointer arguments with
250 known values for func_val1 and func_val2. Doing so is valid ANSI
251 code, but on some machines (RS6000, HPPA, others?) it may fail when
252 called directly by GDB.
254 In a nutshell, it's not possible for GDB to determine when the address
255 of a function or the address of the function's stub/trampoline should
258 So, to avoid GDB lossage in the common case, we perform calls through the
259 various function pointers and compare the return values. For the HPPA
260 at least, this allows the common case to work.
262 If one wants to try something more complicated, pass the address of
263 a function accepting a "double" as one of its first 4 arguments. Call
264 that function indirectly through the function pointer. This would fail
267 int t_func_values (func_arg1
, func_arg2
)
268 int (*func_arg1
) PARAMS ((int, int));
269 int (*func_arg2
) PARAMS ((int));
271 return ((*func_arg1
) (5,5) == (*func_val1
) (5,5)
272 && (*func_arg2
) (6) == (*func_val2
) (6));
275 int t_call_add (func_arg1
, a
, b
)
276 int (*func_arg1
) PARAMS ((int, int));
279 return ((*func_arg1
)(a
, b
));
This page took 0.035144 seconds and 4 git commands to generate.