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