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 } 363