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