gdb/testsuite/gdb.base/callfuncs.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 1993-2013 Free Software Foundation, Inc.
   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
   7    the Free Software Foundation; either version 3 of the License, or
   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.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  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
  28 # include <stdlib.h>
  29 # include <string.h>
  30
  31 char char_val1 = 'a';
  32 char char_val2 = 'b';
  33
  34 short short_val1 = 10;
  35 short short_val2 = -23;
  36
  37 int int_val1 = 87;
  38 int int_val2 = -26;
  39
  40 long long_val1 = 789;
  41 long long_val2 = -321;
  42
  43 float float_val1 = 3.14159;
  44 float float_val2 = -2.3765;
  45 float float_val3 = 0.25;
  46 float float_val4 = 1.25;
  47 float float_val5 = 2.25;
  48 float float_val6 = 3.25;
  49 float float_val7 = 4.25;
  50 float float_val8 = 5.25;
  51 float float_val9 = 6.25;
  52 float float_val10 = 7.25;
  53 float float_val11 = 8.25;
  54 float float_val12 = 9.25;
  55 float float_val13 = 10.25;
  56 float float_val14 = 11.25;
  57 float float_val15 = 12.25;
  58
  59 double double_val1 = 45.654;
  60 double double_val2 = -67.66;
  61 double double_val3 = 0.25;
  62 double double_val4 = 1.25;
  63 double double_val5 = 2.25;
  64 double double_val6 = 3.25;
  65 double double_val7 = 4.25;
  66 double double_val8 = 5.25;
  67 double double_val9 = 6.25;
  68 double double_val10 = 7.25;
  69 double double_val11 = 8.25;
  70 double double_val12 = 9.25;
  71 double double_val13 = 10.25;
  72 double double_val14 = 11.25;
  73 double double_val15 = 12.25;
  74
  75 #ifdef TEST_COMPLEX
  76 extern float crealf (float _Complex);
  77 extern float cimagf (float _Complex);
  78 extern double creal (double _Complex);
  79 extern double cimag (double _Complex);
  80 extern long double creall (long double _Complex);
  81 extern long double cimagl (long double _Complex);
  82
  83 float _Complex fc1 = 1.0F + 1.0iF;
  84 float _Complex fc2 = 2.0F + 2.0iF;
  85 float _Complex fc3 = 3.0F + 3.0iF;
  86 float _Complex fc4 = 4.0F + 4.0iF;
  87
  88 double _Complex dc1 = 1.0 + 1.0i;
  89 double _Complex dc2 = 2.0 + 2.0i;
  90 double _Complex dc3 = 3.0 + 3.0i;
  91 double _Complex dc4 = 4.0 + 4.0i;
  92
  93 long double _Complex ldc1 = 1.0L + 1.0Li;
  94 long double _Complex ldc2 = 2.0L + 2.0Li;
  95 long double _Complex ldc3 = 3.0L + 3.0Li;
  96 long double _Complex ldc4 = 4.0L + 4.0Li;
  97 #endif /* TEST_COMPLEX */
  98
  99 #define DELTA (0.001)
 100
 101 char *string_val1 = (char *)"string 1";
 102 char *string_val2 = (char *)"string 2";
 103
 104 char char_array_val1[] = "carray 1";
 105 char char_array_val2[] = "carray 2";
 106
 107 struct struct1 {
 108   char c;
 109   short s;
 110   int i;
 111   long l;
 112   float f;
 113   double d;
 114   char a[4];
 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
 122 } struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
 123 #endif /* TEST_COMPLEX */
 124 /* Some functions that can be passed as arguments to other test
 125    functions, or called directly. */
 126 #ifdef PROTOTYPES
 127 int add (int a, int b)
 128 #else
 129 int add (a, b) int a, b;
 130 #endif
 131 {
 132   return (a + b);
 133 }
 134
 135 #ifdef PROTOTYPES
 136 int doubleit (int a)
 137 #else
 138 int doubleit (a) int a;
 139 #endif
 140 {
 141   return (a + a);
 142 }
 143
 144 int (*func_val1) PARAMS((int,int)) = add;
 145 int (*func_val2) PARAMS((int)) = doubleit;
 146
 147 /* An enumeration and functions that test for specific values. */
 148
 149 enum enumtype { enumval1, enumval2, enumval3 };
 150 enum enumtype enum_val1 = enumval1;
 151 enum enumtype enum_val2 = enumval2;
 152 enum enumtype enum_val3 = enumval3;
 153
 154 #ifdef PROTOTYPES
 155 int t_enum_value1 (enum enumtype enum_arg)
 156 #else
 157 int t_enum_value1 (enum_arg) enum enumtype enum_arg;
 158 #endif
 159 {
 160   return (enum_arg == enum_val1);
 161 }
 162
 163 #ifdef PROTOTYPES
 164 int t_enum_value2 (enum enumtype enum_arg)
 165 #else
 166 int t_enum_value2 (enum_arg) enum enumtype enum_arg;
 167 #endif
 168 {
 169   return (enum_arg == enum_val2);
 170 }
 171
 172 #ifdef PROTOTYPES
 173 int t_enum_value3 (enum enumtype enum_arg)
 174 #else
 175 int t_enum_value3 (enum_arg) enum enumtype enum_arg;
 176 #endif
 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
 184 #ifdef PROTOTYPES
 185 int sum_args (int argc, int argv[])
 186 #else
 187 int sum_args (argc, argv) int argc; int argv[];
 188 #endif
 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
 203 #ifdef PROTOTYPES
 204 char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
 205 short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
 206 int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
 207 long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
 208 float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
 209 double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
 210 char  *t_structs_a (struct struct1 tstruct)
 211 {
 212   static char buf[8];
 213   strcpy (buf, tstruct.a);
 214   return buf;
 215 }
 216 #ifdef TEST_COMPLEX
 217 float _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.fc;}
 218 double _Complex t_structs_dc (struct struct1 tstruct) { return tstruct.dc;}
 219 long double _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.ldc;}
 220 #endif
 221 #else
 222 char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
 223 short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
 224 int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
 225 long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
 226 float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
 227 double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
 228 char  *t_structs_a (tstruct) struct struct1 tstruct;
 229 {
 230   static char buf[8];
 231   strcpy (buf, tstruct.a);
 232   return buf;
 233 }
 234 #ifdef TEST_COMPLEX
 235 float _Complex t_structs_fc (tstruct) struct struct1 tstruct; { return tstruct.fc;}
 236 double _Complex t_structs_dc (tstruct) struct struct1 tstruct; { return tstruct.dc;}
 237 long double _Complex t_structs_ldc (tstruct) struct struct1 tstruct; { return tstruct.ldc;}
 238 #endif
 239 #endif
 240
 241 /* Test that calling functions works if there are a lot of arguments.  */
 242 #ifdef PROTOTYPES
 243 int
 244 sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 245 #else
 246 int
 247 sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
 248      int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 249 #endif
 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. */
 255 #ifdef PROTOTYPES
 256 int
 257 cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 258 #else
 259 int
 260 cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
 261   int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 262 #endif
 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
 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
 273 #ifdef PROTOTYPES
 274 int t_char_values (char char_arg1, char char_arg2)
 275 #else
 276 int t_char_values (char_arg1, char_arg2)
 277 char char_arg1, char_arg2;
 278 #endif
 279 {
 280   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 281 }
 282
 283 int
 284 #ifdef PROTOTYPES
 285 t_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
 288 t_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;
 299 #endif
 300 {
 301   return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
 302 }
 303
 304 #ifdef PROTOTYPES
 305 int t_short_values (short short_arg1, short short_arg2)
 306 #else
 307 int t_short_values (short_arg1, short_arg2)
 308      short short_arg1, short_arg2;
 309 #endif
 310 {
 311   return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
 312 }
 313
 314 #ifdef PROTOTYPES
 315 int t_int_values (int int_arg1, int int_arg2)
 316 #else
 317 int t_int_values (int_arg1, int_arg2)
 318 int int_arg1, int_arg2;
 319 #endif
 320 {
 321   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 322 }
 323
 324 #ifdef PROTOTYPES
 325 int t_long_values (long long_arg1, long long_arg2)
 326 #else
 327 int t_long_values (long_arg1, long_arg2)
 328 long long_arg1, long_arg2;
 329 #endif
 330 {
 331   return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
 332 }
 333
 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
 339 int t_float_values (float_arg1, float_arg2)
 340 float 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
 348 int
 349 #ifdef NO_PROTOTYPES
 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.  */
 352 t_float_values2 (float_arg1, float_arg2)
 353      float float_arg1, float_arg2;
 354 #else
 355 t_float_values2 (float float_arg1, float float_arg2)
 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
 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
 370 float
 371 #ifdef NO_PROTOTYPES
 372 t_float_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13,
 373                    f14, f15)
 374      float f1, float f2, float f3, float f4, float f5, float f6, float f7,
 375      float f8, float f9, float f10, float f11, float f12, float f13, float f14,
 376      float f15;
 377 #else
 378 t_float_many_args (float f1, float f2, float f3, float f4, float f5, float f6,
 379                    float f7, float f8, float f9, float f10, float f11,
 380                    float f12, float f13, float f14, float f15)
 381 #endif
 382 {
 383   float sum_args;
 384   float sum_values;
 385
 386   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 387              + f13 + f14 + f15;
 388   sum_values = float_val1 + float_val2 + float_val3 + float_val4 + float_val5
 389                + float_val6 + float_val7 + float_val8 + float_val9
 390                + float_val10 + float_val11 + float_val12 + float_val13
 391                + float_val14 + float_val15;
 392
 393   return ((sum_args - sum_values) < DELTA
 394           && (sum_args - sum_values) > -DELTA);
 395 }
 396
 397 #ifdef PROTOTYPES
 398 int t_double_values (double double_arg1, double double_arg2)
 399 #else
 400 int t_double_values (double_arg1, double_arg2)
 401 double double_arg1, double_arg2;
 402 #endif
 403 {
 404   return ((double_arg1 - double_val1) < DELTA
 405           && (double_arg1 - double_val1) > -DELTA
 406           && (double_arg2 - double_val2) < DELTA
 407           && (double_arg2 - double_val2) > -DELTA);
 408 }
 409
 410 /* This function has many arguments to force some of them to be passed via
 411    the stack instead of registers, to test that GDB can construct correctly
 412    the parameter save area. Note that Linux/ppc32 has 8 float registers to use
 413    for float parameter passing and Linux/ppc64 has 13, so the number of
 414    arguments has to be at least 14 to contemplate these platforms.  */
 415
 416 double
 417 #ifdef NO_PROTOTYPES
 418 t_double_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13,
 419                    f14, f15)
 420      double f1, double f2, double f3, double f4, double f5, double f6,
 421      double f7, double f8, double f9, double f10, double f11, double f12,
 422      double f13, double f14, double f15;
 423 #else
 424 t_double_many_args (double f1, double f2, double f3, double f4, double f5,
 425                     double f6, double f7, double f8, double f9, double f10,
 426                     double f11, double f12, double f13, double f14, double f15)
 427 #endif
 428 {
 429   double sum_args;
 430   double sum_values;
 431
 432   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 433              + f13 + f14 + f15;
 434   sum_values = double_val1 + double_val2 + double_val3 + double_val4
 435                + double_val5 + double_val6 + double_val7 + double_val8
 436                + double_val9 + double_val10 + double_val11 + double_val12
 437                + double_val13 + double_val14 + double_val15;
 438
 439   return ((sum_args - sum_values) < DELTA
 440           && (sum_args - sum_values) > -DELTA);
 441 }
 442
 443 /* Various functions for _Complex types.  */
 444
 445 #ifdef TEST_COMPLEX
 446
 447 #define COMPARE_WITHIN_RANGE(ARG1, ARG2, DEL, FUNC) \
 448   ((FUNC(ARG1) - FUNC(ARG2)) < DEL) && ((FUNC(ARG1) - FUNC(ARG2) > -DEL))
 449
 450 #define DEF_FUNC_MANY_ARGS_1(TYPE, NAME)                        \
 451 t_##NAME##_complex_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, \
 452                               f12, f13, f14, f15, f16)                  \
 453      TYPE _Complex f1, TYPE _Complex f2, TYPE _Complex f3, \
 454      TYPE _Complex f4, TYPE _Complex f5, TYPE _Complex f6, \
 455      TYPE _Complex f7, TYPE _Complex f8, TYPE _Complex f9, \
 456      TYPE _Complex f10, TYPE _Complex f11, TYPE _Complex f12, \
 457      TYPE _Complex f13, TYPE _Complex f14, TYPE _Complex f15, \
 458      TYPE _Complex f16;
 459
 460 #define DEF_FUNC_MANY_ARGS_2(TYPE, NAME)                  \
 461 t_##NAME##_complex_many_args (TYPE _Complex f1, TYPE _Complex f2, \
 462                               TYPE _Complex f3, TYPE _Complex f4, \
 463                               TYPE _Complex f5, TYPE _Complex f6, \
 464                               TYPE _Complex f7, TYPE _Complex f8, \
 465                               TYPE _Complex f9, TYPE _Complex f10,      \
 466                               TYPE _Complex f11, TYPE _Complex f12,     \
 467                               TYPE _Complex f13, TYPE _Complex f14,     \
 468                               TYPE _Complex f15, TYPE _Complex f16)
 469
 470 #define DEF_FUNC_MANY_ARGS_3(TYPE, CREAL, CIMAG) \
 471 { \
 472    TYPE _Complex expected = fc1 + fc2 + fc3 + fc4 + fc1 + fc2 + fc3 + fc4 \
 473     + fc1 + fc2 + fc3 + fc4 + fc1 + fc2 + fc3 + fc4; \
 474   TYPE _Complex actual = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 \
 475     + f11 + f12 + f13 + f14 + f15 + f16; \
 476   return (COMPARE_WITHIN_RANGE(expected, actual, DELTA, creal) \
 477           && COMPARE_WITHIN_RANGE(expected, actual, DELTA, creal) \
 478           && COMPARE_WITHIN_RANGE(expected, actual, DELTA, cimag)   \
 479           && COMPARE_WITHIN_RANGE(expected, actual, DELTA, cimag)); \
 480 }
 481
 482 int
 483 #ifdef NO_PROTOTYPES
 484 DEF_FUNC_MANY_ARGS_1(float, float)
 485 #else
 486 DEF_FUNC_MANY_ARGS_2(float, float)
 487 #endif
 488 DEF_FUNC_MANY_ARGS_3(float, crealf, cimagf)
 489
 490 int
 491 #ifdef NO_PROTOTYPES
 492 DEF_FUNC_MANY_ARGS_1(double, double)
 493 #else
 494 DEF_FUNC_MANY_ARGS_2(double, double)
 495 #endif
 496 DEF_FUNC_MANY_ARGS_3(double, creal, cimag)
 497
 498 int
 499 #ifdef NO_PROTOTYPES
 500 DEF_FUNC_MANY_ARGS_1(long double, long_double)
 501 #else
 502 DEF_FUNC_MANY_ARGS_2(long double, long_double)
 503 #endif
 504 DEF_FUNC_MANY_ARGS_3(long double, creall, cimagl)
 505
 506 #define DEF_FUNC_VALUES_1(TYPE, NAME)                   \
 507   t_##NAME##_complex_values (f1, f2) TYPE _Complex f1, TYPE _Complex f2;
 508
 509 #define DEF_FUNC_VALUES_2(TYPE, NAME) \
 510   t_##NAME##_complex_values (TYPE _Complex f1, TYPE _Complex f2)
 511
 512 #define DEF_FUNC_VALUES_3(FORMAL_PARM, TYPE, CREAL, CIMAG)      \
 513 { \
 514   return (COMPARE_WITHIN_RANGE(f1, FORMAL_PARM##1, DELTA, CREAL)    \
 515           && COMPARE_WITHIN_RANGE(f2, FORMAL_PARM##2, DELTA, CREAL)    \
 516           && COMPARE_WITHIN_RANGE(f1,  FORMAL_PARM##1, DELTA, CIMAG)   \
 517           && COMPARE_WITHIN_RANGE(f2,  FORMAL_PARM##2, DELTA, CIMAG)); \
 518 }
 519
 520 int
 521 #ifdef NO_PROTOTYPES
 522 DEF_FUNC_VALUES_1(float, float)
 523 #else
 524 DEF_FUNC_VALUES_2(float, float)
 525 #endif
 526 DEF_FUNC_VALUES_3(fc, float, crealf, cimagf)
 527
 528 int
 529 #ifdef NO_PROTOTYPES
 530 DEF_FUNC_VALUES_1(double, double)
 531 #else
 532 DEF_FUNC_VALUES_2(double, double)
 533 #endif
 534 DEF_FUNC_VALUES_3(fc, double, creal, cimag)
 535
 536 int
 537 #ifdef NO_PROTOTYPES
 538 DEF_FUNC_VALUES_1(long double, long_double)
 539 #else
 540 DEF_FUNC_VALUES_2(long double, long_double)
 541 #endif
 542 DEF_FUNC_VALUES_3(fc, long double, creall, cimagl)
 543
 544 #endif /* TEST_COMPLEX */
 545
 546
 547 #ifdef PROTOTYPES
 548 int t_string_values (char *string_arg1, char *string_arg2)
 549 #else
 550 int t_string_values (string_arg1, string_arg2)
 551 char *string_arg1, *string_arg2;
 552 #endif
 553 {
 554   return (!strcmp (string_arg1, string_val1) &&
 555           !strcmp (string_arg2, string_val2));
 556 }
 557
 558 #ifdef PROTOTYPES
 559 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 560 #else
 561 int t_char_array_values (char_array_arg1, char_array_arg2)
 562 char char_array_arg1[], char_array_arg2[];
 563 #endif
 564 {
 565   return (!strcmp (char_array_arg1, char_array_val1) &&
 566           !strcmp (char_array_arg2, char_array_val2));
 567 }
 568
 569 #ifdef PROTOTYPES
 570 int t_double_int (double double_arg1, int int_arg2)
 571 #else
 572 int t_double_int (double_arg1, int_arg2)
 573 double double_arg1;
 574 int int_arg2;
 575 #endif
 576 {
 577   return ((double_arg1 - int_arg2) < DELTA
 578           && (double_arg1 - int_arg2) > -DELTA);
 579 }
 580
 581 #ifdef PROTOTYPES
 582 int t_int_double (int int_arg1, double double_arg2)
 583 #else
 584 int t_int_double (int_arg1, double_arg2)
 585 int int_arg1;
 586 double double_arg2;
 587 #endif
 588 {
 589   return ((int_arg1 - double_arg2) < DELTA
 590           && (int_arg1 - double_arg2) > -DELTA);
 591 }
 592
 593 /* This used to simply compare the function pointer arguments with
 594    known values for func_val1 and func_val2.  Doing so is valid ANSI
 595    code, but on some machines (RS6000, HPPA, others?) it may fail when
 596    called directly by GDB.
 597
 598    In a nutshell, it's not possible for GDB to determine when the address
 599    of a function or the address of the function's stub/trampoline should
 600    be passed.
 601
 602    So, to avoid GDB lossage in the common case, we perform calls through the
 603    various function pointers and compare the return values.  For the HPPA
 604    at least, this allows the common case to work.
 605
 606    If one wants to try something more complicated, pass the address of
 607    a function accepting a "double" as one of its first 4 arguments.  Call
 608    that function indirectly through the function pointer.  This would fail
 609    on the HPPA.  */
 610
 611 #ifdef PROTOTYPES
 612 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 613 #else
 614 int t_func_values (func_arg1, func_arg2)
 615 int (*func_arg1) PARAMS ((int, int));
 616 int (*func_arg2) PARAMS ((int));
 617 #endif
 618 {
 619   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
 620           && (*func_arg2) (6) == (*func_val2) (6));
 621 }
 622
 623 #ifdef PROTOTYPES
 624 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 625 #else
 626 int t_call_add (func_arg1, a, b)
 627 int (*func_arg1) PARAMS ((int, int));
 628 int a, b;
 629 #endif
 630 {
 631   return ((*func_arg1)(a, b));
 632 }
 633
 634 struct struct_with_fnptr
 635 {
 636   int (*func) PARAMS((int));
 637 };
 638
 639 struct struct_with_fnptr function_struct = { doubleit };
 640
 641 struct struct_with_fnptr *function_struct_ptr = &function_struct;
 642
 643 int *
 644 voidfunc (void)
 645 {
 646   static int twentythree = 23;
 647   return &twentythree;
 648 }
 649
 650 /* Gotta have a main to be able to generate a linked, runnable
 651    executable, and also provide a useful place to set a breakpoint. */
 652
 653 int main ()
 654 {
 655   malloc(1);
 656   t_double_values(double_val1, double_val2);
 657   t_structs_c(struct_val1);
 658   return 0 ;
 659 }
 660
 661 static int
 662 Lcallfunc (int arg)
 663 {
 664   return arg + 1;
 665 }
 666
 667 int
 668 callfunc (int (*func) (int value), int value)
 669 {
 670   return Lcallfunc (0) * 0 + func (value) * 2;
 671 }