utilsrc/srcX86MAC64/Admin/gdb-7.7.1/gdb/testsuite/gdb.hp/gdb.base-hp/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   t_structs_c(struct_val1);
 184   return 0;
 185
 186 }
 187
 188 /* Functions that expect specific values to be passed and return
 189    either 0 or 1, depending upon whether the values were
 190    passed incorrectly or correctly, respectively. */
 191
 192 #ifdef PROTOTYPES
 193 int t_char_values (char char_arg1, char char_arg2)
 194 #else
 195 int t_char_values (char_arg1, char_arg2)
 196 char char_arg1, char_arg2;
 197 #endif
 198 {
 199   return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
 200 }
 201
 202 int
 203 #ifdef PROTOTYPES
 204 t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
 205                 char arg6, short arg7, int arg8, short arg9, short arg10)
 206 #else
 207 t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
 208      char arg1;
 209      short arg2;
 210      int arg3;
 211      char arg4;
 212      short arg5;
 213      char arg6;
 214      short arg7;
 215      int arg8;
 216      short arg9;
 217      short arg10;
 218 #endif
 219 {
 220   return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
 221 }
 222
 223 #ifdef PROTOTYPES
 224 int t_short_values (short short_arg1, short short_arg2)
 225 #else
 226 int t_short_values (short_arg1, short_arg2)
 227 short short_arg1, short_arg2;
 228 #endif
 229 {
 230   return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
 231 }
 232
 233 #ifdef PROTOTYPES
 234 int t_int_values (int int_arg1, int int_arg2)
 235 #else
 236 int t_int_values (int_arg1, int_arg2)
 237 int int_arg1, int_arg2;
 238 #endif
 239 {
 240   return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
 241 }
 242
 243 #ifdef PROTOTYPES
 244 int t_long_values (long long_arg1, long long_arg2)
 245 #else
 246 int t_long_values (long_arg1, long_arg2)
 247 long long_arg1, long_arg2;
 248 #endif
 249 {
 250   return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
 251 }
 252
 253 /* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
 254    There must be one version of "t_float_values" (this one)
 255    that is not prototyped, and one (if supported) that is (following).
 256    That way GDB can be tested against both cases.  */
 257
 258 int t_float_values (float_arg1, float_arg2)
 259 float float_arg1, float_arg2;
 260 {
 261   return ((float_arg1 - float_val1) < DELTA
 262           && (float_arg1 - float_val1) > -DELTA
 263           && (float_arg2 - float_val2) < DELTA
 264           && (float_arg2 - float_val2) > -DELTA);
 265 }
 266
 267 int
 268 #ifdef NO_PROTOTYPES
 269 /* In this case we are just duplicating t_float_values, but that is the
 270    easiest way to deal with either ANSI or non-ANSI.  */
 271 t_float_values2 (float_arg1, float_arg2)
 272      float float_arg1, float_arg2;
 273 #else
 274 t_float_values2 (float float_arg1, float float_arg2)
 275 #endif
 276 {
 277   return ((float_arg1 - float_val1) < DELTA
 278           && (float_arg1 - float_val1) > -DELTA
 279           && (float_arg2 - float_val2) < DELTA
 280           && (float_arg2 - float_val2) > -DELTA);
 281 }
 282
 283 #ifdef PROTOTYPES
 284 int t_double_values (double double_arg1, double double_arg2)
 285 #else
 286 int t_double_values (double_arg1, double_arg2)
 287 double double_arg1, double_arg2;
 288 #endif
 289 {
 290   return ((double_arg1 - double_val1) < DELTA
 291           && (double_arg1 - double_val1) > -DELTA
 292           && (double_arg2 - double_val2) < DELTA
 293           && (double_arg2 - double_val2) > -DELTA);
 294 }
 295
 296 #ifdef PROTOTYPES
 297 int t_string_values (char *string_arg1, char *string_arg2)
 298 #else
 299 int t_string_values (string_arg1, string_arg2)
 300 char *string_arg1, *string_arg2;
 301 #endif
 302 {
 303   return (!strcmp (string_arg1, string_val1) &&
 304           !strcmp (string_arg2, string_val2));
 305 }
 306
 307 #ifdef PROTOTYPES
 308 int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
 309 #else
 310 int t_char_array_values (char_array_arg1, char_array_arg2)
 311 char char_array_arg1[], char_array_arg2[];
 312 #endif
 313 {
 314   return (!strcmp (char_array_arg1, char_array_val1) &&
 315           !strcmp (char_array_arg2, char_array_val2));
 316 }
 317
 318
 319 /* This used to simply compare the function pointer arguments with
 320    known values for func_val1 and func_val2.  Doing so is valid ANSI
 321    code, but on some machines (RS6000, HPPA, others?) it may fail when
 322    called directly by GDB.
 323
 324    In a nutshell, it's not possible for GDB to determine when the address
 325    of a function or the address of the function's stub/trampoline should
 326    be passed.
 327
 328    So, to avoid GDB lossage in the common case, we perform calls through the
 329    various function pointers and compare the return values.  For the HPPA
 330    at least, this allows the common case to work.
 331
 332    If one wants to try something more complicated, pass the address of
 333    a function accepting a "double" as one of its first 4 arguments.  Call
 334    that function indirectly through the function pointer.  This would fail
 335    on the HPPA.  */
 336
 337 #ifdef PROTOTYPES
 338 int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
 339 #else
 340 int t_func_values (func_arg1, func_arg2)
 341 int (*func_arg1) PARAMS ((int, int));
 342 int (*func_arg2) PARAMS ((int));
 343 #endif
 344 {
 345   return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
 346           && (*func_arg2) (6) == (*func_val2) (6));
 347 }
 348
 349 #ifdef PROTOTYPES
 350 int t_call_add (int (*func_arg1)(int, int), int a, int b)
 351 #else
 352 int t_call_add (func_arg1, a, b)
 353 int (*func_arg1) PARAMS ((int, int));
 354 int a, b;
 355 #endif
 356 {
 357   return ((*func_arg1)(a, b));
 358 }