OSDN Git Service

2011-02-07 Joel Sherrill <joel.sherrill@oarcorp.com>
[pf3gnuchains/gcc-fork.git] / libffi / src / m68k / ffi.c
1 /* -----------------------------------------------------------------------
2    ffi.c
3    
4    m68k Foreign Function Interface 
5    ----------------------------------------------------------------------- */
6
7 #include <ffi.h>
8 #include <ffi_common.h>
9
10 #include <stdlib.h>
11 #include <unistd.h>
12 #ifdef __rtems__
13 void rtems_cache_flush_multiple_data_lines( const void *, size_t );
14 #else
15 #include <sys/syscall.h>
16 #include <asm/cachectl.h>
17 #endif
18
19 void ffi_call_SYSV (extended_cif *,
20                     unsigned, unsigned,
21                     void *, void (*fn) ());
22 void *ffi_prep_args (void *stack, extended_cif *ecif);
23 void ffi_closure_SYSV (ffi_closure *);
24 void ffi_closure_struct_SYSV (ffi_closure *);
25 unsigned int ffi_closure_SYSV_inner (ffi_closure *closure,
26                                      void *resp, void *args);
27
28 /* ffi_prep_args is called by the assembly routine once stack space has
29    been allocated for the function's arguments.  */
30
31 void *
32 ffi_prep_args (void *stack, extended_cif *ecif)
33 {
34   unsigned int i;
35   void **p_argv;
36   char *argp;
37   ffi_type **p_arg;
38   void *struct_value_ptr;
39
40   argp = stack;
41
42   if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
43       && !ecif->cif->flags)
44     struct_value_ptr = ecif->rvalue;
45   else
46     struct_value_ptr = NULL;
47
48   p_argv = ecif->avalue;
49
50   for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
51        i != 0;
52        i--, p_arg++)
53     {
54       size_t z;
55
56       z = (*p_arg)->size;
57       if (z < sizeof (int))
58         {
59           switch ((*p_arg)->type)
60             {
61             case FFI_TYPE_SINT8:
62               *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
63               break;
64
65             case FFI_TYPE_UINT8:
66               *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
67               break;
68
69             case FFI_TYPE_SINT16:
70               *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
71               break;
72
73             case FFI_TYPE_UINT16:
74               *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
75               break;
76
77             case FFI_TYPE_STRUCT:
78               memcpy (argp + sizeof (int) - z, *p_argv, z);
79               break;
80
81             default:
82               FFI_ASSERT (0);
83             }
84           z = sizeof (int);
85         }
86       else
87         {
88           memcpy (argp, *p_argv, z);
89
90           /* Align if necessary.  */
91           if ((sizeof(int) - 1) & z)
92             z = ALIGN(z, sizeof(int));
93         }
94
95       p_argv++;
96       argp += z;
97     }
98
99   return struct_value_ptr;
100 }
101
102 #define CIF_FLAGS_INT           1
103 #define CIF_FLAGS_DINT          2
104 #define CIF_FLAGS_FLOAT         4
105 #define CIF_FLAGS_DOUBLE        8
106 #define CIF_FLAGS_LDOUBLE       16
107 #define CIF_FLAGS_POINTER       32
108 #define CIF_FLAGS_STRUCT1       64
109 #define CIF_FLAGS_STRUCT2       128
110
111 /* Perform machine dependent cif processing */
112 ffi_status
113 ffi_prep_cif_machdep (ffi_cif *cif)
114 {
115   /* Set the return type flag */
116   switch (cif->rtype->type)
117     {
118     case FFI_TYPE_VOID:
119       cif->flags = 0;
120       break;
121
122     case FFI_TYPE_STRUCT:
123       switch (cif->rtype->size)
124         {
125         case 1:
126           cif->flags = CIF_FLAGS_STRUCT1;
127           break;
128         case 2:
129           cif->flags = CIF_FLAGS_STRUCT2;
130           break;
131         case 4:
132           cif->flags = CIF_FLAGS_INT;
133           break;
134         case 8:
135           cif->flags = CIF_FLAGS_DINT;
136           break;
137         default:
138           cif->flags = 0;
139           break;
140         }
141       break;
142
143     case FFI_TYPE_FLOAT:
144       cif->flags = CIF_FLAGS_FLOAT;
145       break;
146
147     case FFI_TYPE_DOUBLE:
148       cif->flags = CIF_FLAGS_DOUBLE;
149       break;
150
151 #if (FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE)
152     case FFI_TYPE_LONGDOUBLE:
153       cif->flags = CIF_FLAGS_LDOUBLE;
154       break;
155 #endif
156
157     case FFI_TYPE_POINTER:
158       cif->flags = CIF_FLAGS_POINTER;
159       break;
160
161     case FFI_TYPE_SINT64:
162     case FFI_TYPE_UINT64:
163       cif->flags = CIF_FLAGS_DINT;
164       break;
165
166     default:
167       cif->flags = CIF_FLAGS_INT;
168       break;
169     }
170
171   return FFI_OK;
172 }
173
174 void
175 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
176 {
177   extended_cif ecif;
178
179   ecif.cif = cif;
180   ecif.avalue = avalue;
181
182   /* If the return value is a struct and we don't have a return value
183      address then we need to make one.  */
184
185   if (rvalue == NULL
186       && cif->rtype->type == FFI_TYPE_STRUCT
187       && cif->rtype->size > 8)
188     ecif.rvalue = alloca (cif->rtype->size);
189   else
190     ecif.rvalue = rvalue;
191
192   switch (cif->abi)
193     {
194     case FFI_SYSV:
195       ffi_call_SYSV (&ecif, cif->bytes, cif->flags,
196                      ecif.rvalue, fn);
197       break;
198
199     default:
200       FFI_ASSERT (0);
201       break;
202     }
203 }
204
205 static void
206 ffi_prep_incoming_args_SYSV (char *stack, void **avalue, ffi_cif *cif)
207 {
208   unsigned int i;
209   void **p_argv;
210   char *argp;
211   ffi_type **p_arg;
212
213   argp = stack;
214   p_argv = avalue;
215
216   for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
217     {
218       size_t z;
219
220       z = (*p_arg)->size;
221       if (z <= 4)
222         {
223           *p_argv = (void *) (argp + 4 - z);
224
225           z = 4;
226         }
227       else
228         {
229           *p_argv = (void *) argp;
230
231           /* Align if necessary */
232           if ((sizeof(int) - 1) & z)
233             z = ALIGN(z, sizeof(int));
234         }
235
236       p_argv++;
237       argp += z;
238     }
239 }
240
241 unsigned int
242 ffi_closure_SYSV_inner (ffi_closure *closure, void *resp, void *args)
243 {
244   ffi_cif *cif;
245   void **arg_area;
246
247   cif = closure->cif;
248   arg_area = (void**) alloca (cif->nargs * sizeof (void *));
249
250   ffi_prep_incoming_args_SYSV(args, arg_area, cif);
251
252   (closure->fun) (cif, resp, arg_area, closure->user_data);
253
254   return cif->flags;
255 }
256
257 ffi_status
258 ffi_prep_closure_loc (ffi_closure* closure,
259                       ffi_cif* cif,
260                       void (*fun)(ffi_cif*,void*,void**,void*),
261                       void *user_data,
262                       void *codeloc)
263 {
264   FFI_ASSERT (cif->abi == FFI_SYSV);
265
266   *(unsigned short *)closure->tramp = 0x207c;
267   *(void **)(closure->tramp + 2) = codeloc;
268   *(unsigned short *)(closure->tramp + 6) = 0x4ef9;
269   if (cif->rtype->type == FFI_TYPE_STRUCT
270       && !cif->flags)
271     *(void **)(closure->tramp + 8) = ffi_closure_struct_SYSV;
272   else
273     *(void **)(closure->tramp + 8) = ffi_closure_SYSV;
274
275 #ifdef __rtems__
276   rtems_cache_flush_multiple_data_lines( codeloc, FFI_TRAMPOLINE_SIZE );
277 #else
278   syscall(SYS_cacheflush, codeloc, FLUSH_SCOPE_LINE,
279           FLUSH_CACHE_BOTH, FFI_TRAMPOLINE_SIZE);
280 #endif
281
282   closure->cif  = cif;
283   closure->user_data = user_data;
284   closure->fun  = fun;
285
286   return FFI_OK;
287 }
288