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, 2009
   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 /* 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
  32 char char_val1 = 'a';
  33 char char_val2 = 'b';
  34
  35 short short_val1 = 10;
  36 short short_val2 = -23;
  37
  38 int int_val1 = 87;
  39 int int_val2 = -26;
  40
  41 long long_val1 = 789;
  42 long long_val2 = -321;
  43
  44 float float_val1 = 3.14159;
  45 float float_val2 = -2.3765;
  46 float float_val3 = 0.25;
  47 float float_val4 = 1.25;
  48 float float_val5 = 2.25;
  49 float float_val6 = 3.25;
  50 float float_val7 = 4.25;
  51 float float_val8 = 5.25;
  52 float float_val9 = 6.25;
  53 float float_val10 = 7.25;
  54 float float_val11 = 8.25;
  55 float float_val12 = 9.25;
  56 float float_val13 = 10.25;
  57 float float_val14 = 11.25;
  58 float float_val15 = 12.25;
  59
  60 double double_val1 = 45.654;
  61 double double_val2 = -67.66;
  62 double double_val3 = 0.25;
  63 double double_val4 = 1.25;
  64 double double_val5 = 2.25;
  65 double double_val6 = 3.25;
  66 double double_val7 = 4.25;
  67 double double_val8 = 5.25;
  68 double double_val9 = 6.25;
  69 double double_val10 = 7.25;
  70 double double_val11 = 8.25;
  71 double double_val12 = 9.25;
  72 double double_val13 = 10.25;
  73 double double_val14 = 11.25;
  74 double double_val15 = 12.25;
  75
  76 #define DELTA (0.001)
  77
  78 char *string_val1 = (char *)"string 1";
  79 char *string_val2 = (char *)"string 2";
  80
  81 char char_array_val1[] = "carray 1";
  82 char char_array_val2[] = "carray 2";
  83
  84 struct 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
  97 int add (int a, int b)
  98 #else
  99 int add (a, b) int a, b;
 100 #endif
 101 {
 102   return (a + b);
 103 }
 104
 105 #ifdef PROTOTYPES
 106 int doubleit (int a)
 107 #else
 108 int doubleit (a) int a;
 109 #endif
 110 {
 111   return (a + a);
 112 }
 113
 114 int (*func_val1) PARAMS((int,int)) = add;
 115 int (*func_val2) PARAMS((int)) = doubleit;
 116
 117 /* An enumeration and functions that test for specific values. */
 118
 119 enum enumtype { enumval1, enumval2, enumval3 };
 120 enum enumtype enum_val1 = enumval1;
 121 enum enumtype enum_val2 = enumval2;
 122 enum enumtype enum_val3 = enumval3;
 123
 124 #ifdef PROTOTYPES
 125 int t_enum_value1 (enum enumtype enum_arg)
 126 #else
 127 int t_enum_value1 (enum_arg) enum enumtype enum_arg;
 128 #endif
 129 {
 130   return (enum_arg == enum_val1);
 131 }
 132
 133 #ifdef PROTOTYPES
 134 int t_enum_value2 (enum enumtype enum_arg)
 135 #else
 136 int t_enum_value2 (enum_arg) enum enumtype enum_arg;
 137 #endif
 138 {
 139   return (enum_arg == enum_val2);
 140 }
 141
 142 #ifdef PROTOTYPES
 143 int t_enum_value3 (enum enumtype enum_arg)
 144 #else
 145 int 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
 155 int sum_args (int argc, int argv[])
 156 #else
 157 int 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
 174 char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
 175 short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
 176 int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
 177 long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
 178 float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
 179 double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
 180 char  *t_structs_a (struct struct1 tstruct)
 181 {
 182   static char buf[8];
 183   strcpy (buf, tstruct.a);
 184   return buf;
 185 }
 186 #else
 187 char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
 188 short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
 189 int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
 190 long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
 191 float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
 192 double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
 193 char  *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
 203 int
 204 sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 205 #else
 206 int
 207 sum10 (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
 216 int
 217 cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 218 #else
 219 int
 220 cmp10 (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
 234 int t_char_values (char char_arg1, char char_arg2)
 235 #else
 236 int t_char_values (char_arg1, char_arg2)
 237 char char_arg1, char_arg2;
 238 #endif
 239 {
 240   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 241 }
 242
 243 int
 244 #ifdef PROTOTYPES
 245 t_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
 248 t_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
 265 int t_short_values (short short_arg1, short short_arg2)
 266 #else
 267 int 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
 275 int t_int_values (int int_arg1, int int_arg2)
 276 #else
 277 int t_int_values (int_arg1, int_arg2)
 278 int int_arg1, int_arg2;
 279 #endif
 280 {
 281   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 282 }
 283
 284 #ifdef PROTOTYPES
 285 int t_long_values (long long_arg1, long long_arg2)
 286 #else
 287 int t_long_values (long_arg1, long_arg2)
 288 long 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
 299 int t_float_values (float_arg1, float_arg2)
 300 float 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
 308 int
 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.  */
 312 t_float_values2 (float_arg1, float_arg2)
 313      float float_arg1, float_arg2;
 314 #else
 315 t_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
 330 float
 331 #ifdef NO_PROTOTYPES
 332 t_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
 338 t_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
 358 int t_double_values (double double_arg1, double double_arg2)
 359 #else
 360 int t_double_values (double_arg1, double_arg2)
 361 double 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
 376 double
 377 #ifdef NO_PROTOTYPES
 378 t_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
 384 t_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
 404 int t_string_values (char *string_arg1, char *string_arg2)
 405 #else
 406 int t_string_values (string_arg1, string_arg2)
 407 char *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
 415 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 416 #else
 417 int t_char_array_values (char_array_arg1, char_array_arg2)
 418 char 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
 426 int t_double_int (double double_arg1, int int_arg2)
 427 #else
 428 int t_double_int (double_arg1, int_arg2)
 429 double double_arg1;
 430 int int_arg2;
 431 #endif
 432 {
 433   return ((double_arg1 - int_arg2) < DELTA
 434           && (double_arg1 - int_arg2) > -DELTA);
 435 }
 436
 437 #ifdef PROTOTYPES
 438 int t_int_double (int int_arg1, double double_arg2)
 439 #else
 440 int t_int_double (int_arg1, double_arg2)
 441 int int_arg1;
 442 double 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
 468 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 469 #else
 470 int t_func_values (func_arg1, func_arg2)
 471 int (*func_arg1) PARAMS ((int, int));
 472 int (*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
 480 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 481 #else
 482 int t_call_add (func_arg1, a, b)
 483 int (*func_arg1) PARAMS ((int, int));
 484 int a, b;
 485 #endif
 486 {
 487   return ((*func_arg1)(a, b));
 488 }
 489
 490 struct struct_with_fnptr
 491 {
 492   int (*func) PARAMS((int));
 493 };
 494
 495 struct struct_with_fnptr function_struct = { doubleit };
 496
 497 struct 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
 502 int 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 }