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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [testsuite/] [gdb.base/] [callfuncs.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* Support program for testing gdb's ability to call functions
2
   in the inferior, pass appropriate arguments to those functions,
3
   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 <stdlib.h>
12
# include <string.h>
13
 
14
char char_val1 = 'a';
15
char char_val2 = 'b';
16
 
17
short short_val1 = 10;
18
short short_val2 = -23;
19
 
20
int int_val1 = 87;
21
int int_val2 = -26;
22
 
23
long long_val1 = 789;
24
long long_val2 = -321;
25
 
26
float float_val1 = 3.14159;
27
float float_val2 = -2.3765;
28
 
29
double double_val1 = 45.654;
30
double double_val2 = -67.66;
31
 
32
#define DELTA (0.001)
33
 
34
char *string_val1 = (char *)"string 1";
35
char *string_val2 = (char *)"string 2";
36
 
37
char char_array_val1[] = "carray 1";
38
char char_array_val2[] = "carray 2";
39
 
40
struct struct1 {
41
  char c;
42
  short s;
43
  int i;
44
  long l;
45
  float f;
46
  double d;
47
  char a[4];
48
} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
49
 
50
/* Some functions that can be passed as arguments to other test
51
   functions, or called directly. */
52
#ifdef PROTOTYPES
53
int add (int a, int b)
54
#else
55
int add (a, b) int a, b;
56
#endif
57
{
58
  return (a + b);
59
}
60
 
61
#ifdef PROTOTYPES
62
int doubleit (int a)
63
#else
64
int doubleit (a) 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
int t_enum_value1 (enum_arg) enum enumtype enum_arg;
84
#endif
85
{
86
  return (enum_arg == enum_val1);
87
}
88
 
89
#ifdef PROTOTYPES
90
int t_enum_value2 (enum enumtype enum_arg)
91
#else
92
int t_enum_value2 (enum_arg) enum enumtype enum_arg;
93
#endif
94
{
95
  return (enum_arg == enum_val2);
96
}
97
 
98
#ifdef PROTOTYPES
99
int t_enum_value3 (enum enumtype enum_arg)
100
#else
101
int t_enum_value3 (enum_arg) enum enumtype enum_arg;
102
#endif
103
{
104
  return (enum_arg == enum_val3);
105
}
106
 
107
/* A function that takes a vector of integers (along with an explicit
108
   count) and returns their sum. */
109
 
110
#ifdef PROTOTYPES
111
int sum_args (int argc, int argv[])
112
#else
113
int sum_args (argc, argv) int argc; int argv[];
114
#endif
115
{
116
  int sumval = 0;
117
  int idx;
118
 
119
  for (idx = 0; idx < argc; idx++)
120
    {
121
      sumval += argv[idx];
122
    }
123
  return (sumval);
124
}
125
 
126
/* Test that we can call functions that take structs and return
127
   members from that struct */
128
 
129
#ifdef PROTOTYPES
130
char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
131
short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
132
int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
133
long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
134
float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
135
double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
136
char  *t_structs_a (struct struct1 tstruct) { return (tstruct.a); }
137
#else
138
char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
139
short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
140
int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
141
long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
142
float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
143
double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
144
char  *t_structs_a (tstruct) struct struct1 tstruct; { return (tstruct.a); }
145
#endif
146
 
147
/* Test that calling functions works if there are a lot of arguments.  */
148
#ifdef PROTOTYPES
149
int
150
sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
151
#else
152
int
153
sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
154
     int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
155
#endif
156
{
157
  return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
158
}
159
 
160
/* Test that args are passed in the right order. */
161
#ifdef PROTOTYPES
162
int
163
cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
164
#else
165
int
166
cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
167
  int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
168
#endif
169
{
170
  return
171
    (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
172
    (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
173
}
174
 
175
 
176
/* Gotta have a main to be able to generate a linked, runnable
177
   executable, and also provide a useful place to set a breakpoint. */
178
extern void * malloc() ;
179
int main ()
180
{
181
#ifdef usestubs
182
  set_debug_traps();
183
  breakpoint();
184
#endif
185
  malloc(1);
186
  t_structs_c(struct_val1);
187
  return 0 ;
188
}
189
 
190
/* Functions that expect specific values to be passed and return
191
   either 0 or 1, depending upon whether the values were
192
   passed incorrectly or correctly, respectively. */
193
 
194
#ifdef PROTOTYPES
195
int t_char_values (char char_arg1, char char_arg2)
196
#else
197
int t_char_values (char_arg1, char_arg2)
198
char char_arg1, char_arg2;
199
#endif
200
{
201
  return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
202
}
203
 
204
int
205
#ifdef PROTOTYPES
206
t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
207
                char arg6, short arg7, int arg8, short arg9, short arg10)
208
#else
209
t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
210
     char arg1;
211
     short arg2;
212
     int arg3;
213
     char arg4;
214
     short arg5;
215
     char arg6;
216
     short arg7;
217
     int arg8;
218
     short arg9;
219
     short arg10;
220
#endif
221
{
222
  return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
223
}
224
 
225
#ifdef PROTOTYPES
226
int t_short_values (short short_arg1, short short_arg2)
227
#else
228
int t_short_values (short_arg1, short_arg2)
229
     short short_arg1, short_arg2;
230
#endif
231
{
232
  return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
233
}
234
 
235
#ifdef PROTOTYPES
236
int t_int_values (int int_arg1, int int_arg2)
237
#else
238
int t_int_values (int_arg1, int_arg2)
239
int int_arg1, int_arg2;
240
#endif
241
{
242
  return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
243
}
244
 
245
#ifdef PROTOTYPES
246
int t_long_values (long long_arg1, long long_arg2)
247
#else
248
int t_long_values (long_arg1, long_arg2)
249
long long_arg1, long_arg2;
250
#endif
251
{
252
  return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
253
}
254
 
255
#ifdef PROTOTYPES
256
int t_float_values (float float_arg1, float float_arg2)
257
#else
258
int t_float_values (float_arg1, float_arg2)
259
float float_arg1, float_arg2;
260
#endif
261
{
262
  return ((float_arg1 - float_val1) < DELTA
263
          && (float_arg1 - float_val1) > -DELTA
264
          && (float_arg2 - float_val2) < DELTA
265
          && (float_arg2 - float_val2) > -DELTA);
266
}
267
 
268
int
269
#ifdef PROTOTYPES
270
t_float_values2 (float float_arg1, float float_arg2)
271
#else
272
/* In this case we are just duplicating t_float_values, but that is the
273
   easiest way to deal with either ANSI or non-ANSI.  */
274
t_float_values2 (float_arg1, float_arg2)
275
     float float_arg1, float_arg2;
276
#endif
277
{
278
  return ((float_arg1 - float_val1) < DELTA
279
          && (float_arg1 - float_val1) > -DELTA
280
          && (float_arg2 - float_val2) < DELTA
281
          && (float_arg2 - float_val2) > -DELTA);
282
}
283
 
284
#ifdef PROTOTYPES
285
int t_double_values (double double_arg1, double double_arg2)
286
#else
287
int t_double_values (double_arg1, double_arg2)
288
double double_arg1, double_arg2;
289
#endif
290
{
291
  return ((double_arg1 - double_val1) < DELTA
292
          && (double_arg1 - double_val1) > -DELTA
293
          && (double_arg2 - double_val2) < DELTA
294
          && (double_arg2 - double_val2) > -DELTA);
295
}
296
 
297
#ifdef PROTOTYPES
298
int t_string_values (char *string_arg1, char *string_arg2)
299
#else
300
int t_string_values (string_arg1, string_arg2)
301
char *string_arg1, *string_arg2;
302
#endif
303
{
304
  return (!strcmp (string_arg1, string_val1) &&
305
          !strcmp (string_arg2, string_val2));
306
}
307
 
308
#ifdef PROTOTYPES
309
int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
310
#else
311
int t_char_array_values (char_array_arg1, char_array_arg2)
312
char char_array_arg1[], char_array_arg2[];
313
#endif
314
{
315
  return (!strcmp (char_array_arg1, char_array_val1) &&
316
          !strcmp (char_array_arg2, char_array_val2));
317
}
318
 
319
 
320
/* This used to simply compare the function pointer arguments with
321
   known values for func_val1 and func_val2.  Doing so is valid ANSI
322
   code, but on some machines (RS6000, HPPA, others?) it may fail when
323
   called directly by GDB.
324
 
325
   In a nutshell, it's not possible for GDB to determine when the address
326
   of a function or the address of the function's stub/trampoline should
327
   be passed.
328
 
329
   So, to avoid GDB lossage in the common case, we perform calls through the
330
   various function pointers and compare the return values.  For the HPPA
331
   at least, this allows the common case to work.
332
 
333
   If one wants to try something more complicated, pass the address of
334
   a function accepting a "double" as one of its first 4 arguments.  Call
335
   that function indirectly through the function pointer.  This would fail
336
   on the HPPA.  */
337
 
338
#ifdef PROTOTYPES
339
int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
340
#else
341
int t_func_values (func_arg1, func_arg2)
342
int (*func_arg1) PARAMS ((int, int));
343
int (*func_arg2) PARAMS ((int));
344
#endif
345
{
346
  return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
347
          && (*func_arg2) (6) == (*func_val2) (6));
348
}
349
 
350
#ifdef PROTOTYPES
351
int t_call_add (int (*func_arg1)(int, int), int a, int b)
352
#else
353
int t_call_add (func_arg1, a, b)
354
int (*func_arg1) PARAMS ((int, int));
355
int a, b;
356
#endif
357
{
358
  return ((*func_arg1)(a, b));
359
}

powered by: WebSVN 2.1.0

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