OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [testsuite/] [gdb.base/] [callfuncs.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* This testcase is part of GDB, the GNU debugger.
2
 
3
   Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2004, 2007, 2008, 2009,
4
   2010 Free Software Foundation, Inc.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
 
19
/* Support program for testing gdb's ability to call functions
20
   in the inferior, pass appropriate arguments to those functions,
21
   and get the returned result. */
22
 
23
#ifdef NO_PROTOTYPES
24
#define PARAMS(paramlist) ()
25
#else
26
#define PARAMS(paramlist) paramlist
27
#endif
28
 
29
# include <stdlib.h>
30
# include <string.h>
31
 
32
char char_val1 = 'a';
33
char char_val2 = 'b';
34
 
35
short short_val1 = 10;
36
short short_val2 = -23;
37
 
38
int int_val1 = 87;
39
int int_val2 = -26;
40
 
41
long long_val1 = 789;
42
long long_val2 = -321;
43
 
44
float float_val1 = 3.14159;
45
float float_val2 = -2.3765;
46
float float_val3 = 0.25;
47
float float_val4 = 1.25;
48
float float_val5 = 2.25;
49
float float_val6 = 3.25;
50
float float_val7 = 4.25;
51
float float_val8 = 5.25;
52
float float_val9 = 6.25;
53
float float_val10 = 7.25;
54
float float_val11 = 8.25;
55
float float_val12 = 9.25;
56
float float_val13 = 10.25;
57
float float_val14 = 11.25;
58
float float_val15 = 12.25;
59
 
60
double double_val1 = 45.654;
61
double double_val2 = -67.66;
62
double double_val3 = 0.25;
63
double double_val4 = 1.25;
64
double double_val5 = 2.25;
65
double double_val6 = 3.25;
66
double double_val7 = 4.25;
67
double double_val8 = 5.25;
68
double double_val9 = 6.25;
69
double double_val10 = 7.25;
70
double double_val11 = 8.25;
71
double double_val12 = 9.25;
72
double double_val13 = 10.25;
73
double double_val14 = 11.25;
74
double double_val15 = 12.25;
75
 
76
#define DELTA (0.001)
77
 
78
char *string_val1 = (char *)"string 1";
79
char *string_val2 = (char *)"string 2";
80
 
81
char char_array_val1[] = "carray 1";
82
char char_array_val2[] = "carray 2";
83
 
84
struct struct1 {
85
  char c;
86
  short s;
87
  int i;
88
  long l;
89
  float f;
90
  double d;
91
  char a[4];
92
} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
93
 
94
/* Some functions that can be passed as arguments to other test
95
   functions, or called directly. */
96
#ifdef PROTOTYPES
97
int add (int a, int b)
98
#else
99
int add (a, b) int a, b;
100
#endif
101
{
102
  return (a + b);
103
}
104
 
105
#ifdef PROTOTYPES
106
int doubleit (int a)
107
#else
108
int doubleit (a) int a;
109
#endif
110
{
111
  return (a + a);
112
}
113
 
114
int (*func_val1) PARAMS((int,int)) = add;
115
int (*func_val2) PARAMS((int)) = doubleit;
116
 
117
/* An enumeration and functions that test for specific values. */
118
 
119
enum enumtype { enumval1, enumval2, enumval3 };
120
enum enumtype enum_val1 = enumval1;
121
enum enumtype enum_val2 = enumval2;
122
enum enumtype enum_val3 = enumval3;
123
 
124
#ifdef PROTOTYPES
125
int t_enum_value1 (enum enumtype enum_arg)
126
#else
127
int t_enum_value1 (enum_arg) enum enumtype enum_arg;
128
#endif
129
{
130
  return (enum_arg == enum_val1);
131
}
132
 
133
#ifdef PROTOTYPES
134
int t_enum_value2 (enum enumtype enum_arg)
135
#else
136
int t_enum_value2 (enum_arg) enum enumtype enum_arg;
137
#endif
138
{
139
  return (enum_arg == enum_val2);
140
}
141
 
142
#ifdef PROTOTYPES
143
int t_enum_value3 (enum enumtype enum_arg)
144
#else
145
int t_enum_value3 (enum_arg) enum enumtype enum_arg;
146
#endif
147
{
148
  return (enum_arg == enum_val3);
149
}
150
 
151
/* A function that takes a vector of integers (along with an explicit
152
   count) and returns their sum. */
153
 
154
#ifdef PROTOTYPES
155
int sum_args (int argc, int argv[])
156
#else
157
int sum_args (argc, argv) int argc; int argv[];
158
#endif
159
{
160
  int sumval = 0;
161
  int idx;
162
 
163
  for (idx = 0; idx < argc; idx++)
164
    {
165
      sumval += argv[idx];
166
    }
167
  return (sumval);
168
}
169
 
170
/* Test that we can call functions that take structs and return
171
   members from that struct */
172
 
173
#ifdef PROTOTYPES
174
char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
175
short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
176
int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
177
long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
178
float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
179
double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
180
char  *t_structs_a (struct struct1 tstruct)
181
{
182
  static char buf[8];
183
  strcpy (buf, tstruct.a);
184
  return buf;
185
}
186
#else
187
char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
188
short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
189
int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
190
long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
191
float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
192
double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
193
char  *t_structs_a (tstruct) struct struct1 tstruct;
194
{
195
  static char buf[8];
196
  strcpy (buf, tstruct.a);
197
  return buf;
198
}
199
#endif
200
 
201
/* Test that calling functions works if there are a lot of arguments.  */
202
#ifdef PROTOTYPES
203
int
204
sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
205
#else
206
int
207
sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
208
     int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
209
#endif
210
{
211
  return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
212
}
213
 
214
/* Test that args are passed in the right order. */
215
#ifdef PROTOTYPES
216
int
217
cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
218
#else
219
int
220
cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
221
  int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
222
#endif
223
{
224
  return
225
    (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
226
    (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
227
}
228
 
229
/* Functions that expect specific values to be passed and return
230
   either 0 or 1, depending upon whether the values were
231
   passed incorrectly or correctly, respectively. */
232
 
233
#ifdef PROTOTYPES
234
int t_char_values (char char_arg1, char char_arg2)
235
#else
236
int t_char_values (char_arg1, char_arg2)
237
char char_arg1, char_arg2;
238
#endif
239
{
240
  return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
241
}
242
 
243
int
244
#ifdef PROTOTYPES
245
t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
246
                char arg6, short arg7, int arg8, short arg9, short arg10)
247
#else
248
t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
249
     char arg1;
250
     short arg2;
251
     int arg3;
252
     char arg4;
253
     short arg5;
254
     char arg6;
255
     short arg7;
256
     int arg8;
257
     short arg9;
258
     short arg10;
259
#endif
260
{
261
  return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
262
}
263
 
264
#ifdef PROTOTYPES
265
int t_short_values (short short_arg1, short short_arg2)
266
#else
267
int t_short_values (short_arg1, short_arg2)
268
     short short_arg1, short_arg2;
269
#endif
270
{
271
  return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
272
}
273
 
274
#ifdef PROTOTYPES
275
int t_int_values (int int_arg1, int int_arg2)
276
#else
277
int t_int_values (int_arg1, int_arg2)
278
int int_arg1, int_arg2;
279
#endif
280
{
281
  return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
282
}
283
 
284
#ifdef PROTOTYPES
285
int t_long_values (long long_arg1, long long_arg2)
286
#else
287
int t_long_values (long_arg1, long_arg2)
288
long long_arg1, long_arg2;
289
#endif
290
{
291
  return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
292
}
293
 
294
/* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
295
   There must be one version of "t_float_values" (this one)
296
   that is not prototyped, and one (if supported) that is (following).
297
   That way GDB can be tested against both cases.  */
298
 
299
int t_float_values (float_arg1, float_arg2)
300
float float_arg1, float_arg2;
301
{
302
  return ((float_arg1 - float_val1) < DELTA
303
          && (float_arg1 - float_val1) > -DELTA
304
          && (float_arg2 - float_val2) < DELTA
305
          && (float_arg2 - float_val2) > -DELTA);
306
}
307
 
308
int
309
#ifdef NO_PROTOTYPES
310
/* In this case we are just duplicating t_float_values, but that is the
311
   easiest way to deal with either ANSI or non-ANSI.  */
312
t_float_values2 (float_arg1, float_arg2)
313
     float float_arg1, float_arg2;
314
#else
315
t_float_values2 (float float_arg1, float float_arg2)
316
#endif
317
{
318
  return ((float_arg1 - float_val1) < DELTA
319
          && (float_arg1 - float_val1) > -DELTA
320
          && (float_arg2 - float_val2) < DELTA
321
          && (float_arg2 - float_val2) > -DELTA);
322
}
323
 
324
/* This function has many arguments to force some of them to be passed via
325
   the stack instead of registers, to test that GDB can construct correctly
326
   the parameter save area. Note that Linux/ppc32 has 8 float registers to use
327
   for float parameter passing and Linux/ppc64 has 13, so the number of
328
   arguments has to be at least 14 to contemplate these platforms.  */
329
 
330
float
331
#ifdef NO_PROTOTYPES
332
t_float_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13,
333
                   f14, f15)
334
     float f1, float f2, float f3, float f4, float f5, float f6, float f7,
335
     float f8, float f9, float f10, float f11, float f12, float f13, float f14,
336
     float f15;
337
#else
338
t_float_many_args (float f1, float f2, float f3, float f4, float f5, float f6,
339
                   float f7, float f8, float f9, float f10, float f11,
340
                   float f12, float f13, float f14, float f15)
341
#endif
342
{
343
  float sum_args;
344
  float sum_values;
345
 
346
  sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
347
             + f13 + f14 + f15;
348
  sum_values = float_val1 + float_val2 + float_val3 + float_val4 + float_val5
349
               + float_val6 + float_val7 + float_val8 + float_val9
350
               + float_val10 + float_val11 + float_val12 + float_val13
351
               + float_val14 + float_val15;
352
 
353
  return ((sum_args - sum_values) < DELTA
354
          && (sum_args - sum_values) > -DELTA);
355
}
356
 
357
#ifdef PROTOTYPES
358
int t_double_values (double double_arg1, double double_arg2)
359
#else
360
int t_double_values (double_arg1, double_arg2)
361
double double_arg1, double_arg2;
362
#endif
363
{
364
  return ((double_arg1 - double_val1) < DELTA
365
          && (double_arg1 - double_val1) > -DELTA
366
          && (double_arg2 - double_val2) < DELTA
367
          && (double_arg2 - double_val2) > -DELTA);
368
}
369
 
370
/* This function has many arguments to force some of them to be passed via
371
   the stack instead of registers, to test that GDB can construct correctly
372
   the parameter save area. Note that Linux/ppc32 has 8 float registers to use
373
   for float parameter passing and Linux/ppc64 has 13, so the number of
374
   arguments has to be at least 14 to contemplate these platforms.  */
375
 
376
double
377
#ifdef NO_PROTOTYPES
378
t_double_many_args (f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13,
379
                   f14, f15)
380
     double f1, double f2, double f3, double f4, double f5, double f6,
381
     double f7, double f8, double f9, double f10, double f11, double f12,
382
     double f13, double f14, double f15;
383
#else
384
t_double_many_args (double f1, double f2, double f3, double f4, double f5,
385
                    double f6, double f7, double f8, double f9, double f10,
386
                    double f11, double f12, double f13, double f14, double f15)
387
#endif
388
{
389
  double sum_args;
390
  double sum_values;
391
 
392
  sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
393
             + f13 + f14 + f15;
394
  sum_values = double_val1 + double_val2 + double_val3 + double_val4
395
               + double_val5 + double_val6 + double_val7 + double_val8
396
               + double_val9 + double_val10 + double_val11 + double_val12
397
               + double_val13 + double_val14 + double_val15;
398
 
399
  return ((sum_args - sum_values) < DELTA
400
          && (sum_args - sum_values) > -DELTA);
401
}
402
 
403
#ifdef PROTOTYPES
404
int t_string_values (char *string_arg1, char *string_arg2)
405
#else
406
int t_string_values (string_arg1, string_arg2)
407
char *string_arg1, *string_arg2;
408
#endif
409
{
410
  return (!strcmp (string_arg1, string_val1) &&
411
          !strcmp (string_arg2, string_val2));
412
}
413
 
414
#ifdef PROTOTYPES
415
int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
416
#else
417
int t_char_array_values (char_array_arg1, char_array_arg2)
418
char char_array_arg1[], char_array_arg2[];
419
#endif
420
{
421
  return (!strcmp (char_array_arg1, char_array_val1) &&
422
          !strcmp (char_array_arg2, char_array_val2));
423
}
424
 
425
#ifdef PROTOTYPES
426
int t_double_int (double double_arg1, int int_arg2)
427
#else
428
int t_double_int (double_arg1, int_arg2)
429
double double_arg1;
430
int int_arg2;
431
#endif
432
{
433
  return ((double_arg1 - int_arg2) < DELTA
434
          && (double_arg1 - int_arg2) > -DELTA);
435
}
436
 
437
#ifdef PROTOTYPES
438
int t_int_double (int int_arg1, double double_arg2)
439
#else
440
int t_int_double (int_arg1, double_arg2)
441
int int_arg1;
442
double double_arg2;
443
#endif
444
{
445
  return ((int_arg1 - double_arg2) < DELTA
446
          && (int_arg1 - double_arg2) > -DELTA);
447
}
448
 
449
/* This used to simply compare the function pointer arguments with
450
   known values for func_val1 and func_val2.  Doing so is valid ANSI
451
   code, but on some machines (RS6000, HPPA, others?) it may fail when
452
   called directly by GDB.
453
 
454
   In a nutshell, it's not possible for GDB to determine when the address
455
   of a function or the address of the function's stub/trampoline should
456
   be passed.
457
 
458
   So, to avoid GDB lossage in the common case, we perform calls through the
459
   various function pointers and compare the return values.  For the HPPA
460
   at least, this allows the common case to work.
461
 
462
   If one wants to try something more complicated, pass the address of
463
   a function accepting a "double" as one of its first 4 arguments.  Call
464
   that function indirectly through the function pointer.  This would fail
465
   on the HPPA.  */
466
 
467
#ifdef PROTOTYPES
468
int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
469
#else
470
int t_func_values (func_arg1, func_arg2)
471
int (*func_arg1) PARAMS ((int, int));
472
int (*func_arg2) PARAMS ((int));
473
#endif
474
{
475
  return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
476
          && (*func_arg2) (6) == (*func_val2) (6));
477
}
478
 
479
#ifdef PROTOTYPES
480
int t_call_add (int (*func_arg1)(int, int), int a, int b)
481
#else
482
int t_call_add (func_arg1, a, b)
483
int (*func_arg1) PARAMS ((int, int));
484
int a, b;
485
#endif
486
{
487
  return ((*func_arg1)(a, b));
488
}
489
 
490
struct struct_with_fnptr
491
{
492
  int (*func) PARAMS((int));
493
};
494
 
495
struct struct_with_fnptr function_struct = { doubleit };
496
 
497
struct struct_with_fnptr *function_struct_ptr = &function_struct;
498
 
499
/* Gotta have a main to be able to generate a linked, runnable
500
   executable, and also provide a useful place to set a breakpoint. */
501
 
502
int main ()
503
{
504
#ifdef usestubs
505
  set_debug_traps();
506
  breakpoint();
507
#endif
508
  malloc(1);
509
  t_double_values(double_val1, double_val2);
510
  t_structs_c(struct_val1);
511
  return 0 ;
512
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.