1 /* This testcase is part of GDB, the GNU debugger.
3 Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2004, 2007
4 Free Software Foundation, Inc.
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 Please email any bugs, comments, and/or additions to this file to:
20 bug-gdb@prep.ai.mit.edu */
22 /* Support program for testing gdb's ability to call functions
23 in the inferior, pass appropriate arguments to those functions,
24 and get the returned result. */
27 #define PARAMS(paramlist) ()
29 #define PARAMS(paramlist) paramlist
38 short short_val1
= 10;
39 short short_val2
= -23;
45 long long_val2
= -321;
47 float float_val1
= 3.14159;
48 float float_val2
= -2.3765;
50 double double_val1
= 45.654;
51 double double_val2
= -67.66;
55 char *string_val1
= (char *)"string 1";
56 char *string_val2
= (char *)"string 2";
58 char char_array_val1
[] = "carray 1";
59 char char_array_val2
[] = "carray 2";
69 } struct_val1
= { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
71 /* Some functions that can be passed as arguments to other test
72 functions, or called directly. */
74 int add (int a
, int b
)
76 int add (a
, b
) int a
, b
;
85 int doubleit (a
) int a
;
91 int (*func_val1
) PARAMS((int,int)) = add
;
92 int (*func_val2
) PARAMS((int)) = doubleit
;
94 /* An enumeration and functions that test for specific values. */
96 enum enumtype
{ enumval1
, enumval2
, enumval3
};
97 enum enumtype enum_val1
= enumval1
;
98 enum enumtype enum_val2
= enumval2
;
99 enum enumtype enum_val3
= enumval3
;
102 int t_enum_value1 (enum enumtype enum_arg
)
104 int t_enum_value1 (enum_arg
) enum enumtype enum_arg
;
107 return (enum_arg
== enum_val1
);
111 int t_enum_value2 (enum enumtype enum_arg
)
113 int t_enum_value2 (enum_arg
) enum enumtype enum_arg
;
116 return (enum_arg
== enum_val2
);
120 int t_enum_value3 (enum enumtype enum_arg
)
122 int t_enum_value3 (enum_arg
) enum enumtype enum_arg
;
125 return (enum_arg
== enum_val3
);
128 /* A function that takes a vector of integers (along with an explicit
129 count) and returns their sum. */
132 int sum_args (int argc
, int argv
[])
134 int sum_args (argc
, argv
) int argc
; int argv
[];
140 for (idx
= 0; idx
< argc
; idx
++)
147 /* Test that we can call functions that take structs and return
148 members from that struct */
151 char t_structs_c (struct struct1 tstruct
) { return (tstruct
.c
); }
152 short t_structs_s (struct struct1 tstruct
) { return (tstruct
.s
); }
153 int t_structs_i (struct struct1 tstruct
) { return (tstruct
.i
); }
154 long t_structs_l (struct struct1 tstruct
) { return (tstruct
.l
); }
155 float t_structs_f (struct struct1 tstruct
) { return (tstruct
.f
); }
156 double t_structs_d (struct struct1 tstruct
) { return (tstruct
.d
); }
157 char *t_structs_a (struct struct1 tstruct
)
160 strcpy (buf
, tstruct
.a
);
164 char t_structs_c (tstruct
) struct struct1 tstruct
; { return (tstruct
.c
); }
165 short t_structs_s (tstruct
) struct struct1 tstruct
; { return (tstruct
.s
); }
166 int t_structs_i (tstruct
) struct struct1 tstruct
; { return (tstruct
.i
); }
167 long t_structs_l (tstruct
) struct struct1 tstruct
; { return (tstruct
.l
); }
168 float t_structs_f (tstruct
) struct struct1 tstruct
; { return (tstruct
.f
); }
169 double t_structs_d (tstruct
) struct struct1 tstruct
; { return (tstruct
.d
); }
170 char *t_structs_a (tstruct
) struct struct1 tstruct
;
173 strcpy (buf
, tstruct
.a
);
178 /* Test that calling functions works if there are a lot of arguments. */
181 sum10 (int i0
, int i1
, int i2
, int i3
, int i4
, int i5
, int i6
, int i7
, int i8
, int i9
)
184 sum10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
185 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
188 return i0
+ i1
+ i2
+ i3
+ i4
+ i5
+ i6
+ i7
+ i8
+ i9
;
191 /* Test that args are passed in the right order. */
194 cmp10 (int i0
, int i1
, int i2
, int i3
, int i4
, int i5
, int i6
, int i7
, int i8
, int i9
)
197 cmp10 (i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
)
198 int i0
, i1
, i2
, i3
, i4
, i5
, i6
, i7
, i8
, i9
;
202 (i0
== 0) && (i1
== 1) && (i2
== 2) && (i3
== 3) && (i4
== 4) &&
203 (i5
== 5) && (i6
== 6) && (i7
== 7) && (i8
== 8) && (i9
== 9);
206 /* Functions that expect specific values to be passed and return
207 either 0 or 1, depending upon whether the values were
208 passed incorrectly or correctly, respectively. */
211 int t_char_values (char char_arg1
, char char_arg2
)
213 int t_char_values (char_arg1
, char_arg2
)
214 char char_arg1
, char_arg2
;
217 return ((char_arg1
== char_val1
) && (char_arg2
== char_val2
));
222 t_small_values (char arg1
, short arg2
, int arg3
, char arg4
, short arg5
,
223 char arg6
, short arg7
, int arg8
, short arg9
, short arg10
)
225 t_small_values (arg1
, arg2
, arg3
, arg4
, arg5
, arg6
, arg7
, arg8
, arg9
, arg10
)
238 return arg1
+ arg2
+ arg3
+ arg4
+ arg5
+ arg6
+ arg7
+ arg8
+ arg9
+ arg10
;
242 int t_short_values (short short_arg1
, short short_arg2
)
244 int t_short_values (short_arg1
, short_arg2
)
245 short short_arg1
, short_arg2
;
248 return ((short_arg1
== short_val1
) && (short_arg2
== short_val2
));
252 int t_int_values (int int_arg1
, int int_arg2
)
254 int t_int_values (int_arg1
, int_arg2
)
255 int int_arg1
, int_arg2
;
258 return ((int_arg1
== int_val1
) && (int_arg2
== int_val2
));
262 int t_long_values (long long_arg1
, long long_arg2
)
264 int t_long_values (long_arg1
, long_arg2
)
265 long long_arg1
, long_arg2
;
268 return ((long_arg1
== long_val1
) && (long_arg2
== long_val2
));
271 /* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
272 There must be one version of "t_float_values" (this one)
273 that is not prototyped, and one (if supported) that is (following).
274 That way GDB can be tested against both cases. */
276 int t_float_values (float_arg1
, float_arg2
)
277 float float_arg1
, float_arg2
;
279 return ((float_arg1
- float_val1
) < DELTA
280 && (float_arg1
- float_val1
) > -DELTA
281 && (float_arg2
- float_val2
) < DELTA
282 && (float_arg2
- float_val2
) > -DELTA
);
287 /* In this case we are just duplicating t_float_values, but that is the
288 easiest way to deal with either ANSI or non-ANSI. */
289 t_float_values2 (float_arg1
, float_arg2
)
290 float float_arg1
, float_arg2
;
292 t_float_values2 (float float_arg1
, float float_arg2
)
295 return ((float_arg1
- float_val1
) < DELTA
296 && (float_arg1
- float_val1
) > -DELTA
297 && (float_arg2
- float_val2
) < DELTA
298 && (float_arg2
- float_val2
) > -DELTA
);
302 int t_double_values (double double_arg1
, double double_arg2
)
304 int t_double_values (double_arg1
, double_arg2
)
305 double double_arg1
, double_arg2
;
308 return ((double_arg1
- double_val1
) < DELTA
309 && (double_arg1
- double_val1
) > -DELTA
310 && (double_arg2
- double_val2
) < DELTA
311 && (double_arg2
- double_val2
) > -DELTA
);
315 int t_string_values (char *string_arg1
, char *string_arg2
)
317 int t_string_values (string_arg1
, string_arg2
)
318 char *string_arg1
, *string_arg2
;
321 return (!strcmp (string_arg1
, string_val1
) &&
322 !strcmp (string_arg2
, string_val2
));
326 int t_char_array_values (char char_array_arg1
[], char char_array_arg2
[])
328 int t_char_array_values (char_array_arg1
, char_array_arg2
)
329 char char_array_arg1
[], char_array_arg2
[];
332 return (!strcmp (char_array_arg1
, char_array_val1
) &&
333 !strcmp (char_array_arg2
, char_array_val2
));
337 int t_double_int (double double_arg1
, int int_arg2
)
339 int t_double_int (double_arg1
, int_arg2
)
344 return ((double_arg1
- int_arg2
) < DELTA
345 && (double_arg1
- int_arg2
) > -DELTA
);
349 int t_int_double (int int_arg1
, double double_arg2
)
351 int t_int_double (int_arg1
, double_arg2
)
356 return ((int_arg1
- double_arg2
) < DELTA
357 && (int_arg1
- double_arg2
) > -DELTA
);
360 /* This used to simply compare the function pointer arguments with
361 known values for func_val1 and func_val2. Doing so is valid ANSI
362 code, but on some machines (RS6000, HPPA, others?) it may fail when
363 called directly by GDB.
365 In a nutshell, it's not possible for GDB to determine when the address
366 of a function or the address of the function's stub/trampoline should
369 So, to avoid GDB lossage in the common case, we perform calls through the
370 various function pointers and compare the return values. For the HPPA
371 at least, this allows the common case to work.
373 If one wants to try something more complicated, pass the address of
374 a function accepting a "double" as one of its first 4 arguments. Call
375 that function indirectly through the function pointer. This would fail
379 int t_func_values (int (*func_arg1
)(int, int), int (*func_arg2
)(int))
381 int t_func_values (func_arg1
, func_arg2
)
382 int (*func_arg1
) PARAMS ((int, int));
383 int (*func_arg2
) PARAMS ((int));
386 return ((*func_arg1
) (5,5) == (*func_val1
) (5,5)
387 && (*func_arg2
) (6) == (*func_val2
) (6));
391 int t_call_add (int (*func_arg1
)(int, int), int a
, int b
)
393 int t_call_add (func_arg1
, a
, b
)
394 int (*func_arg1
) PARAMS ((int, int));
398 return ((*func_arg1
)(a
, b
));
402 /* Gotta have a main to be able to generate a linked, runnable
403 executable, and also provide a useful place to set a breakpoint. */
412 t_double_values(double_val1
, double_val2
);
413 t_structs_c(struct_val1
);
This page took 0.039179 seconds and 4 git commands to generate.