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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.hp/] [gdb.base-hp/] [callfwmall.c] - Blame information for rev 258

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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
}

powered by: WebSVN 2.1.0

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