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 32char char_val1 = 'a'; 33char char_val2 = 'b'; 34 35short short_val1 = 10; 36short short_val2 = -23; 37 38int int_val1 = 87; 39int int_val2 = -26; 40 41long long_val1 = 789; 42long long_val2 = -321; 43 44float float_val1 = 3.14159; 45float float_val2 = -2.3765; 46float float_val3 = 0.25; 47float float_val4 = 1.25; 48float float_val5 = 2.25; 49float float_val6 = 3.25; 50float float_val7 = 4.25; 51float float_val8 = 5.25; 52float float_val9 = 6.25; 53float float_val10 = 7.25; 54float float_val11 = 8.25; 55float float_val12 = 9.25; 56float float_val13 = 10.25; 57float float_val14 = 11.25; 58float float_val15 = 12.25; 59 60double double_val1 = 45.654; 61double double_val2 = -67.66; 62double double_val3 = 0.25; 63double double_val4 = 1.25; 64double double_val5 = 2.25; 65double double_val6 = 3.25; 66double double_val7 = 4.25; 67double double_val8 = 5.25; 68double double_val9 = 6.25; 69double double_val10 = 7.25; 70double double_val11 = 8.25; 71double double_val12 = 9.25; 72double double_val13 = 10.25; 73double double_val14 = 11.25; 74double double_val15 = 12.25; 75 76#define DELTA (0.001) 77 78char *string_val1 = (char *)"string 1"; 79char *string_val2 = (char *)"string 2"; 80 81char char_array_val1[] = "carray 1"; 82char char_array_val2[] = "carray 2"; 83 84struct struct1 { 85 char c; 86 short s; 87 int i; 88 long l; 89 float f; 90 double d; 91 char a[4]; 92} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" }; 93 94/* Some functions that can be passed as arguments to other test 95 functions, or called directly. */ 96#ifdef PROTOTYPES 97int add (int a, int b) 98#else 99int add (a, b) int a, b; 100#endif 101{ 102 return (a + b); 103} 104 105#ifdef PROTOTYPES 106int doubleit (int a) 107#else 108int doubleit (a) int a; 109#endif 110{ 111 return (a + a); 112} 113 114int (*func_val1) PARAMS((int,int)) = add; 115int (*func_val2) PARAMS((int)) = doubleit; 116 117/* An enumeration and functions that test for specific values. */ 118 119enum enumtype { enumval1, enumval2, enumval3 }; 120enum enumtype enum_val1 = enumval1; 121enum enumtype enum_val2 = enumval2; 122enum enumtype enum_val3 = enumval3; 123 124#ifdef PROTOTYPES 125int t_enum_value1 (enum enumtype enum_arg) 126#else 127int t_enum_value1 (enum_arg) enum enumtype enum_arg; 128#endif 129{ 130 return (enum_arg == enum_val1); 131} 132 133#ifdef PROTOTYPES 134int t_enum_value2 (enum enumtype enum_arg) 135#else 136int t_enum_value2 (enum_arg) enum enumtype enum_arg; 137#endif 138{ 139 return (enum_arg == enum_val2); 140} 141 142#ifdef PROTOTYPES 143int t_enum_value3 (enum enumtype enum_arg) 144#else 145int t_enum_value3 (enum_arg) enum enumtype enum_arg; 146#endif 147{ 148 return (enum_arg == enum_val3); 149} 150 151/* A function that takes a vector of integers (along with an explicit 152 count) and returns their sum. */ 153 154#ifdef PROTOTYPES 155int sum_args (int argc, int argv[]) 156#else 157int sum_args (argc, argv) int argc; int argv[]; 158#endif 159{ 160 int sumval = 0; 161 int idx; 162 163 for (idx = 0; idx < argc; idx++) 164 { 165 sumval += argv[idx]; 166 } 167 return (sumval); 168} 169 170/* Test that we can call functions that take structs and return 171 members from that struct */ 172 173#ifdef PROTOTYPES 174char t_structs_c (struct struct1 tstruct) { return (tstruct.c); } 175short t_structs_s (struct struct1 tstruct) { return (tstruct.s); } 176int t_structs_i (struct struct1 tstruct) { return (tstruct.i); } 177long t_structs_l (struct struct1 tstruct) { return (tstruct.l); } 178float t_structs_f (struct struct1 tstruct) { return (tstruct.f); } 179double t_structs_d (struct struct1 tstruct) { return (tstruct.d); } 180char *t_structs_a (struct struct1 tstruct) 181{ 182 static char buf[8]; 183 strcpy (buf, tstruct.a); 184 return buf; 185} 186#else 187char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); } 188short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); } 189int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); } 190long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); } 191float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); } 192double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); } 193char *t_structs_a (tstruct) struct struct1 tstruct; 194{ 195 static char buf[8]; 196 strcpy (buf, tstruct.a); 197 return buf; 198} 199#endif 200 201/* Test that calling functions works if there are a lot of arguments. */ 202#ifdef PROTOTYPES 203int 204sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) 205#else 206int 207sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) 208 int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; 209#endif 210{ 211 return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9; 212} 213 214/* Test that args are passed in the right order. */ 215#ifdef PROTOTYPES 216int 217cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) 218#else 219int 220cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) 221 int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; 222#endif 223{ 224 return 225 (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) && 226 (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9); 227} 228 229/* Functions that expect specific values to be passed and return 230 either 0 or 1, depending upon whether the values were 231 passed incorrectly or correctly, respectively. */ 232 233#ifdef PROTOTYPES 234int t_char_values (char char_arg1, char char_arg2) 235#else 236int t_char_values (char_arg1, char_arg2) 237char char_arg1, char_arg2; 238#endif 239{ 240 return ((char_arg1 == char_val1) && (char_arg2 == char_val2)); 241} 242 243int 244#ifdef PROTOTYPES 245t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5, 246 char arg6, short arg7, int arg8, short arg9, short arg10) 247#else 248t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) 249 char arg1; 250 short arg2; 251 int arg3; 252 char arg4; 253 short arg5; 254 char arg6; 255 short arg7; 256 int arg8; 257 short arg9; 258 short arg10; 259#endif 260{ 261 return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10; 262} 263 264#ifdef PROTOTYPES 265int t_short_values (short short_arg1, short short_arg2) 266#else 267int t_short_values (short_arg1, short_arg2) 268 short short_arg1, short_arg2; 269#endif 270{ 271 return ((short_arg1 == short_val1) && (short_arg2 == short_val2)); 272} 273 274#ifdef PROTOTYPES 275int t_int_values (int int_arg1, int int_arg2) 276#else 277int t_int_values (int_arg1, int_arg2) 278int int_arg1, int_arg2; 279#endif 280{ 281 return ((int_arg1 == int_val1) && (int_arg2 == int_val2)); 282} 283 284#ifdef PROTOTYPES 285int t_long_values (long long_arg1, long long_arg2) 286#else 287int t_long_values (long_arg1, long_arg2) 288long long_arg1, long_arg2; 289#endif 290{ 291 return ((long_arg1 == long_val1) && (long_arg2 == long_val2)); 292} 293 294/* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!! 295 There must be one version of "t_float_values" (this one) 296 that is not prototyped, and one (if supported) that is (following). 297 That way GDB can be tested against both cases. */ 298 299int t_float_values (float_arg1, float_arg2) 300float float_arg1, float_arg2; 301{ 302 return ((float_arg1 - float_val1) < DELTA 303 && (float_arg1 - float_val1) > -DELTA 304 && (float_arg2 - float_val2) < DELTA 305 && (float_arg2 - float_val2) > -DELTA); 306} 307 308int 309#ifdef NO_PROTOTYPES 310/* In this case we are just duplicating t_float_values, but that is the 311 easiest way to deal with either ANSI or non-ANSI. */ 312t_float_values2 (float_arg1, float_arg2) 313 float float_arg1, float_arg2; 314#else 315t_float_values2 (float float_arg1, float float_arg2) 316#endif 317{ 318 return ((float_arg1 - float_val1) < DELTA 319 && (float_arg1 - float_val1) > -DELTA 320 && (float_arg2 - float_val2) < DELTA 321 && (float_arg2 - float_val2) > -DELTA); 322} 323 324/* This function has many arguments to force some of them to be passed via 325 the stack instead of registers, to test that GDB can construct correctly 326 the parameter save area. Note that Linux/ppc32 has 8 float registers to use 327 for float parameter passing and Linux/ppc64 has 13, so the number of 328 arguments has to be at least 14 to contemplate these platforms. */ 329 330float 331#ifdef NO_PROTOTYPES 332t_float_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, 333 f14, f15) 334 float f1, float f2, float f3, float f4, float f5, float f6, float f7, 335 float f8, float f9, float f10, float f11, float f12, float f13, float f14, 336 float f15; 337#else 338t_float_many_args (float f1, float f2, float f3, float f4, float f5, float f6, 339 float f7, float f8, float f9, float f10, float f11, 340 float f12, float f13, float f14, float f15) 341#endif 342{ 343 float sum_args; 344 float sum_values; 345 346 sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12 347 + f13 + f14 + f15; 348 sum_values = float_val1 + float_val2 + float_val3 + float_val4 + float_val5 349 + float_val6 + float_val7 + float_val8 + float_val9 350 + float_val10 + float_val11 + float_val12 + float_val13 351 + float_val14 + float_val15; 352 353 return ((sum_args - sum_values) < DELTA 354 && (sum_args - sum_values) > -DELTA); 355} 356 357#ifdef PROTOTYPES 358int t_double_values (double double_arg1, double double_arg2) 359#else 360int t_double_values (double_arg1, double_arg2) 361double double_arg1, double_arg2; 362#endif 363{ 364 return ((double_arg1 - double_val1) < DELTA 365 && (double_arg1 - double_val1) > -DELTA 366 && (double_arg2 - double_val2) < DELTA 367 && (double_arg2 - double_val2) > -DELTA); 368} 369 370/* This function has many arguments to force some of them to be passed via 371 the stack instead of registers, to test that GDB can construct correctly 372 the parameter save area. Note that Linux/ppc32 has 8 float registers to use 373 for float parameter passing and Linux/ppc64 has 13, so the number of 374 arguments has to be at least 14 to contemplate these platforms. */ 375 376double 377#ifdef NO_PROTOTYPES 378t_double_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, 379 f14, f15) 380 double f1, double f2, double f3, double f4, double f5, double f6, 381 double f7, double f8, double f9, double f10, double f11, double f12, 382 double f13, double f14, double f15; 383#else 384t_double_many_args (double f1, double f2, double f3, double f4, double f5, 385 double f6, double f7, double f8, double f9, double f10, 386 double f11, double f12, double f13, double f14, double f15) 387#endif 388{ 389 double sum_args; 390 double sum_values; 391 392 sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12 393 + f13 + f14 + f15; 394 sum_values = double_val1 + double_val2 + double_val3 + double_val4 395 + double_val5 + double_val6 + double_val7 + double_val8 396 + double_val9 + double_val10 + double_val11 + double_val12 397 + double_val13 + double_val14 + double_val15; 398 399 return ((sum_args - sum_values) < DELTA 400 && (sum_args - sum_values) > -DELTA); 401} 402 403#ifdef PROTOTYPES 404int t_string_values (char *string_arg1, char *string_arg2) 405#else 406int t_string_values (string_arg1, string_arg2) 407char *string_arg1, *string_arg2; 408#endif 409{ 410 return (!strcmp (string_arg1, string_val1) && 411 !strcmp (string_arg2, string_val2)); 412} 413 414#ifdef PROTOTYPES 415int t_char_array_values (char char_array_arg1[], char char_array_arg2[]) 416#else 417int t_char_array_values (char_array_arg1, char_array_arg2) 418char char_array_arg1[], char_array_arg2[]; 419#endif 420{ 421 return (!strcmp (char_array_arg1, char_array_val1) && 422 !strcmp (char_array_arg2, char_array_val2)); 423} 424 425#ifdef PROTOTYPES 426int t_double_int (double double_arg1, int int_arg2) 427#else 428int t_double_int (double_arg1, int_arg2) 429double double_arg1; 430int int_arg2; 431#endif 432{ 433 return ((double_arg1 - int_arg2) < DELTA 434 && (double_arg1 - int_arg2) > -DELTA); 435} 436 437#ifdef PROTOTYPES 438int t_int_double (int int_arg1, double double_arg2) 439#else 440int t_int_double (int_arg1, double_arg2) 441int int_arg1; 442double double_arg2; 443#endif 444{ 445 return ((int_arg1 - double_arg2) < DELTA 446 && (int_arg1 - double_arg2) > -DELTA); 447} 448 449/* This used to simply compare the function pointer arguments with 450 known values for func_val1 and func_val2. Doing so is valid ANSI 451 code, but on some machines (RS6000, HPPA, others?) it may fail when 452 called directly by GDB. 453 454 In a nutshell, it's not possible for GDB to determine when the address 455 of a function or the address of the function's stub/trampoline should 456 be passed. 457 458 So, to avoid GDB lossage in the common case, we perform calls through the 459 various function pointers and compare the return values. For the HPPA 460 at least, this allows the common case to work. 461 462 If one wants to try something more complicated, pass the address of 463 a function accepting a "double" as one of its first 4 arguments. Call 464 that function indirectly through the function pointer. This would fail 465 on the HPPA. */ 466 467#ifdef PROTOTYPES 468int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int)) 469#else 470int t_func_values (func_arg1, func_arg2) 471int (*func_arg1) PARAMS ((int, int)); 472int (*func_arg2) PARAMS ((int)); 473#endif 474{ 475 return ((*func_arg1) (5,5) == (*func_val1) (5,5) 476 && (*func_arg2) (6) == (*func_val2) (6)); 477} 478 479#ifdef PROTOTYPES 480int t_call_add (int (*func_arg1)(int, int), int a, int b) 481#else 482int t_call_add (func_arg1, a, b) 483int (*func_arg1) PARAMS ((int, int)); 484int a, b; 485#endif 486{ 487 return ((*func_arg1)(a, b)); 488} 489 490struct struct_with_fnptr 491{ 492 int (*func) PARAMS((int)); 493}; 494 495struct struct_with_fnptr function_struct = { doubleit }; 496 497struct struct_with_fnptr *function_struct_ptr = &function_struct; 498 499/* Gotta have a main to be able to generate a linked, runnable 500 executable, and also provide a useful place to set a breakpoint. */ 501 502int main () 503{ 504#ifdef usestubs 505 set_debug_traps(); 506 breakpoint(); 507#endif 508 malloc(1); 509 t_double_values(double_val1, double_val2); 510 t_structs_c(struct_val1); 511 return 0 ; 512} 513