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