gdb/testsuite/gdb.base/callfuncs2.c

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