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) { return (tstruct.a); }
 137 #else
 138 char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
 139 short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
 140 int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
 141 long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
 142 float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
 143 double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
 144 char  *t_structs_a (tstruct) struct struct1 tstruct; { return (tstruct.a); }
 145 #endif
 146
 147 /* Test that calling functions works if there are a lot of arguments.  */
 148 #ifdef PROTOTYPES
 149 int
 150 sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 151 #else
 152 int
 153 sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
 154      int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 155 #endif
 156 {
 157   return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
 158 }
 159
 160 /* Test that args are passed in the right order. */
 161 #ifdef PROTOTYPES
 162 int
 163 cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
 164 #else
 165 int
 166 cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
 167   int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
 168 #endif
 169 {
 170   return
 171     (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
 172     (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
 173 }
 174
 175
 176 /* Gotta have a main to be able to generate a linked, runnable
 177    executable, and also provide a useful place to set a breakpoint. */
 178 extern void * malloc() ;
 179 int main ()
 180 {
 181 #ifdef usestubs
 182   set_debug_traps();
 183   breakpoint();
 184 #endif
 185   malloc(1);
 186   t_structs_c(struct_val1);
 187   return 0 ;
 188 }
 189
 190 /* Functions that expect specific values to be passed and return
 191    either 0 or 1, depending upon whether the values were
 192    passed incorrectly or correctly, respectively. */
 193
 194 #ifdef PROTOTYPES
 195 int t_char_values (char char_arg1, char char_arg2)
 196 #else
 197 int t_char_values (char_arg1, char_arg2)
 198 char char_arg1, char_arg2;
 199 #endif
 200 {
 201   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 202 }
 203
 204 int
 205 #ifdef PROTOTYPES
 206 t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
 207                 char arg6, short arg7, int arg8, short arg9, short arg10)
 208 #else
 209 t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
 210      char arg1;
 211      short arg2;
 212      int arg3;
 213      char arg4;
 214      short arg5;
 215      char arg6;
 216      short arg7;
 217      int arg8;
 218      short arg9;
 219      short arg10;
 220 #endif
 221 {
 222   return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
 223 }
 224
 225 #ifdef PROTOTYPES
 226 int t_short_values (short short_arg1, short short_arg2)
 227 #else
 228 int t_short_values (short_arg1, short_arg2)
 229      short short_arg1, short_arg2;
 230 #endif
 231 {
 232   return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
 233 }
 234
 235 #ifdef PROTOTYPES
 236 int t_int_values (int int_arg1, int int_arg2)
 237 #else
 238 int t_int_values (int_arg1, int_arg2)
 239 int int_arg1, int_arg2;
 240 #endif
 241 {
 242   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 243 }
 244
 245 #ifdef PROTOTYPES
 246 int t_long_values (long long_arg1, long long_arg2)
 247 #else
 248 int t_long_values (long_arg1, long_arg2)
 249 long long_arg1, long_arg2;
 250 #endif
 251 {
 252   return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
 253 }
 254
 255 #ifdef PROTOTYPES
 256 int t_float_values (float float_arg1, float float_arg2)
 257 #else
 258 int t_float_values (float_arg1, float_arg2)
 259 float float_arg1, float_arg2;
 260 #endif
 261 {
 262   return ((float_arg1 - float_val1) < DELTA
 263           && (float_arg1 - float_val1) > -DELTA
 264           && (float_arg2 - float_val2) < DELTA
 265           && (float_arg2 - float_val2) > -DELTA);
 266 }
 267
 268 int
 269 #ifdef PROTOTYPES
 270 t_float_values2 (float float_arg1, float float_arg2)
 271 #else
 272 /* In this case we are just duplicating t_float_values, but that is the
 273    easiest way to deal with either ANSI or non-ANSI.  */
 274 t_float_values2 (float_arg1, float_arg2)
 275      float float_arg1, float_arg2;
 276 #endif
 277 {
 278   return ((float_arg1 - float_val1) < DELTA
 279           && (float_arg1 - float_val1) > -DELTA
 280           && (float_arg2 - float_val2) < DELTA
 281           && (float_arg2 - float_val2) > -DELTA);
 282 }
 283
 284 #ifdef PROTOTYPES
 285 int t_double_values (double double_arg1, double double_arg2)
 286 #else
 287 int t_double_values (double_arg1, double_arg2)
 288 double double_arg1, double_arg2;
 289 #endif
 290 {
 291   return ((double_arg1 - double_val1) < DELTA
 292           && (double_arg1 - double_val1) > -DELTA
 293           && (double_arg2 - double_val2) < DELTA
 294           && (double_arg2 - double_val2) > -DELTA);
 295 }
 296
 297 #ifdef PROTOTYPES
 298 int t_string_values (char *string_arg1, char *string_arg2)
 299 #else
 300 int t_string_values (string_arg1, string_arg2)
 301 char *string_arg1, *string_arg2;
 302 #endif
 303 {
 304   return (!strcmp (string_arg1, string_val1) &&
 305           !strcmp (string_arg2, string_val2));
 306 }
 307
 308 #ifdef PROTOTYPES
 309 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 310 #else
 311 int t_char_array_values (char_array_arg1, char_array_arg2)
 312 char char_array_arg1[], char_array_arg2[];
 313 #endif
 314 {
 315   return (!strcmp (char_array_arg1, char_array_val1) &&
 316           !strcmp (char_array_arg2, char_array_val2));
 317 }
 318
 319
 320 /* This used to simply compare the function pointer arguments with
 321    known values for func_val1 and func_val2.  Doing so is valid ANSI
 322    code, but on some machines (RS6000, HPPA, others?) it may fail when
 323    called directly by GDB.
 324
 325    In a nutshell, it's not possible for GDB to determine when the address
 326    of a function or the address of the function's stub/trampoline should
 327    be passed.
 328
 329    So, to avoid GDB lossage in the common case, we perform calls through the
 330    various function pointers and compare the return values.  For the HPPA
 331    at least, this allows the common case to work.
 332
 333    If one wants to try something more complicated, pass the address of
 334    a function accepting a "double" as one of its first 4 arguments.  Call
 335    that function indirectly through the function pointer.  This would fail
 336    on the HPPA.  */
 337
 338 #ifdef PROTOTYPES
 339 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 340 #else
 341 int t_func_values (func_arg1, func_arg2)
 342 int (*func_arg1) PARAMS ((int, int));
 343 int (*func_arg2) PARAMS ((int));
 344 #endif
 345 {
 346   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
 347           && (*func_arg2) (6) == (*func_val2) (6));
 348 }
 349
 350 #ifdef PROTOTYPES
 351 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 352 #else
 353 int t_call_add (func_arg1, a, b)
 354 int (*func_arg1) PARAMS ((int, int));
 355 int a, b;
 356 #endif
 357 {
 358   return ((*func_arg1)(a, b));
 359 }