1 /* This testcase is part of GDB, the GNU debugger.
3 Copyright 1993-1995, 1998-2001, 2004, 2007-2012 Free Software
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
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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. */
24 #define PARAMS(paramlist) ()
26 #define PARAMS(paramlist) paramlist
35 short short_val1
= 10;
36 short short_val2
= -23;
42 long long_val2
= -321;
44 float float_val1
= 3.14159;
45 float float_val2
= -2.3765;
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;
60 double double_val1
= 45.654;
61 double double_val2
= -67.66;
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;
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
);
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
;
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
;
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 */
100 #define DELTA (0.001)
102 char *string_val1
= (char *)"string 1";
103 char *string_val2
= (char *)"string 2";
105 char char_array_val1
[] = "carray 1";
106 char char_array_val2
[] = "carray 2";
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
};
123 } struct_val1
= { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
124 #endif /* TEST_COMPLEX */
125 /* Some functions that can be passed as arguments to other test
126 functions, or called directly. */
128 int add (int a
, int b
)
130 int add (a
, b
) int a
, b
;
139 int doubleit (a
) int a
;
145 int (*func_val1
) PARAMS((int,int)) = add
;
146 int (*func_val2
) PARAMS((int)) = doubleit
;
148 /* An enumeration and functions that test for specific values. */
150 enum enumtype
{ enumval1
, enumval2
, enumval3
};
151 enum enumtype enum_val1
= enumval1
;
152 enum enumtype enum_val2
= enumval2
;
153 enum enumtype enum_val3
= enumval3
;
156 int t_enum_value1 (enum enumtype enum_arg
)
158 int t_enum_value1 (enum_arg
) enum enumtype enum_arg
;
161 return (enum_arg
== enum_val1
);
165 int t_enum_value2 (enum enumtype enum_arg
)
167 int t_enum_value2 (enum_arg
) enum enumtype enum_arg
;
170 return (enum_arg
== enum_val2
);
174 int t_enum_value3 (enum enumtype enum_arg
)
176 int t_enum_value3 (enum_arg
) enum enumtype enum_arg
;
179 return (enum_arg
== enum_val3
);
182 /* A function that takes a vector of integers (along with an explicit
183 count) and returns their sum. */
186 int sum_args (int argc
, int argv
[])
188 int sum_args (argc
, argv
) int argc
; int argv
[];
194 for (idx
= 0; idx
< argc
; idx
++)
201 /* Test that we can call functions that take structs and return
202 members from that struct */
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
); }
211 char *t_structs_a (struct struct1 tstruct
)
214 strcpy (buf
, tstruct
.a
);
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
;}
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
); }
229 char *t_structs_a (tstruct
) struct struct1 tstruct
;
232 strcpy (buf
, tstruct
.a
);
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
;}
242 /* Test that calling functions works if there are a lot of arguments. */
245 sum10 (int i0
, int i1
, int i2
, int i3
, int i4
, int i5
, int i6
, int i7
, int i8
, int i9
)
248 sum10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
249 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
252 return i0
+ i1
+ i2
+ i3
+ i4
+ i5
+ i6
+ i7
+ i8
+ i9
;
255 /* Test that args are passed in the right order. */
258 cmp10 (int i0
, int i1
, int i2
, int i3
, int i4
, int i5
, int i6
, int i7
, int i8
, int i9
)
261 cmp10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
262 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
266 (i0
== 0) && (i1
== 1) && (i2
== 2) && (i3
== 3) && (i4
== 4) &&
267 (i5
== 5) && (i6
== 6) && (i7
== 7) && (i8
== 8) && (i9
== 9);
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. */
275 int t_char_values (char char_arg1
, char char_arg2
)
277 int t_char_values (char_arg1
, char_arg2
)
278 char char_arg1
, char_arg2
;
281 return ((char_arg1
== char_val1
) && (char_arg2
== char_val2
));
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
)
289 t_small_values (arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
, arg9
, arg10
)
302 return arg1
+ arg2
+ arg3
+ arg4
+ arg5
+ arg6
+ arg7
+ arg8
+ arg9
+ arg10
;
306 int t_short_values (short short_arg1
, short short_arg2
)
308 int t_short_values (short_arg1
, short_arg2
)
309 short short_arg1
, short_arg2
;
312 return ((short_arg1
== short_val1
) && (short_arg2
== short_val2
));
316 int t_int_values (int int_arg1
, int int_arg2
)
318 int t_int_values (int_arg1
, int_arg2
)
319 int int_arg1
, int_arg2
;
322 return ((int_arg1
== int_val1
) && (int_arg2
== int_val2
));
326 int t_long_values (long long_arg1
, long long_arg2
)
328 int t_long_values (long_arg1
, long_arg2
)
329 long long_arg1
, long_arg2
;
332 return ((long_arg1
== long_val1
) && (long_arg2
== long_val2
));
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. */
340 int t_float_values (float_arg1
, float_arg2
)
341 float float_arg1
, float_arg2
;
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
);
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
;
356 t_float_values2 (float float_arg1
, float float_arg2
)
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
);
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. */
373 t_float_many_args (f1
, f2
, f3
, f4
, f5
, f6
, f7
, f8
, f9
, f10
, f11
, f12
, f13
,
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
,
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
)
387 sum_args
= f1
+ f2
+ f3
+ f4
+ f5
+ f6
+ f7
+ f8
+ f9
+ f10
+ f11
+ f12
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
;
394 return ((sum_args
- sum_values
) < DELTA
395 && (sum_args
- sum_values
) > -DELTA
);
399 int t_double_values (double double_arg1
, double double_arg2
)
401 int t_double_values (double_arg1
, double_arg2
)
402 double double_arg1
, double_arg2
;
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
);
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. */
419 t_double_many_args (f1
, f2
, f3
, f4
, f5
, f6
, f7
, f8
, f9
, f10
, f11
, f12
, f13
,
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
;
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
)
433 sum_args
= f1
+ f2
+ f3
+ f4
+ f5
+ f6
+ f7
+ f8
+ f9
+ f10
+ f11
+ f12
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
;
440 return ((sum_args
- sum_values
) < DELTA
441 && (sum_args
- sum_values
) > -DELTA
);
444 /* Various functions for _Complex types. */
448 #define COMPARE_WITHIN_RANGE(ARG1, ARG2, DEL, FUNC) \
449 ((FUNC(ARG1) - FUNC(ARG2)) < DEL) && ((FUNC(ARG1) - FUNC(ARG2) > -DEL))
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, \
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)
471 #define DEF_FUNC_MANY_ARGS_3(TYPE, CREAL, CIMAG) \
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)); \
485 DEF_FUNC_MANY_ARGS_1(float, float)
487 DEF_FUNC_MANY_ARGS_2(float, float)
489 DEF_FUNC_MANY_ARGS_3(float, crealf
, cimagf
)
493 DEF_FUNC_MANY_ARGS_1(double, double)
495 DEF_FUNC_MANY_ARGS_2(double, double)
497 DEF_FUNC_MANY_ARGS_3(double, creal
, cimag
)
501 DEF_FUNC_MANY_ARGS_1(long double, long_double
)
503 DEF_FUNC_MANY_ARGS_2(long double, long_double
)
505 DEF_FUNC_MANY_ARGS_3(long double, creall
, cimagl
)
507 #define DEF_FUNC_VALUES_1(TYPE, NAME) \
508 t_##NAME##_complex_values (f1, f2) TYPE _Complex f1, TYPE _Complex f2;
510 #define DEF_FUNC_VALUES_2(TYPE, NAME) \
511 t_##NAME##_complex_values (TYPE _Complex f1, TYPE _Complex f2)
513 #define DEF_FUNC_VALUES_3(FORMAL_PARM, TYPE, CREAL, CIMAG) \
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)); \
523 DEF_FUNC_VALUES_1(float, float)
525 DEF_FUNC_VALUES_2(float, float)
527 DEF_FUNC_VALUES_3(fc
, float, crealf
, cimagf
)
531 DEF_FUNC_VALUES_1(double, double)
533 DEF_FUNC_VALUES_2(double, double)
535 DEF_FUNC_VALUES_3(fc
, double, creal
, cimag
)
539 DEF_FUNC_VALUES_1(long double, long_double
)
541 DEF_FUNC_VALUES_2(long double, long_double
)
543 DEF_FUNC_VALUES_3(fc
, long double, creall
, cimagl
)
545 #endif /* TEST_COMPLEX */
549 int t_string_values (char *string_arg1
, char *string_arg2
)
551 int t_string_values (string_arg1
, string_arg2
)
552 char *string_arg1
, *string_arg2
;
555 return (!strcmp (string_arg1
, string_val1
) &&
556 !strcmp (string_arg2
, string_val2
));
560 int t_char_array_values (char char_array_arg1
[], char char_array_arg2
[])
562 int t_char_array_values (char_array_arg1
, char_array_arg2
)
563 char char_array_arg1
[], char_array_arg2
[];
566 return (!strcmp (char_array_arg1
, char_array_val1
) &&
567 !strcmp (char_array_arg2
, char_array_val2
));
571 int t_double_int (double double_arg1
, int int_arg2
)
573 int t_double_int (double_arg1
, int_arg2
)
578 return ((double_arg1
- int_arg2
) < DELTA
579 && (double_arg1
- int_arg2
) > -DELTA
);
583 int t_int_double (int int_arg1
, double double_arg2
)
585 int t_int_double (int_arg1
, double_arg2
)
590 return ((int_arg1
- double_arg2
) < DELTA
591 && (int_arg1
- double_arg2
) > -DELTA
);
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.
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
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.
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
613 int t_func_values (int (*func_arg1
)(int, int), int (*func_arg2
)(int))
615 int t_func_values (func_arg1
, func_arg2
)
616 int (*func_arg1
) PARAMS ((int, int));
617 int (*func_arg2
) PARAMS ((int));
620 return ((*func_arg1
) (5,5) == (*func_val1
) (5,5)
621 && (*func_arg2
) (6) == (*func_val2
) (6));
625 int t_call_add (int (*func_arg1
)(int, int), int a
, int b
)
627 int t_call_add (func_arg1
, a
, b
)
628 int (*func_arg1
) PARAMS ((int, int));
632 return ((*func_arg1
)(a
, b
));
635 struct struct_with_fnptr
637 int (*func
) PARAMS((int));
640 struct struct_with_fnptr function_struct
= { doubleit
};
642 struct struct_with_fnptr
*function_struct_ptr
= &function_struct
;
647 static int twentythree
= 23;
651 /* Gotta have a main to be able to generate a linked, runnable
652 executable, and also provide a useful place to set a breakpoint. */
657 t_double_values(double_val1
, double_val2
);
658 t_structs_c(struct_val1
);
669 callfunc (int (*func
) (int value
), int value
)
671 return Lcallfunc (0) * 0 + func (value
) * 2;