gdb/testsuite/gdb.base/callfuncs.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 1993-2014 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_ldc (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, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15;
 375 #else
 376 t_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
 395 #ifdef PROTOTYPES
 396 int t_double_values (double double_arg1, double double_arg2)
 397 #else
 398 int t_double_values (double_arg1, double_arg2)
 399 double double_arg1, double_arg2;
 400 #endif
 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
 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
 414 double
 415 #ifdef NO_PROTOTYPES
 416 t_double_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13,
 417                    f14, f15)
 418      double f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15;
 419 #else
 420 t_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
 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)                        \
 447 t_##NAME##_complex_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, \
 448                               f12, f13, f14, f15, f16)                  \
 449      TYPE _Complex f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, \
 450      f13, f14, f15, f16;
 451
 452 #define DEF_FUNC_MANY_ARGS_2(TYPE, NAME)                  \
 453 t_##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
 474 int
 475 #ifdef NO_PROTOTYPES
 476 DEF_FUNC_MANY_ARGS_1(float, float)
 477 #else
 478 DEF_FUNC_MANY_ARGS_2(float, float)
 479 #endif
 480 DEF_FUNC_MANY_ARGS_3(float, crealf, cimagf)
 481
 482 int
 483 #ifdef NO_PROTOTYPES
 484 DEF_FUNC_MANY_ARGS_1(double, double)
 485 #else
 486 DEF_FUNC_MANY_ARGS_2(double, double)
 487 #endif
 488 DEF_FUNC_MANY_ARGS_3(double, creal, cimag)
 489
 490 int
 491 #ifdef NO_PROTOTYPES
 492 DEF_FUNC_MANY_ARGS_1(long double, long_double)
 493 #else
 494 DEF_FUNC_MANY_ARGS_2(long double, long_double)
 495 #endif
 496 DEF_FUNC_MANY_ARGS_3(long double, creall, cimagl)
 497
 498 #define DEF_FUNC_VALUES_1(TYPE, NAME)                   \
 499   t_##NAME##_complex_values (f1, f2) TYPE _Complex f1, f2;
 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
 512 int
 513 #ifdef NO_PROTOTYPES
 514 DEF_FUNC_VALUES_1(float, float)
 515 #else
 516 DEF_FUNC_VALUES_2(float, float)
 517 #endif
 518 DEF_FUNC_VALUES_3(fc, float, crealf, cimagf)
 519
 520 int
 521 #ifdef NO_PROTOTYPES
 522 DEF_FUNC_VALUES_1(double, double)
 523 #else
 524 DEF_FUNC_VALUES_2(double, double)
 525 #endif
 526 DEF_FUNC_VALUES_3(fc, double, creal, cimag)
 527
 528 int
 529 #ifdef NO_PROTOTYPES
 530 DEF_FUNC_VALUES_1(long double, long_double)
 531 #else
 532 DEF_FUNC_VALUES_2(long double, long_double)
 533 #endif
 534 DEF_FUNC_VALUES_3(fc, long double, creall, cimagl)
 535
 536 #endif /* TEST_COMPLEX */
 537
 538
 539 #ifdef PROTOTYPES
 540 int t_string_values (char *string_arg1, char *string_arg2)
 541 #else
 542 int t_string_values (string_arg1, string_arg2)
 543 char *string_arg1, *string_arg2;
 544 #endif
 545 {
 546   return (!strcmp (string_arg1, string_val1) &&
 547           !strcmp (string_arg2, string_val2));
 548 }
 549
 550 #ifdef PROTOTYPES
 551 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 552 #else
 553 int t_char_array_values (char_array_arg1, char_array_arg2)
 554 char char_array_arg1[], char_array_arg2[];
 555 #endif
 556 {
 557   return (!strcmp (char_array_arg1, char_array_val1) &&
 558           !strcmp (char_array_arg2, char_array_val2));
 559 }
 560
 561 #ifdef PROTOTYPES
 562 int t_double_int (double double_arg1, int int_arg2)
 563 #else
 564 int t_double_int (double_arg1, int_arg2)
 565 double double_arg1;
 566 int int_arg2;
 567 #endif
 568 {
 569   return ((double_arg1 - int_arg2) < DELTA
 570           && (double_arg1 - int_arg2) > -DELTA);
 571 }
 572
 573 #ifdef PROTOTYPES
 574 int t_int_double (int int_arg1, double double_arg2)
 575 #else
 576 int t_int_double (int_arg1, double_arg2)
 577 int int_arg1;
 578 double double_arg2;
 579 #endif
 580 {
 581   return ((int_arg1 - double_arg2) < DELTA
 582           && (int_arg1 - double_arg2) > -DELTA);
 583 }
 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
 603 #ifdef PROTOTYPES
 604 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 605 #else
 606 int t_func_values (func_arg1, func_arg2)
 607 int (*func_arg1) PARAMS ((int, int));
 608 int (*func_arg2) PARAMS ((int));
 609 #endif
 610 {
 611   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
 612           && (*func_arg2) (6) == (*func_val2) (6));
 613 }
 614
 615 #ifdef PROTOTYPES
 616 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 617 #else
 618 int t_call_add (func_arg1, a, b)
 619 int (*func_arg1) PARAMS ((int, int));
 620 int a, b;
 621 #endif
 622 {
 623   return ((*func_arg1)(a, b));
 624 }
 625
 626 struct struct_with_fnptr
 627 {
 628   int (*func) PARAMS((int));
 629 };
 630
 631 struct struct_with_fnptr function_struct = { doubleit };
 632
 633 struct struct_with_fnptr *function_struct_ptr = &function_struct;
 634
 635 int *
 636 voidfunc (void)
 637 {
 638   static int twentythree = 23;
 639   return &twentythree;
 640 }
 641
 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. */
 644
 645 int main ()
 646 {
 647   void *p = malloc (1);
 648   t_double_values(double_val1, double_val2);
 649   t_structs_c(struct_val1);
 650   free (p);
 651   return 0 ;
 652 }
 653
 654 static int
 655 Lcallfunc (int arg)
 656 {
 657   return arg + 1;
 658 }
 659
 660 int
 661 callfunc (int (*func) (int value), int value)
 662 {
 663   return Lcallfunc (0) * 0 + func (value) * 2;
 664 }