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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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