gdb/testsuite/gdb.base/callfuncs.c

   1 /* Support program for testing gdb's ability to call functions
   2    in the inferior, pass appropriate arguments to those functions,
   3    and get the returned result. */
   4
   5 #ifdef NO_PROTOTYPES
   6 #define PARAMS(paramlist) ()
   7 #else
   8 #define PARAMS(paramlist) paramlist
   9 #endif
  10
  11 # include <stdlib.h>
  12 # include <string.h>
  13
  14 char char_val1 = 'a';
  15 char char_val2 = 'b';
  16
  17 short short_val1 = 10;
  18 short short_val2 = -23;
  19
  20 int int_val1 = 87;
  21 int int_val2 = -26;
  22
  23 long long_val1 = 789;
  24 long long_val2 = -321;
  25
  26 float float_val1 = 3.14159;
  27 float float_val2 = -2.3765;
  28
  29 double double_val1 = 45.654;
  30 double double_val2 = -67.66;
  31
  32 #define DELTA (0.001)
  33
  34 char *string_val1 = (char *)"string 1";
  35 char *string_val2 = (char *)"string 2";
  36
  37 char char_array_val1[] = "carray 1";
  38 char char_array_val2[] = "carray 2";
  39
  40 struct struct1 {
  41   char c;
  42   short s;
  43   int i;
  44   long l;
  45   float f;
  46   double d;
  47   char a[4];
  48 } struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
  49
  50 /* Some functions that can be passed as arguments to other test
  51    functions, or called directly. */
  52 #ifdef PROTOTYPES
  53 int add (int a, int b)
  54 #else
  55 int add (a, b) int a, b;
  56 #endif
  57 {
  58   return (a + b);
  59 }
  60
  61 #ifdef PROTOTYPES
  62 int doubleit (int a)
  63 #else
  64 int doubleit (a) int a;
  65 #endif
  66 {
  67   return (a + a);
  68 }
  69
  70 int (*func_val1) PARAMS((int,int)) = add;
  71 int (*func_val2) PARAMS((int)) = doubleit;
  72
  73 /* An enumeration and functions that test for specific values. */
  74
  75 enum enumtype { enumval1, enumval2, enumval3 };
  76 enum enumtype enum_val1 = enumval1;
  77 enum enumtype enum_val2 = enumval2;
  78 enum enumtype enum_val3 = enumval3;
  79
  80 #ifdef PROTOTYPES
  81 int t_enum_value1 (enum enumtype enum_arg)
  82 #else
  83 int t_enum_value1 (enum_arg) enum enumtype enum_arg;
  84 #endif
  85 {
  86   return (enum_arg == enum_val1);
  87 }
  88
  89 #ifdef PROTOTYPES
  90 int t_enum_value2 (enum enumtype enum_arg)
  91 #else
  92 int t_enum_value2 (enum_arg) enum enumtype enum_arg;
  93 #endif
  94 {
  95   return (enum_arg == enum_val2);
  96 }
  97
  98 #ifdef PROTOTYPES
  99 int t_enum_value3 (enum enumtype enum_arg)
 100 #else
 101 int t_enum_value3 (enum_arg) enum enumtype enum_arg;
 102 #endif
 103 {
 104   return (enum_arg == enum_val3);
 105 }
 106
 107 /* A function that takes a vector of integers (along with an explicit
 108    count) and returns their sum. */
 109
 110 #ifdef PROTOTYPES
 111 int sum_args (int argc, int argv[])
 112 #else
 113 int sum_args (argc, argv) int argc; int argv[];
 114 #endif
 115 {
 116   int sumval = 0;
 117   int idx;
 118
 119   for (idx = 0; idx < argc; idx++)
 120     {
 121       sumval += argv[idx];
 122     }
 123   return (sumval);
 124 }
 125
 126 /* Test that we can call functions that take structs and return
 127    members from that struct */
 128
 129 #ifdef PROTOTYPES
 130 char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
 131 short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
 132 int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
 133 long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
 134 float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
 135 double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
 136 char  *t_structs_a (struct struct1 tstruct)
 137 {
 138   static char buf[8];
 139   strcpy (buf, tstruct.a);
 140   return buf;
 141 }
 142 #else
 143 char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
 144 short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
 145 int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
 146 long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
 147 float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
 148 double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
 149 char  *t_structs_a (tstruct) struct struct1 tstruct;
 150 {
 151   static char buf[8];
 152   strcpy (buf, tstruct.a);
 153   return buf;
 154 }
 155 #endif
 156
 157 /* Test that calling functions works if there are a lot of arguments.  */
 158 #ifdef PROTOTYPES
 159 int
 160 sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 161 #else
 162 int
 163 sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
 164      int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 165 #endif
 166 {
 167   return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
 168 }
 169
 170 /* Test that args are passed in the right order. */
 171 #ifdef PROTOTYPES
 172 int
 173 cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 174 #else
 175 int
 176 cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
 177   int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 178 #endif
 179 {
 180   return
 181     (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
 182     (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
 183 }
 184
 185 /* Functions that expect specific values to be passed and return
 186    either 0 or 1, depending upon whether the values were
 187    passed incorrectly or correctly, respectively. */
 188
 189 #ifdef PROTOTYPES
 190 int t_char_values (char char_arg1, char char_arg2)
 191 #else
 192 int t_char_values (char_arg1, char_arg2)
 193 char char_arg1, char_arg2;
 194 #endif
 195 {
 196   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 197 }
 198
 199 int
 200 #ifdef PROTOTYPES
 201 t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
 202                 char arg6, short arg7, int arg8, short arg9, short arg10)
 203 #else
 204 t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
 205      char arg1;
 206      short arg2;
 207      int arg3;
 208      char arg4;
 209      short arg5;
 210      char arg6;
 211      short arg7;
 212      int arg8;
 213      short arg9;
 214      short arg10;
 215 #endif
 216 {
 217   return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
 218 }
 219
 220 #ifdef PROTOTYPES
 221 int t_short_values (short short_arg1, short short_arg2)
 222 #else
 223 int t_short_values (short_arg1, short_arg2)
 224      short short_arg1, short_arg2;
 225 #endif
 226 {
 227   return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
 228 }
 229
 230 #ifdef PROTOTYPES
 231 int t_int_values (int int_arg1, int int_arg2)
 232 #else
 233 int t_int_values (int_arg1, int_arg2)
 234 int int_arg1, int_arg2;
 235 #endif
 236 {
 237   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 238 }
 239
 240 #ifdef PROTOTYPES
 241 int t_long_values (long long_arg1, long long_arg2)
 242 #else
 243 int t_long_values (long_arg1, long_arg2)
 244 long long_arg1, long_arg2;
 245 #endif
 246 {
 247   return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
 248 }
 249
 250 /* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
 251    There must be one version of "t_float_values" (this one)
 252    that is not prototyped, and one (if supported) that is (following).
 253    That way GDB can be tested against both cases.  */
 254
 255 int t_float_values (float_arg1, float_arg2)
 256 float float_arg1, float_arg2;
 257 {
 258   return ((float_arg1 - float_val1) < DELTA
 259           && (float_arg1 - float_val1) > -DELTA
 260           && (float_arg2 - float_val2) < DELTA
 261           && (float_arg2 - float_val2) > -DELTA);
 262 }
 263
 264 int
 265 #ifdef NO_PROTOTYPES
 266 /* In this case we are just duplicating t_float_values, but that is the
 267    easiest way to deal with either ANSI or non-ANSI.  */
 268 t_float_values2 (float_arg1, float_arg2)
 269      float float_arg1, float_arg2;
 270 #else
 271 t_float_values2 (float float_arg1, float float_arg2)
 272 #endif
 273 {
 274   return ((float_arg1 - float_val1) < DELTA
 275           && (float_arg1 - float_val1) > -DELTA
 276           && (float_arg2 - float_val2) < DELTA
 277           && (float_arg2 - float_val2) > -DELTA);
 278 }
 279
 280 #ifdef PROTOTYPES
 281 int t_double_values (double double_arg1, double double_arg2)
 282 #else
 283 int t_double_values (double_arg1, double_arg2)
 284 double double_arg1, double_arg2;
 285 #endif
 286 {
 287   return ((double_arg1 - double_val1) < DELTA
 288           && (double_arg1 - double_val1) > -DELTA
 289           && (double_arg2 - double_val2) < DELTA
 290           && (double_arg2 - double_val2) > -DELTA);
 291 }
 292
 293 #ifdef PROTOTYPES
 294 int t_string_values (char *string_arg1, char *string_arg2)
 295 #else
 296 int t_string_values (string_arg1, string_arg2)
 297 char *string_arg1, *string_arg2;
 298 #endif
 299 {
 300   return (!strcmp (string_arg1, string_val1) &&
 301           !strcmp (string_arg2, string_val2));
 302 }
 303
 304 #ifdef PROTOTYPES
 305 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 306 #else
 307 int t_char_array_values (char_array_arg1, char_array_arg2)
 308 char char_array_arg1[], char_array_arg2[];
 309 #endif
 310 {
 311   return (!strcmp (char_array_arg1, char_array_val1) &&
 312           !strcmp (char_array_arg2, char_array_val2));
 313 }
 314
 315
 316 /* This used to simply compare the function pointer arguments with
 317    known values for func_val1 and func_val2.  Doing so is valid ANSI
 318    code, but on some machines (RS6000, HPPA, others?) it may fail when
 319    called directly by GDB.
 320
 321    In a nutshell, it's not possible for GDB to determine when the address
 322    of a function or the address of the function's stub/trampoline should
 323    be passed.
 324
 325    So, to avoid GDB lossage in the common case, we perform calls through the
 326    various function pointers and compare the return values.  For the HPPA
 327    at least, this allows the common case to work.
 328
 329    If one wants to try something more complicated, pass the address of
 330    a function accepting a "double" as one of its first 4 arguments.  Call
 331    that function indirectly through the function pointer.  This would fail
 332    on the HPPA.  */
 333
 334 #ifdef PROTOTYPES
 335 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 336 #else
 337 int t_func_values (func_arg1, func_arg2)
 338 int (*func_arg1) PARAMS ((int, int));
 339 int (*func_arg2) PARAMS ((int));
 340 #endif
 341 {
 342   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
 343           && (*func_arg2) (6) == (*func_val2) (6));
 344 }
 345
 346 #ifdef PROTOTYPES
 347 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 348 #else
 349 int t_call_add (func_arg1, a, b)
 350 int (*func_arg1) PARAMS ((int, int));
 351 int a, b;
 352 #endif
 353 {
 354   return ((*func_arg1)(a, b));
 355 }
 356
 357
 358 /* Gotta have a main to be able to generate a linked, runnable
 359    executable, and also provide a useful place to set a breakpoint. */
 360 extern void * malloc() ;
 361 int main ()
 362 {
 363 #ifdef usestubs
 364   set_debug_traps();
 365   breakpoint();
 366 #endif
 367   malloc(1);
 368   t_double_values(double_val1, double_val2);
 369   t_structs_c(struct_val1);
 370   return 0 ;
 371 }