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