projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR ld/14323
[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.base / callfuncs.c
CommitLineData
f453692c
MC		 1/* This testcase is part of GDB, the GNU debugger.
2
0b302171
JB		 3 Copyright 1993-1995, 1998-2001, 2004, 2007-2012 Free Software
4 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		 32char char_val1 = 'a';
33char char_val2 = 'b';
34
35short short_val1 = 10;
36short short_val2 = -23;
37
38int int_val1 = 87;
39int int_val2 = -26;
40
41long long_val1 = 789;
42long long_val2 = -321;
43
44float float_val1 = 3.14159;
45float float_val2 = -2.3765;
1a4ca44a
TJB		 46float float_val3 = 0.25;
47float float_val4 = 1.25;
48float float_val5 = 2.25;
49float float_val6 = 3.25;
50float float_val7 = 4.25;
51float float_val8 = 5.25;
52float float_val9 = 6.25;
53float float_val10 = 7.25;
54float float_val11 = 8.25;
55float float_val12 = 9.25;
56float float_val13 = 10.25;
57float float_val14 = 11.25;
58float float_val15 = 12.25;
c906108c
SS		 59
60double double_val1 = 45.654;
61double double_val2 = -67.66;
1a4ca44a
TJB		 62double double_val3 = 0.25;
63double double_val4 = 1.25;
64double double_val5 = 2.25;
65double double_val6 = 3.25;
66double double_val7 = 4.25;
67double double_val8 = 5.25;
68double double_val9 = 6.25;
69double double_val10 = 7.25;
70double double_val11 = 8.25;
71double double_val12 = 9.25;
72double double_val13 = 10.25;
73double double_val14 = 11.25;
74double double_val15 = 12.25;
c906108c 75
0578b8d1
YQ		 76#ifdef TEST_COMPLEX
77extern float crealf (float _Complex);
78extern float cimagf (float _Complex);
79extern double creal (double _Complex);
80extern double cimag (double _Complex);
81extern long double creall (long double _Complex);
82extern long double cimagl (long double _Complex);
83
84float _Complex fc1 = 1.0F + 1.0iF;
85float _Complex fc2 = 2.0F + 2.0iF;
86float _Complex fc3 = 3.0F + 3.0iF;
87float _Complex fc4 = 4.0F + 4.0iF;
88
89double _Complex dc1 = 1.0 + 1.0i;
90double _Complex dc2 = 2.0 + 2.0i;
91double _Complex dc3 = 3.0 + 3.0i;
92double _Complex dc4 = 4.0 + 4.0i;
93
94long double _Complex ldc1 = 1.0L + 1.0Li;
95long double _Complex ldc2 = 2.0L + 2.0Li;
96long double _Complex ldc3 = 3.0L + 3.0Li;
97long double _Complex ldc4 = 4.0L + 4.0Li;
98#endif /* TEST_COMPLEX */
99
c906108c
SS		 100#define DELTA (0.001)
101
085dd6e6
JM		 102char *string_val1 = (char *)"string 1";
103char *string_val2 = (char *)"string 2";
c906108c
SS		 104
105char char_array_val1[] = "carray 1";
106char char_array_val2[] = "carray 2";
107
108struct 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
128int add (int a, int b)
129#else
130int add (a, b) int a, b;
131#endif
c906108c
SS		 132{
133 return (a + b);
134}
135
085dd6e6
JM		 136#ifdef PROTOTYPES
137int doubleit (int a)
138#else
139int doubleit (a) int a;
140#endif
c906108c
SS		 141{
142 return (a + a);
143}
144
145int (*func_val1) PARAMS((int,int)) = add;
146int (*func_val2) PARAMS((int)) = doubleit;
147
148/* An enumeration and functions that test for specific values. */
149
150enum enumtype { enumval1, enumval2, enumval3 };
151enum enumtype enum_val1 = enumval1;
152enum enumtype enum_val2 = enumval2;
153enum enumtype enum_val3 = enumval3;
154
085dd6e6
JM		 155#ifdef PROTOTYPES
156int t_enum_value1 (enum enumtype enum_arg)
157#else
158int 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
165int t_enum_value2 (enum enumtype enum_arg)
166#else
167int 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
174int t_enum_value3 (enum enumtype enum_arg)
175#else
176int 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
186int sum_args (int argc, int argv[])
187#else
188int 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
205char t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
206short t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
207int t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
208long t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
209float t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
210double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
184d0bc8
FN		 211char *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
218float _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.fc;}
219double _Complex t_structs_dc (struct struct1 tstruct) { return tstruct.dc;}
220long double _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.ldc;}
221#endif
085dd6e6 222#else
c906108c
SS		 223char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
224short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
225int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
226long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
227float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
228double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
184d0bc8
FN		 229char *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
236float _Complex t_structs_fc (tstruct) struct struct1 tstruct; { return tstruct.fc;}
237double _Complex t_structs_dc (tstruct) struct struct1 tstruct; { return tstruct.dc;}
238long 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
244int
245sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
246#else
c906108c
SS		 247int
248sum10 (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
257int
258cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
259#else
c906108c
SS		 260int
261cmp10 (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
275int t_char_values (char char_arg1, char char_arg2)
276#else
c906108c
SS		 277int t_char_values (char_arg1, char_arg2)
278char char_arg1, char_arg2;
085dd6e6 279#endif
c906108c
SS		 280{
281 return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
282}
283
284int
085dd6e6
JM		 285#ifdef PROTOTYPES
286t_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		 289t_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
306int t_short_values (short short_arg1, short short_arg2)
307#else
c906108c 308int 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
316int t_int_values (int int_arg1, int int_arg2)
317#else
c906108c
SS		 318int t_int_values (int_arg1, int_arg2)
319int 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
326int t_long_values (long long_arg1, long long_arg2)
327#else
c906108c
SS		 328int t_long_values (long_arg1, long_arg2)
329long 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		 340int t_float_values (float_arg1, float_arg2)
341float 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
349int
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. */
353t_float_values2 (float_arg1, float_arg2)
354 float float_arg1, float_arg2;
3bf40917
MS		 355#else
356t_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
371float
372#ifdef NO_PROTOTYPES
373t_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
379t_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
399int t_double_values (double double_arg1, double double_arg2)
400#else
c906108c
SS		 401int t_double_values (double_arg1, double_arg2)
402double 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
417double
418#ifdef NO_PROTOTYPES
419t_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
425t_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) \
452t_##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) \
462t_##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
483int
484#ifdef NO_PROTOTYPES
485DEF_FUNC_MANY_ARGS_1(float, float)
486#else
487DEF_FUNC_MANY_ARGS_2(float, float)
488#endif
489DEF_FUNC_MANY_ARGS_3(float, crealf, cimagf)
490
491int
492#ifdef NO_PROTOTYPES
493DEF_FUNC_MANY_ARGS_1(double, double)
494#else
495DEF_FUNC_MANY_ARGS_2(double, double)
496#endif
497DEF_FUNC_MANY_ARGS_3(double, creal, cimag)
498
499int
500#ifdef NO_PROTOTYPES
501DEF_FUNC_MANY_ARGS_1(long double, long_double)
502#else
503DEF_FUNC_MANY_ARGS_2(long double, long_double)
504#endif
505DEF_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
521int
522#ifdef NO_PROTOTYPES
523DEF_FUNC_VALUES_1(float, float)
524#else
525DEF_FUNC_VALUES_2(float, float)
526#endif
527DEF_FUNC_VALUES_3(fc, float, crealf, cimagf)
528
529int
530#ifdef NO_PROTOTYPES
531DEF_FUNC_VALUES_1(double, double)
532#else
533DEF_FUNC_VALUES_2(double, double)
534#endif
535DEF_FUNC_VALUES_3(fc, double, creal, cimag)
536
537int
538#ifdef NO_PROTOTYPES
539DEF_FUNC_VALUES_1(long double, long_double)
540#else
541DEF_FUNC_VALUES_2(long double, long_double)
542#endif
543DEF_FUNC_VALUES_3(fc, long double, creall, cimagl)
544
545#endif /* TEST_COMPLEX */
546
547
085dd6e6
JM		 548#ifdef PROTOTYPES
549int t_string_values (char *string_arg1, char *string_arg2)
550#else
c906108c
SS		 551int t_string_values (string_arg1, string_arg2)
552char *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
560int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
561#else
c906108c
SS		 562int t_char_array_values (char_array_arg1, char_array_arg2)
563char 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
571int t_double_int (double double_arg1, int int_arg2)
572#else
573int t_double_int (double_arg1, int_arg2)
574double double_arg1;
575int int_arg2;
576#endif
577{
578 return ((double_arg1 - int_arg2) < DELTA
579 && (double_arg1 - int_arg2) > -DELTA);
580}
581
582#ifdef PROTOTYPES
583int t_int_double (int int_arg1, double double_arg2)
584#else
585int t_int_double (int_arg1, double_arg2)
586int int_arg1;
587double 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
613int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
614#else
c906108c
SS		 615int t_func_values (func_arg1, func_arg2)
616int (*func_arg1) PARAMS ((int, int));
617int (*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
625int t_call_add (int (*func_arg1)(int, int), int a, int b)
626#else
c906108c
SS		 627int t_call_add (func_arg1, a, b)
628int (*func_arg1) PARAMS ((int, int));
629int a, b;
085dd6e6 630#endif
c906108c
SS		 631{
632 return ((*func_arg1)(a, b));
633}
c7db355b 634
fa8de41e
TT		 635struct struct_with_fnptr
636{
637 int (*func) PARAMS((int));
638};
639
640struct struct_with_fnptr function_struct = { doubleit };
641
642struct 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		 647int main ()
648{
c7db355b
PS		 649 malloc(1);
650 t_double_values(double_val1, double_val2);
651 t_structs_c(struct_val1);
652 return 0 ;
653}
90359a16
JK		 654
655static int
656Lcallfunc (int arg)
657{
658 return arg + 1;
659}
660
661int
662callfunc (int (*func) (int value), int value)
663{
664 return Lcallfunc (0) * 0 + func (value) * 2;
665}
GDB Binutils - Deliverables
This page took 1.189309 seconds and 4 git commands to generate.