gdb/testsuite/gdb.base/callfuncs.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2004, 2007, 2008, 2009,
   4    2010, 2011 Free Software Foundation, Inc.
   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
   8    the Free Software Foundation; either version 3 of the License, or
   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.
  15
  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/>.  */
  18
  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
  29 # include <stdlib.h>
  30 # include <string.h>
  31
  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;
  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;
  59
  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;
  75
  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
 100 #define DELTA (0.001)
 101
 102 char *string_val1 = (char *)"string 1";
 103 char *string_val2 = (char *)"string 2";
 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];
 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
 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. */
 127 #ifdef PROTOTYPES
 128 int add (int a, int b)
 129 #else
 130 int add (a, b) int a, b;
 131 #endif
 132 {
 133   return (a + b);
 134 }
 135
 136 #ifdef PROTOTYPES
 137 int doubleit (int a)
 138 #else
 139 int doubleit (a) int a;
 140 #endif
 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
 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
 160 {
 161   return (enum_arg == enum_val1);
 162 }
 163
 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
 169 {
 170   return (enum_arg == enum_val2);
 171 }
 172
 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
 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
 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
 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
 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); }
 211 char  *t_structs_a (struct struct1 tstruct)
 212 {
 213   static char buf[8];
 214   strcpy (buf, tstruct.a);
 215   return buf;
 216 }
 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
 222 #else
 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;
 230 {
 231   static char buf[8];
 232   strcpy (buf, tstruct.a);
 233   return buf;
 234 }
 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
 240 #endif
 241
 242 /* Test that calling functions works if there are a lot of arguments.  */
 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
 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;
 250 #endif
 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. */
 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
 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;
 263 #endif
 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
 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
 274 #ifdef PROTOTYPES
 275 int t_char_values (char char_arg1, char char_arg2)
 276 #else
 277 int t_char_values (char_arg1, char_arg2)
 278 char char_arg1, char_arg2;
 279 #endif
 280 {
 281   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 282 }
 283
 284 int
 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
 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;
 300 #endif
 301 {
 302   return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
 303 }
 304
 305 #ifdef PROTOTYPES
 306 int t_short_values (short short_arg1, short short_arg2)
 307 #else
 308 int t_short_values (short_arg1, short_arg2)
 309      short short_arg1, short_arg2;
 310 #endif
 311 {
 312   return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
 313 }
 314
 315 #ifdef PROTOTYPES
 316 int t_int_values (int int_arg1, int int_arg2)
 317 #else
 318 int t_int_values (int_arg1, int_arg2)
 319 int int_arg1, int_arg2;
 320 #endif
 321 {
 322   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 323 }
 324
 325 #ifdef PROTOTYPES
 326 int t_long_values (long long_arg1, long long_arg2)
 327 #else
 328 int t_long_values (long_arg1, long_arg2)
 329 long long_arg1, long_arg2;
 330 #endif
 331 {
 332   return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
 333 }
 334
 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
 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
 350 #ifdef NO_PROTOTYPES
 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;
 355 #else
 356 t_float_values2 (float float_arg1, float float_arg2)
 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
 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
 398 #ifdef PROTOTYPES
 399 int t_double_values (double double_arg1, double double_arg2)
 400 #else
 401 int t_double_values (double_arg1, double_arg2)
 402 double double_arg1, double_arg2;
 403 #endif
 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
 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
 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
 548 #ifdef PROTOTYPES
 549 int t_string_values (char *string_arg1, char *string_arg2)
 550 #else
 551 int t_string_values (string_arg1, string_arg2)
 552 char *string_arg1, *string_arg2;
 553 #endif
 554 {
 555   return (!strcmp (string_arg1, string_val1) &&
 556           !strcmp (string_arg2, string_val2));
 557 }
 558
 559 #ifdef PROTOTYPES
 560 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 561 #else
 562 int t_char_array_values (char_array_arg1, char_array_arg2)
 563 char char_array_arg1[], char_array_arg2[];
 564 #endif
 565 {
 566   return (!strcmp (char_array_arg1, char_array_val1) &&
 567           !strcmp (char_array_arg2, char_array_val2));
 568 }
 569
 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 }
 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
 612 #ifdef PROTOTYPES
 613 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 614 #else
 615 int t_func_values (func_arg1, func_arg2)
 616 int (*func_arg1) PARAMS ((int, int));
 617 int (*func_arg2) PARAMS ((int));
 618 #endif
 619 {
 620   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
 621           && (*func_arg2) (6) == (*func_val2) (6));
 622 }
 623
 624 #ifdef PROTOTYPES
 625 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 626 #else
 627 int t_call_add (func_arg1, a, b)
 628 int (*func_arg1) PARAMS ((int, int));
 629 int a, b;
 630 #endif
 631 {
 632   return ((*func_arg1)(a, b));
 633 }
 634
 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;
 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. */
 646
 647 int main ()
 648 {
 649   malloc(1);
 650   t_double_values(double_val1, double_val2);
 651   t_structs_c(struct_val1);
 652   return 0 ;
 653 }
 654
 655 static int
 656 Lcallfunc (int arg)
 657 {
 658   return arg + 1;
 659 }
 660
 661 int
 662 callfunc (int (*func) (int value), int value)
 663 {
 664   return Lcallfunc (0) * 0 + func (value) * 2;
 665 }