1/* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 1993-2020 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 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; 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; 58 59double double_val1 = 45.654; 60double double_val2 = -67.66; 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; 74 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 99#define DELTA (0.001) 100 101char *string_val1 = (char *)"string 1"; 102char *string_val2 = (char *)"string 2"; 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]; 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 127int add (int a, int b) 128#else 129int add (a, b) int a, b; 130#endif 131{ 132 return (a + b); 133} 134 135#ifdef PROTOTYPES 136int doubleit (int a) 137#else 138int doubleit (a) int a; 139#endif 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 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 159{ 160 return (enum_arg == enum_val1); 161} 162 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 168{ 169 return (enum_arg == enum_val2); 170} 171 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 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 185int sum_args (int argc, int argv[]) 186#else 187int 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 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); } 210char *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 217float _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.fc;} 218double _Complex t_structs_dc (struct struct1 tstruct) { return tstruct.dc;} 219long double _Complex t_structs_ldc (struct struct1 tstruct) { return tstruct.ldc;} 220#endif 221#else 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); } 228char *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 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 239#endif 240 241/* Test that calling functions works if there are a lot of arguments. */ 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 246int 247sum10 (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 256int 257cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) 258#else 259int 260cmp10 (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 274int t_char_values (char char_arg1, char char_arg2) 275#else 276int t_char_values (char_arg1, char_arg2) 277char char_arg1, char_arg2; 278#endif 279{ 280 return ((char_arg1 == char_val1) && (char_arg2 == char_val2)); 281} 282 283int 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 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; 299#endif 300{ 301 return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10; 302} 303 304#ifdef PROTOTYPES 305int t_short_values (short short_arg1, short short_arg2) 306#else 307int 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 315int t_int_values (int int_arg1, int int_arg2) 316#else 317int t_int_values (int_arg1, int_arg2) 318int int_arg1, int_arg2; 319#endif 320{ 321 return ((int_arg1 == int_val1) && (int_arg2 == int_val2)); 322} 323 324#ifdef PROTOTYPES 325int t_long_values (long long_arg1, long long_arg2) 326#else 327int t_long_values (long_arg1, long_arg2) 328long 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 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 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. */ 352t_float_values2 (float_arg1, float_arg2) 353 float float_arg1, float_arg2; 354#else 355t_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 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) 374 float f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15; 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 395#ifdef PROTOTYPES 396int t_double_values (double double_arg1, double double_arg2) 397#else 398int t_double_values (double_arg1, double_arg2) 399double 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 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) 418 double f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15; 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 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) \ 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) \ 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) \ 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 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 539#ifdef PROTOTYPES 540int t_string_values (char *string_arg1, char *string_arg2) 541#else 542int t_string_values (string_arg1, string_arg2) 543char *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 551int t_char_array_values (char char_array_arg1[], char char_array_arg2[]) 552#else 553int t_char_array_values (char_array_arg1, char_array_arg2) 554char 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 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} 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 604int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int)) 605#else 606int t_func_values (func_arg1, func_arg2) 607int (*func_arg1) PARAMS ((int, int)); 608int (*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 616int t_call_add (int (*func_arg1)(int, int), int a, int b) 617#else 618int t_call_add (func_arg1, a, b) 619int (*func_arg1) PARAMS ((int, int)); 620int a, b; 621#endif 622{ 623 return ((*func_arg1)(a, b)); 624} 625 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; 634 635int * 636voidfunc (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 645int 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 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} 665