Commit | Line | Data |
---|---|---|
f453692c MC |
1 | /* This testcase is part of GDB, the GNU debugger. |
2 | ||
4c38e0a4 | 3 | Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2004, 2007, 2008, 2009, |
7b6bb8da | 4 | 2010, 2011 Free Software Foundation, Inc. |
f453692c MC |
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 |
c7b778ff | 17 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
f453692c | 18 | |
c906108c SS |
19 | /* Support program for testing gdb's ability to call functions |
20 | in the inferior, pass appropriate arguments to those functions, | |
21 | and get the returned result. */ | |
22 | ||
23 | #ifdef NO_PROTOTYPES | |
24 | #define PARAMS(paramlist) () | |
25 | #else | |
26 | #define PARAMS(paramlist) paramlist | |
27 | #endif | |
28 | ||
085dd6e6 JM |
29 | # include <stdlib.h> |
30 | # include <string.h> | |
31 | ||
c906108c SS |
32 | char char_val1 = 'a'; |
33 | char char_val2 = 'b'; | |
34 | ||
35 | short short_val1 = 10; | |
36 | short short_val2 = -23; | |
37 | ||
38 | int int_val1 = 87; | |
39 | int int_val2 = -26; | |
40 | ||
41 | long long_val1 = 789; | |
42 | long long_val2 = -321; | |
43 | ||
44 | float float_val1 = 3.14159; | |
45 | float float_val2 = -2.3765; | |
1a4ca44a TJB |
46 | float float_val3 = 0.25; |
47 | float float_val4 = 1.25; | |
48 | float float_val5 = 2.25; | |
49 | float float_val6 = 3.25; | |
50 | float float_val7 = 4.25; | |
51 | float float_val8 = 5.25; | |
52 | float float_val9 = 6.25; | |
53 | float float_val10 = 7.25; | |
54 | float float_val11 = 8.25; | |
55 | float float_val12 = 9.25; | |
56 | float float_val13 = 10.25; | |
57 | float float_val14 = 11.25; | |
58 | float float_val15 = 12.25; | |
c906108c SS |
59 | |
60 | double double_val1 = 45.654; | |
61 | double double_val2 = -67.66; | |
1a4ca44a TJB |
62 | double double_val3 = 0.25; |
63 | double double_val4 = 1.25; | |
64 | double double_val5 = 2.25; | |
65 | double double_val6 = 3.25; | |
66 | double double_val7 = 4.25; | |
67 | double double_val8 = 5.25; | |
68 | double double_val9 = 6.25; | |
69 | double double_val10 = 7.25; | |
70 | double double_val11 = 8.25; | |
71 | double double_val12 = 9.25; | |
72 | double double_val13 = 10.25; | |
73 | double double_val14 = 11.25; | |
74 | double double_val15 = 12.25; | |
c906108c | 75 | |
0578b8d1 YQ |
76 | #ifdef TEST_COMPLEX |
77 | extern float crealf (float _Complex); | |
78 | extern float cimagf (float _Complex); | |
79 | extern double creal (double _Complex); | |
80 | extern double cimag (double _Complex); | |
81 | extern long double creall (long double _Complex); | |
82 | extern long double cimagl (long double _Complex); | |
83 | ||
84 | float _Complex fc1 = 1.0F + 1.0iF; | |
85 | float _Complex fc2 = 2.0F + 2.0iF; | |
86 | float _Complex fc3 = 3.0F + 3.0iF; | |
87 | float _Complex fc4 = 4.0F + 4.0iF; | |
88 | ||
89 | double _Complex dc1 = 1.0 + 1.0i; | |
90 | double _Complex dc2 = 2.0 + 2.0i; | |
91 | double _Complex dc3 = 3.0 + 3.0i; | |
92 | double _Complex dc4 = 4.0 + 4.0i; | |
93 | ||
94 | long double _Complex ldc1 = 1.0L + 1.0Li; | |
95 | long double _Complex ldc2 = 2.0L + 2.0Li; | |
96 | long double _Complex ldc3 = 3.0L + 3.0Li; | |
97 | long double _Complex ldc4 = 4.0L + 4.0Li; | |
98 | #endif /* TEST_COMPLEX */ | |
99 | ||
c906108c SS |
100 | #define DELTA (0.001) |
101 | ||
085dd6e6 JM |
102 | char *string_val1 = (char *)"string 1"; |
103 | char *string_val2 = (char *)"string 2"; | |
c906108c SS |
104 | |
105 | char char_array_val1[] = "carray 1"; | |
106 | char char_array_val2[] = "carray 2"; | |
107 | ||
108 | struct struct1 { | |
109 | char c; | |
110 | short s; | |
111 | int i; | |
112 | long l; | |
113 | float f; | |
114 | double d; | |
115 | char a[4]; | |
0578b8d1 YQ |
116 | #ifdef TEST_COMPLEX |
117 | float _Complex fc; | |
118 | double _Complex dc; | |
119 | long double _Complex ldc; | |
120 | } struct_val1 ={ 'x', 87, 76, 51, 2.1234, 9.876, "foo", 3.0F + 3.0Fi, | |
121 | 4.0L + 4.0Li, 5.0L + 5.0Li}; | |
122 | #else | |
c906108c | 123 | } struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" }; |
0578b8d1 | 124 | #endif /* TEST_COMPLEX */ |
c906108c SS |
125 | /* Some functions that can be passed as arguments to other test |
126 | functions, or called directly. */ | |
085dd6e6 JM |
127 | #ifdef PROTOTYPES |
128 | int add (int a, int b) | |
129 | #else | |
130 | int add (a, b) int a, b; | |
131 | #endif | |
c906108c SS |
132 | { |
133 | return (a + b); | |
134 | } | |
135 | ||
085dd6e6 JM |
136 | #ifdef PROTOTYPES |
137 | int doubleit (int a) | |
138 | #else | |
139 | int doubleit (a) int a; | |
140 | #endif | |
c906108c SS |
141 | { |
142 | return (a + a); | |
143 | } | |
144 | ||
145 | int (*func_val1) PARAMS((int,int)) = add; | |
146 | int (*func_val2) PARAMS((int)) = doubleit; | |
147 | ||
148 | /* An enumeration and functions that test for specific values. */ | |
149 | ||
150 | enum enumtype { enumval1, enumval2, enumval3 }; | |
151 | enum enumtype enum_val1 = enumval1; | |
152 | enum enumtype enum_val2 = enumval2; | |
153 | enum enumtype enum_val3 = enumval3; | |
154 | ||
085dd6e6 JM |
155 | #ifdef PROTOTYPES |
156 | int t_enum_value1 (enum enumtype enum_arg) | |
157 | #else | |
158 | int t_enum_value1 (enum_arg) enum enumtype enum_arg; | |
159 | #endif | |
c906108c SS |
160 | { |
161 | return (enum_arg == enum_val1); | |
162 | } | |
163 | ||
085dd6e6 JM |
164 | #ifdef PROTOTYPES |
165 | int t_enum_value2 (enum enumtype enum_arg) | |
166 | #else | |
167 | int t_enum_value2 (enum_arg) enum enumtype enum_arg; | |
168 | #endif | |
c906108c SS |
169 | { |
170 | return (enum_arg == enum_val2); | |
171 | } | |
172 | ||
085dd6e6 JM |
173 | #ifdef PROTOTYPES |
174 | int t_enum_value3 (enum enumtype enum_arg) | |
175 | #else | |
176 | int t_enum_value3 (enum_arg) enum enumtype enum_arg; | |
177 | #endif | |
c906108c SS |
178 | { |
179 | return (enum_arg == enum_val3); | |
180 | } | |
181 | ||
182 | /* A function that takes a vector of integers (along with an explicit | |
183 | count) and returns their sum. */ | |
184 | ||
085dd6e6 JM |
185 | #ifdef PROTOTYPES |
186 | int sum_args (int argc, int argv[]) | |
187 | #else | |
188 | int sum_args (argc, argv) int argc; int argv[]; | |
189 | #endif | |
c906108c SS |
190 | { |
191 | int sumval = 0; | |
192 | int idx; | |
193 | ||
194 | for (idx = 0; idx < argc; idx++) | |
195 | { | |
196 | sumval += argv[idx]; | |
197 | } | |
198 | return (sumval); | |
199 | } | |
200 | ||
201 | /* Test that we can call functions that take structs and return | |
202 | members from that struct */ | |
203 | ||
085dd6e6 JM |
204 | #ifdef PROTOTYPES |
205 | char t_structs_c (struct struct1 tstruct) { return (tstruct.c); } | |
206 | short t_structs_s (struct struct1 tstruct) { return (tstruct.s); } | |
207 | int t_structs_i (struct struct1 tstruct) { return (tstruct.i); } | |
208 | long t_structs_l (struct struct1 tstruct) { return (tstruct.l); } | |
209 | float t_structs_f (struct struct1 tstruct) { return (tstruct.f); } | |
210 | double t_structs_d (struct struct1 tstruct) { return (tstruct.d); } | |
184d0bc8 FN |
211 | char *t_structs_a (struct struct1 tstruct) |
212 | { | |
213 | static char buf[8]; | |
214 | strcpy (buf, tstruct.a); | |
215 | return buf; | |
216 | } | |
0578b8d1 YQ |
217 | #ifdef TEST_COMPLEX |
218 | float _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.fc;} | |
219 | double _Complex t_structs_dc (struct struct1 tstruct) { return tstruct.dc;} | |
220 | long double _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.ldc;} | |
221 | #endif | |
085dd6e6 | 222 | #else |
c906108c SS |
223 | char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); } |
224 | short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); } | |
225 | int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); } | |
226 | long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); } | |
227 | float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); } | |
228 | double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); } | |
184d0bc8 FN |
229 | char *t_structs_a (tstruct) struct struct1 tstruct; |
230 | { | |
231 | static char buf[8]; | |
232 | strcpy (buf, tstruct.a); | |
233 | return buf; | |
234 | } | |
0578b8d1 YQ |
235 | #ifdef TEST_COMPLEX |
236 | float _Complex t_structs_fc (tstruct) struct struct1 tstruct; { return tstruct.fc;} | |
237 | double _Complex t_structs_dc (tstruct) struct struct1 tstruct; { return tstruct.dc;} | |
238 | long double _Complex t_structs_ldc (tstruct) struct struct1 tstruct; { return tstruct.ldc;} | |
239 | #endif | |
085dd6e6 | 240 | #endif |
c906108c SS |
241 | |
242 | /* Test that calling functions works if there are a lot of arguments. */ | |
085dd6e6 JM |
243 | #ifdef PROTOTYPES |
244 | int | |
245 | sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) | |
246 | #else | |
c906108c SS |
247 | int |
248 | sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) | |
249 | int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; | |
085dd6e6 | 250 | #endif |
c906108c SS |
251 | { |
252 | return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9; | |
253 | } | |
254 | ||
255 | /* Test that args are passed in the right order. */ | |
085dd6e6 JM |
256 | #ifdef PROTOTYPES |
257 | int | |
258 | cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) | |
259 | #else | |
c906108c SS |
260 | int |
261 | cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) | |
262 | int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; | |
085dd6e6 | 263 | #endif |
c906108c SS |
264 | { |
265 | return | |
266 | (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) && | |
267 | (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9); | |
268 | } | |
269 | ||
c906108c SS |
270 | /* Functions that expect specific values to be passed and return |
271 | either 0 or 1, depending upon whether the values were | |
272 | passed incorrectly or correctly, respectively. */ | |
273 | ||
085dd6e6 JM |
274 | #ifdef PROTOTYPES |
275 | int t_char_values (char char_arg1, char char_arg2) | |
276 | #else | |
c906108c SS |
277 | int t_char_values (char_arg1, char_arg2) |
278 | char char_arg1, char_arg2; | |
085dd6e6 | 279 | #endif |
c906108c SS |
280 | { |
281 | return ((char_arg1 == char_val1) && (char_arg2 == char_val2)); | |
282 | } | |
283 | ||
284 | int | |
085dd6e6 JM |
285 | #ifdef PROTOTYPES |
286 | t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5, | |
287 | char arg6, short arg7, int arg8, short arg9, short arg10) | |
288 | #else | |
c906108c SS |
289 | t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) |
290 | char arg1; | |
291 | short arg2; | |
292 | int arg3; | |
293 | char arg4; | |
294 | short arg5; | |
295 | char arg6; | |
296 | short arg7; | |
297 | int arg8; | |
298 | short arg9; | |
299 | short arg10; | |
c906108c SS |
300 | #endif |
301 | { | |
302 | return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10; | |
303 | } | |
304 | ||
085dd6e6 JM |
305 | #ifdef PROTOTYPES |
306 | int t_short_values (short short_arg1, short short_arg2) | |
307 | #else | |
c906108c | 308 | int t_short_values (short_arg1, short_arg2) |
085dd6e6 JM |
309 | short short_arg1, short_arg2; |
310 | #endif | |
c906108c SS |
311 | { |
312 | return ((short_arg1 == short_val1) && (short_arg2 == short_val2)); | |
313 | } | |
314 | ||
085dd6e6 JM |
315 | #ifdef PROTOTYPES |
316 | int t_int_values (int int_arg1, int int_arg2) | |
317 | #else | |
c906108c SS |
318 | int t_int_values (int_arg1, int_arg2) |
319 | int int_arg1, int_arg2; | |
085dd6e6 | 320 | #endif |
c906108c SS |
321 | { |
322 | return ((int_arg1 == int_val1) && (int_arg2 == int_val2)); | |
323 | } | |
324 | ||
085dd6e6 JM |
325 | #ifdef PROTOTYPES |
326 | int t_long_values (long long_arg1, long long_arg2) | |
327 | #else | |
c906108c SS |
328 | int t_long_values (long_arg1, long_arg2) |
329 | long long_arg1, long_arg2; | |
085dd6e6 | 330 | #endif |
c906108c SS |
331 | { |
332 | return ((long_arg1 == long_val1) && (long_arg2 == long_val2)); | |
333 | } | |
334 | ||
3bf40917 MS |
335 | /* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!! |
336 | There must be one version of "t_float_values" (this one) | |
337 | that is not prototyped, and one (if supported) that is (following). | |
338 | That way GDB can be tested against both cases. */ | |
339 | ||
c906108c SS |
340 | int t_float_values (float_arg1, float_arg2) |
341 | float float_arg1, float_arg2; | |
342 | { | |
343 | return ((float_arg1 - float_val1) < DELTA | |
344 | && (float_arg1 - float_val1) > -DELTA | |
345 | && (float_arg2 - float_val2) < DELTA | |
346 | && (float_arg2 - float_val2) > -DELTA); | |
347 | } | |
348 | ||
349 | int | |
3bf40917 | 350 | #ifdef NO_PROTOTYPES |
c906108c SS |
351 | /* In this case we are just duplicating t_float_values, but that is the |
352 | easiest way to deal with either ANSI or non-ANSI. */ | |
353 | t_float_values2 (float_arg1, float_arg2) | |
354 | float float_arg1, float_arg2; | |
3bf40917 MS |
355 | #else |
356 | t_float_values2 (float float_arg1, float float_arg2) | |
c906108c SS |
357 | #endif |
358 | { | |
359 | return ((float_arg1 - float_val1) < DELTA | |
360 | && (float_arg1 - float_val1) > -DELTA | |
361 | && (float_arg2 - float_val2) < DELTA | |
362 | && (float_arg2 - float_val2) > -DELTA); | |
363 | } | |
364 | ||
1a4ca44a TJB |
365 | /* This function has many arguments to force some of them to be passed via |
366 | the stack instead of registers, to test that GDB can construct correctly | |
367 | the parameter save area. Note that Linux/ppc32 has 8 float registers to use | |
368 | for float parameter passing and Linux/ppc64 has 13, so the number of | |
369 | arguments has to be at least 14 to contemplate these platforms. */ | |
370 | ||
371 | float | |
372 | #ifdef NO_PROTOTYPES | |
373 | t_float_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, | |
374 | f14, f15) | |
375 | float f1, float f2, float f3, float f4, float f5, float f6, float f7, | |
376 | float f8, float f9, float f10, float f11, float f12, float f13, float f14, | |
377 | float f15; | |
378 | #else | |
379 | t_float_many_args (float f1, float f2, float f3, float f4, float f5, float f6, | |
380 | float f7, float f8, float f9, float f10, float f11, | |
381 | float f12, float f13, float f14, float f15) | |
382 | #endif | |
383 | { | |
384 | float sum_args; | |
385 | float sum_values; | |
386 | ||
387 | sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12 | |
388 | + f13 + f14 + f15; | |
389 | sum_values = float_val1 + float_val2 + float_val3 + float_val4 + float_val5 | |
390 | + float_val6 + float_val7 + float_val8 + float_val9 | |
391 | + float_val10 + float_val11 + float_val12 + float_val13 | |
392 | + float_val14 + float_val15; | |
393 | ||
394 | return ((sum_args - sum_values) < DELTA | |
395 | && (sum_args - sum_values) > -DELTA); | |
396 | } | |
397 | ||
085dd6e6 JM |
398 | #ifdef PROTOTYPES |
399 | int t_double_values (double double_arg1, double double_arg2) | |
400 | #else | |
c906108c SS |
401 | int t_double_values (double_arg1, double_arg2) |
402 | double double_arg1, double_arg2; | |
085dd6e6 | 403 | #endif |
c906108c SS |
404 | { |
405 | return ((double_arg1 - double_val1) < DELTA | |
406 | && (double_arg1 - double_val1) > -DELTA | |
407 | && (double_arg2 - double_val2) < DELTA | |
408 | && (double_arg2 - double_val2) > -DELTA); | |
409 | } | |
410 | ||
1a4ca44a TJB |
411 | /* This function has many arguments to force some of them to be passed via |
412 | the stack instead of registers, to test that GDB can construct correctly | |
413 | the parameter save area. Note that Linux/ppc32 has 8 float registers to use | |
414 | for float parameter passing and Linux/ppc64 has 13, so the number of | |
415 | arguments has to be at least 14 to contemplate these platforms. */ | |
416 | ||
417 | double | |
418 | #ifdef NO_PROTOTYPES | |
419 | t_double_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, | |
420 | f14, f15) | |
421 | double f1, double f2, double f3, double f4, double f5, double f6, | |
422 | double f7, double f8, double f9, double f10, double f11, double f12, | |
423 | double f13, double f14, double f15; | |
424 | #else | |
425 | t_double_many_args (double f1, double f2, double f3, double f4, double f5, | |
426 | double f6, double f7, double f8, double f9, double f10, | |
427 | double f11, double f12, double f13, double f14, double f15) | |
428 | #endif | |
429 | { | |
430 | double sum_args; | |
431 | double sum_values; | |
432 | ||
433 | sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12 | |
434 | + f13 + f14 + f15; | |
435 | sum_values = double_val1 + double_val2 + double_val3 + double_val4 | |
436 | + double_val5 + double_val6 + double_val7 + double_val8 | |
437 | + double_val9 + double_val10 + double_val11 + double_val12 | |
438 | + double_val13 + double_val14 + double_val15; | |
439 | ||
440 | return ((sum_args - sum_values) < DELTA | |
441 | && (sum_args - sum_values) > -DELTA); | |
442 | } | |
443 | ||
0578b8d1 YQ |
444 | /* Various functions for _Complex types. */ |
445 | ||
446 | #ifdef TEST_COMPLEX | |
447 | ||
448 | #define COMPARE_WITHIN_RANGE(ARG1, ARG2, DEL, FUNC) \ | |
449 | ((FUNC(ARG1) - FUNC(ARG2)) < DEL) && ((FUNC(ARG1) - FUNC(ARG2) > -DEL)) | |
450 | ||
451 | #define DEF_FUNC_MANY_ARGS_1(TYPE, NAME) \ | |
452 | t_##NAME##_complex_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, \ | |
453 | f12, f13, f14, f15, f16) \ | |
454 | TYPE _Complex f1, TYPE _Complex f2, TYPE _Complex f3, \ | |
455 | TYPE _Complex f4, TYPE _Complex f5, TYPE _Complex f6, \ | |
456 | TYPE _Complex f7, TYPE _Complex f8, TYPE _Complex f9, \ | |
457 | TYPE _Complex f10, TYPE _Complex f11, TYPE _Complex f12, \ | |
458 | TYPE _Complex f13, TYPE _Complex f14, TYPE _Complex f15, \ | |
459 | TYPE _Complex f16; | |
460 | ||
461 | #define DEF_FUNC_MANY_ARGS_2(TYPE, NAME) \ | |
462 | t_##NAME##_complex_many_args (TYPE _Complex f1, TYPE _Complex f2, \ | |
463 | TYPE _Complex f3, TYPE _Complex f4, \ | |
464 | TYPE _Complex f5, TYPE _Complex f6, \ | |
465 | TYPE _Complex f7, TYPE _Complex f8, \ | |
466 | TYPE _Complex f9, TYPE _Complex f10, \ | |
467 | TYPE _Complex f11, TYPE _Complex f12, \ | |
468 | TYPE _Complex f13, TYPE _Complex f14, \ | |
469 | TYPE _Complex f15, TYPE _Complex f16) | |
470 | ||
471 | #define DEF_FUNC_MANY_ARGS_3(TYPE, CREAL, CIMAG) \ | |
472 | { \ | |
473 | TYPE _Complex expected = fc1 + fc2 + fc3 + fc4 + fc1 + fc2 + fc3 + fc4 \ | |
474 | + fc1 + fc2 + fc3 + fc4 + fc1 + fc2 + fc3 + fc4; \ | |
475 | TYPE _Complex actual = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 \ | |
476 | + f11 + f12 + f13 + f14 + f15 + f16; \ | |
477 | return (COMPARE_WITHIN_RANGE(expected, actual, DELTA, creal) \ | |
478 | && COMPARE_WITHIN_RANGE(expected, actual, DELTA, creal) \ | |
479 | && COMPARE_WITHIN_RANGE(expected, actual, DELTA, cimag) \ | |
480 | && COMPARE_WITHIN_RANGE(expected, actual, DELTA, cimag)); \ | |
481 | } | |
482 | ||
483 | int | |
484 | #ifdef NO_PROTOTYPES | |
485 | DEF_FUNC_MANY_ARGS_1(float, float) | |
486 | #else | |
487 | DEF_FUNC_MANY_ARGS_2(float, float) | |
488 | #endif | |
489 | DEF_FUNC_MANY_ARGS_3(float, crealf, cimagf) | |
490 | ||
491 | int | |
492 | #ifdef NO_PROTOTYPES | |
493 | DEF_FUNC_MANY_ARGS_1(double, double) | |
494 | #else | |
495 | DEF_FUNC_MANY_ARGS_2(double, double) | |
496 | #endif | |
497 | DEF_FUNC_MANY_ARGS_3(double, creal, cimag) | |
498 | ||
499 | int | |
500 | #ifdef NO_PROTOTYPES | |
501 | DEF_FUNC_MANY_ARGS_1(long double, long_double) | |
502 | #else | |
503 | DEF_FUNC_MANY_ARGS_2(long double, long_double) | |
504 | #endif | |
505 | DEF_FUNC_MANY_ARGS_3(long double, creall, cimagl) | |
506 | ||
507 | #define DEF_FUNC_VALUES_1(TYPE, NAME) \ | |
508 | t_##NAME##_complex_values (f1, f2) TYPE _Complex f1, TYPE _Complex f2; | |
509 | ||
510 | #define DEF_FUNC_VALUES_2(TYPE, NAME) \ | |
511 | t_##NAME##_complex_values (TYPE _Complex f1, TYPE _Complex f2) | |
512 | ||
513 | #define DEF_FUNC_VALUES_3(FORMAL_PARM, TYPE, CREAL, CIMAG) \ | |
514 | { \ | |
515 | return (COMPARE_WITHIN_RANGE(f1, FORMAL_PARM##1, DELTA, CREAL) \ | |
516 | && COMPARE_WITHIN_RANGE(f2, FORMAL_PARM##2, DELTA, CREAL) \ | |
517 | && COMPARE_WITHIN_RANGE(f1, FORMAL_PARM##1, DELTA, CIMAG) \ | |
518 | && COMPARE_WITHIN_RANGE(f2, FORMAL_PARM##2, DELTA, CIMAG)); \ | |
519 | } | |
520 | ||
521 | int | |
522 | #ifdef NO_PROTOTYPES | |
523 | DEF_FUNC_VALUES_1(float, float) | |
524 | #else | |
525 | DEF_FUNC_VALUES_2(float, float) | |
526 | #endif | |
527 | DEF_FUNC_VALUES_3(fc, float, crealf, cimagf) | |
528 | ||
529 | int | |
530 | #ifdef NO_PROTOTYPES | |
531 | DEF_FUNC_VALUES_1(double, double) | |
532 | #else | |
533 | DEF_FUNC_VALUES_2(double, double) | |
534 | #endif | |
535 | DEF_FUNC_VALUES_3(fc, double, creal, cimag) | |
536 | ||
537 | int | |
538 | #ifdef NO_PROTOTYPES | |
539 | DEF_FUNC_VALUES_1(long double, long_double) | |
540 | #else | |
541 | DEF_FUNC_VALUES_2(long double, long_double) | |
542 | #endif | |
543 | DEF_FUNC_VALUES_3(fc, long double, creall, cimagl) | |
544 | ||
545 | #endif /* TEST_COMPLEX */ | |
546 | ||
547 | ||
085dd6e6 JM |
548 | #ifdef PROTOTYPES |
549 | int t_string_values (char *string_arg1, char *string_arg2) | |
550 | #else | |
c906108c SS |
551 | int t_string_values (string_arg1, string_arg2) |
552 | char *string_arg1, *string_arg2; | |
085dd6e6 | 553 | #endif |
c906108c SS |
554 | { |
555 | return (!strcmp (string_arg1, string_val1) && | |
556 | !strcmp (string_arg2, string_val2)); | |
557 | } | |
558 | ||
085dd6e6 JM |
559 | #ifdef PROTOTYPES |
560 | int t_char_array_values (char char_array_arg1[], char char_array_arg2[]) | |
561 | #else | |
c906108c SS |
562 | int t_char_array_values (char_array_arg1, char_array_arg2) |
563 | char char_array_arg1[], char_array_arg2[]; | |
085dd6e6 | 564 | #endif |
c906108c SS |
565 | { |
566 | return (!strcmp (char_array_arg1, char_array_val1) && | |
567 | !strcmp (char_array_arg2, char_array_val2)); | |
568 | } | |
569 | ||
8d26208a DJ |
570 | #ifdef PROTOTYPES |
571 | int t_double_int (double double_arg1, int int_arg2) | |
572 | #else | |
573 | int t_double_int (double_arg1, int_arg2) | |
574 | double double_arg1; | |
575 | int int_arg2; | |
576 | #endif | |
577 | { | |
578 | return ((double_arg1 - int_arg2) < DELTA | |
579 | && (double_arg1 - int_arg2) > -DELTA); | |
580 | } | |
581 | ||
582 | #ifdef PROTOTYPES | |
583 | int t_int_double (int int_arg1, double double_arg2) | |
584 | #else | |
585 | int t_int_double (int_arg1, double_arg2) | |
586 | int int_arg1; | |
587 | double double_arg2; | |
588 | #endif | |
589 | { | |
590 | return ((int_arg1 - double_arg2) < DELTA | |
591 | && (int_arg1 - double_arg2) > -DELTA); | |
592 | } | |
c906108c SS |
593 | |
594 | /* This used to simply compare the function pointer arguments with | |
595 | known values for func_val1 and func_val2. Doing so is valid ANSI | |
596 | code, but on some machines (RS6000, HPPA, others?) it may fail when | |
597 | called directly by GDB. | |
598 | ||
599 | In a nutshell, it's not possible for GDB to determine when the address | |
600 | of a function or the address of the function's stub/trampoline should | |
601 | be passed. | |
602 | ||
603 | So, to avoid GDB lossage in the common case, we perform calls through the | |
604 | various function pointers and compare the return values. For the HPPA | |
605 | at least, this allows the common case to work. | |
606 | ||
607 | If one wants to try something more complicated, pass the address of | |
608 | a function accepting a "double" as one of its first 4 arguments. Call | |
609 | that function indirectly through the function pointer. This would fail | |
610 | on the HPPA. */ | |
611 | ||
085dd6e6 JM |
612 | #ifdef PROTOTYPES |
613 | int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int)) | |
614 | #else | |
c906108c SS |
615 | int t_func_values (func_arg1, func_arg2) |
616 | int (*func_arg1) PARAMS ((int, int)); | |
617 | int (*func_arg2) PARAMS ((int)); | |
085dd6e6 | 618 | #endif |
c906108c SS |
619 | { |
620 | return ((*func_arg1) (5,5) == (*func_val1) (5,5) | |
621 | && (*func_arg2) (6) == (*func_val2) (6)); | |
622 | } | |
623 | ||
085dd6e6 JM |
624 | #ifdef PROTOTYPES |
625 | int t_call_add (int (*func_arg1)(int, int), int a, int b) | |
626 | #else | |
c906108c SS |
627 | int t_call_add (func_arg1, a, b) |
628 | int (*func_arg1) PARAMS ((int, int)); | |
629 | int a, b; | |
085dd6e6 | 630 | #endif |
c906108c SS |
631 | { |
632 | return ((*func_arg1)(a, b)); | |
633 | } | |
c7db355b | 634 | |
fa8de41e TT |
635 | struct struct_with_fnptr |
636 | { | |
637 | int (*func) PARAMS((int)); | |
638 | }; | |
639 | ||
640 | struct struct_with_fnptr function_struct = { doubleit }; | |
641 | ||
642 | struct struct_with_fnptr *function_struct_ptr = &function_struct; | |
c7db355b PS |
643 | |
644 | /* Gotta have a main to be able to generate a linked, runnable | |
645 | executable, and also provide a useful place to set a breakpoint. */ | |
a476ccc9 | 646 | |
c7db355b PS |
647 | int main () |
648 | { | |
649 | #ifdef usestubs | |
650 | set_debug_traps(); | |
651 | breakpoint(); | |
652 | #endif | |
653 | malloc(1); | |
654 | t_double_values(double_val1, double_val2); | |
655 | t_structs_c(struct_val1); | |
656 | return 0 ; | |
657 | } | |
90359a16 JK |
658 | |
659 | static int | |
660 | Lcallfunc (int arg) | |
661 | { | |
662 | return arg + 1; | |
663 | } | |
664 | ||
665 | int | |
666 | callfunc (int (*func) (int value), int value) | |
667 | { | |
668 | return Lcallfunc (0) * 0 + func (value) * 2; | |
669 | } |