|
111
|
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 #ifdef __MINT__
|
|
|
17 #include <mint/mintbind.h>
|
|
|
18 #include <mint/ssystem.h>
|
|
|
19 #else
|
|
|
20 #include <asm/cachectl.h>
|
|
|
21 #endif
|
|
|
22 #endif
|
|
|
23
|
|
|
24 void ffi_call_SYSV (extended_cif *,
|
|
|
25 unsigned, unsigned,
|
|
|
26 void *, void (*fn) ());
|
|
|
27 void *ffi_prep_args (void *stack, extended_cif *ecif);
|
|
|
28 void ffi_closure_SYSV (ffi_closure *);
|
|
|
29 void ffi_closure_struct_SYSV (ffi_closure *);
|
|
|
30 unsigned int ffi_closure_SYSV_inner (ffi_closure *closure,
|
|
|
31 void *resp, void *args);
|
|
|
32
|
|
|
33 /* ffi_prep_args is called by the assembly routine once stack space has
|
|
|
34 been allocated for the function's arguments. */
|
|
|
35
|
|
|
36 void *
|
|
|
37 ffi_prep_args (void *stack, extended_cif *ecif)
|
|
|
38 {
|
|
|
39 unsigned int i;
|
|
|
40 void **p_argv;
|
|
|
41 char *argp;
|
|
|
42 ffi_type **p_arg;
|
|
|
43 void *struct_value_ptr;
|
|
|
44
|
|
|
45 argp = stack;
|
|
|
46
|
|
|
47 if (
|
|
|
48 #ifdef __MINT__
|
|
|
49 (ecif->cif->rtype->type == FFI_TYPE_LONGDOUBLE) ||
|
|
|
50 #endif
|
|
|
51 (((ecif->cif->rtype->type == FFI_TYPE_STRUCT)
|
|
|
52 && !ecif->cif->flags)))
|
|
|
53 struct_value_ptr = ecif->rvalue;
|
|
|
54 else
|
|
|
55 struct_value_ptr = NULL;
|
|
|
56
|
|
|
57 p_argv = ecif->avalue;
|
|
|
58
|
|
|
59 for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
|
|
|
60 i != 0;
|
|
|
61 i--, p_arg++)
|
|
|
62 {
|
|
|
63 size_t z = (*p_arg)->size;
|
|
|
64 int type = (*p_arg)->type;
|
|
|
65
|
|
|
66 if (z < sizeof (int))
|
|
|
67 {
|
|
|
68 switch (type)
|
|
|
69 {
|
|
|
70 case FFI_TYPE_SINT8:
|
|
|
71 *(signed int *) argp = (signed int) *(SINT8 *) *p_argv;
|
|
|
72 break;
|
|
|
73
|
|
|
74 case FFI_TYPE_UINT8:
|
|
|
75 *(unsigned int *) argp = (unsigned int) *(UINT8 *) *p_argv;
|
|
|
76 break;
|
|
|
77
|
|
|
78 case FFI_TYPE_SINT16:
|
|
|
79 *(signed int *) argp = (signed int) *(SINT16 *) *p_argv;
|
|
|
80 break;
|
|
|
81
|
|
|
82 case FFI_TYPE_UINT16:
|
|
|
83 *(unsigned int *) argp = (unsigned int) *(UINT16 *) *p_argv;
|
|
|
84 break;
|
|
|
85
|
|
|
86 case FFI_TYPE_STRUCT:
|
|
|
87 #ifdef __MINT__
|
|
|
88 if (z == 1 || z == 2)
|
|
|
89 memcpy (argp + 2, *p_argv, z);
|
|
|
90 else
|
|
|
91 memcpy (argp, *p_argv, z);
|
|
|
92 #else
|
|
|
93 memcpy (argp + sizeof (int) - z, *p_argv, z);
|
|
|
94 #endif
|
|
|
95 break;
|
|
|
96
|
|
|
97 default:
|
|
|
98 FFI_ASSERT (0);
|
|
|
99 }
|
|
|
100 z = sizeof (int);
|
|
|
101 }
|
|
|
102 else
|
|
|
103 {
|
|
|
104 memcpy (argp, *p_argv, z);
|
|
|
105
|
|
|
106 /* Align if necessary. */
|
|
|
107 if ((sizeof(int) - 1) & z)
|
|
|
108 z = ALIGN(z, sizeof(int));
|
|
|
109 }
|
|
|
110
|
|
|
111 p_argv++;
|
|
|
112 argp += z;
|
|
|
113 }
|
|
|
114
|
|
|
115 return struct_value_ptr;
|
|
|
116 }
|
|
|
117
|
|
|
118 #define CIF_FLAGS_INT 1
|
|
|
119 #define CIF_FLAGS_DINT 2
|
|
|
120 #define CIF_FLAGS_FLOAT 4
|
|
|
121 #define CIF_FLAGS_DOUBLE 8
|
|
|
122 #define CIF_FLAGS_LDOUBLE 16
|
|
|
123 #define CIF_FLAGS_POINTER 32
|
|
|
124 #define CIF_FLAGS_STRUCT1 64
|
|
|
125 #define CIF_FLAGS_STRUCT2 128
|
|
|
126 #define CIF_FLAGS_SINT8 256
|
|
|
127 #define CIF_FLAGS_SINT16 512
|
|
|
128
|
|
|
129 /* Perform machine dependent cif processing */
|
|
|
130 ffi_status
|
|
|
131 ffi_prep_cif_machdep (ffi_cif *cif)
|
|
|
132 {
|
|
|
133 /* Set the return type flag */
|
|
|
134 switch (cif->rtype->type)
|
|
|
135 {
|
|
|
136 case FFI_TYPE_VOID:
|
|
|
137 cif->flags = 0;
|
|
|
138 break;
|
|
|
139
|
|
|
140 case FFI_TYPE_STRUCT:
|
|
|
141 if (cif->rtype->elements[0]->type == FFI_TYPE_STRUCT &&
|
|
|
142 cif->rtype->elements[1])
|
|
|
143 {
|
|
|
144 cif->flags = 0;
|
|
|
145 break;
|
|
|
146 }
|
|
|
147
|
|
|
148 switch (cif->rtype->size)
|
|
|
149 {
|
|
|
150 case 1:
|
|
|
151 #ifdef __MINT__
|
|
|
152 cif->flags = CIF_FLAGS_STRUCT2;
|
|
|
153 #else
|
|
|
154 cif->flags = CIF_FLAGS_STRUCT1;
|
|
|
155 #endif
|
|
|
156 break;
|
|
|
157 case 2:
|
|
|
158 cif->flags = CIF_FLAGS_STRUCT2;
|
|
|
159 break;
|
|
|
160 #ifdef __MINT__
|
|
|
161 case 3:
|
|
|
162 #endif
|
|
|
163 case 4:
|
|
|
164 cif->flags = CIF_FLAGS_INT;
|
|
|
165 break;
|
|
|
166 #ifdef __MINT__
|
|
|
167 case 7:
|
|
|
168 #endif
|
|
|
169 case 8:
|
|
|
170 cif->flags = CIF_FLAGS_DINT;
|
|
|
171 break;
|
|
|
172 default:
|
|
|
173 cif->flags = 0;
|
|
|
174 break;
|
|
|
175 }
|
|
|
176 break;
|
|
|
177
|
|
|
178 case FFI_TYPE_FLOAT:
|
|
|
179 cif->flags = CIF_FLAGS_FLOAT;
|
|
|
180 break;
|
|
|
181
|
|
|
182 case FFI_TYPE_DOUBLE:
|
|
|
183 cif->flags = CIF_FLAGS_DOUBLE;
|
|
|
184 break;
|
|
|
185
|
|
|
186 #if (FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE)
|
|
|
187 case FFI_TYPE_LONGDOUBLE:
|
|
|
188 #ifdef __MINT__
|
|
|
189 cif->flags = 0;
|
|
|
190 #else
|
|
|
191 cif->flags = CIF_FLAGS_LDOUBLE;
|
|
|
192 #endif
|
|
|
193 break;
|
|
|
194 #endif
|
|
|
195
|
|
|
196 case FFI_TYPE_POINTER:
|
|
|
197 cif->flags = CIF_FLAGS_POINTER;
|
|
|
198 break;
|
|
|
199
|
|
|
200 case FFI_TYPE_SINT64:
|
|
|
201 case FFI_TYPE_UINT64:
|
|
|
202 cif->flags = CIF_FLAGS_DINT;
|
|
|
203 break;
|
|
|
204
|
|
|
205 case FFI_TYPE_SINT16:
|
|
|
206 cif->flags = CIF_FLAGS_SINT16;
|
|
|
207 break;
|
|
|
208
|
|
|
209 case FFI_TYPE_SINT8:
|
|
|
210 cif->flags = CIF_FLAGS_SINT8;
|
|
|
211 break;
|
|
|
212
|
|
|
213 default:
|
|
|
214 cif->flags = CIF_FLAGS_INT;
|
|
|
215 break;
|
|
|
216 }
|
|
|
217
|
|
|
218 return FFI_OK;
|
|
|
219 }
|
|
|
220
|
|
|
221 void
|
|
|
222 ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
|
|
|
223 {
|
|
|
224 extended_cif ecif;
|
|
|
225
|
|
|
226 ecif.cif = cif;
|
|
|
227 ecif.avalue = avalue;
|
|
|
228
|
|
|
229 /* If the return value is a struct and we don't have a return value
|
|
|
230 address then we need to make one. */
|
|
|
231
|
|
|
232 if (rvalue == NULL
|
|
|
233 && cif->rtype->type == FFI_TYPE_STRUCT
|
|
|
234 && cif->rtype->size > 8)
|
|
|
235 ecif.rvalue = alloca (cif->rtype->size);
|
|
|
236 else
|
|
|
237 ecif.rvalue = rvalue;
|
|
|
238
|
|
|
239 switch (cif->abi)
|
|
|
240 {
|
|
|
241 case FFI_SYSV:
|
|
|
242 ffi_call_SYSV (&ecif, cif->bytes, cif->flags,
|
|
|
243 ecif.rvalue, fn);
|
|
|
244 break;
|
|
|
245
|
|
|
246 default:
|
|
|
247 FFI_ASSERT (0);
|
|
|
248 break;
|
|
|
249 }
|
|
|
250 }
|
|
|
251
|
|
|
252 static void
|
|
|
253 ffi_prep_incoming_args_SYSV (char *stack, void **avalue, ffi_cif *cif)
|
|
|
254 {
|
|
|
255 unsigned int i;
|
|
|
256 void **p_argv;
|
|
|
257 char *argp;
|
|
|
258 ffi_type **p_arg;
|
|
|
259
|
|
|
260 argp = stack;
|
|
|
261 p_argv = avalue;
|
|
|
262
|
|
|
263 for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
|
|
|
264 {
|
|
|
265 size_t z;
|
|
|
266
|
|
|
267 z = (*p_arg)->size;
|
|
|
268 #ifdef __MINT__
|
|
|
269 if (cif->flags &&
|
|
|
270 cif->rtype->type == FFI_TYPE_STRUCT &&
|
|
|
271 (z == 1 || z == 2))
|
|
|
272 {
|
|
|
273 *p_argv = (void *) (argp + 2);
|
|
|
274
|
|
|
275 z = 4;
|
|
|
276 }
|
|
|
277 else
|
|
|
278 if (cif->flags &&
|
|
|
279 cif->rtype->type == FFI_TYPE_STRUCT &&
|
|
|
280 (z == 3 || z == 4))
|
|
|
281 {
|
|
|
282 *p_argv = (void *) (argp);
|
|
|
283
|
|
|
284 z = 4;
|
|
|
285 }
|
|
|
286 else
|
|
|
287 #endif
|
|
|
288 if (z <= 4)
|
|
|
289 {
|
|
|
290 *p_argv = (void *) (argp + 4 - z);
|
|
|
291
|
|
|
292 z = 4;
|
|
|
293 }
|
|
|
294 else
|
|
|
295 {
|
|
|
296 *p_argv = (void *) argp;
|
|
|
297
|
|
|
298 /* Align if necessary */
|
|
|
299 if ((sizeof(int) - 1) & z)
|
|
|
300 z = ALIGN(z, sizeof(int));
|
|
|
301 }
|
|
|
302
|
|
|
303 p_argv++;
|
|
|
304 argp += z;
|
|
|
305 }
|
|
|
306 }
|
|
|
307
|
|
|
308 unsigned int
|
|
|
309 ffi_closure_SYSV_inner (ffi_closure *closure, void *resp, void *args)
|
|
|
310 {
|
|
|
311 ffi_cif *cif;
|
|
|
312 void **arg_area;
|
|
|
313
|
|
|
314 cif = closure->cif;
|
|
|
315 arg_area = (void**) alloca (cif->nargs * sizeof (void *));
|
|
|
316
|
|
|
317 ffi_prep_incoming_args_SYSV(args, arg_area, cif);
|
|
|
318
|
|
|
319 (closure->fun) (cif, resp, arg_area, closure->user_data);
|
|
|
320
|
|
|
321 return cif->flags;
|
|
|
322 }
|
|
|
323
|
|
|
324 ffi_status
|
|
|
325 ffi_prep_closure_loc (ffi_closure* closure,
|
|
|
326 ffi_cif* cif,
|
|
|
327 void (*fun)(ffi_cif*,void*,void**,void*),
|
|
|
328 void *user_data,
|
|
|
329 void *codeloc)
|
|
|
330 {
|
|
|
331 if (cif->abi != FFI_SYSV)
|
|
|
332 return FFI_BAD_ABI;
|
|
|
333
|
|
|
334 *(unsigned short *)closure->tramp = 0x207c;
|
|
|
335 *(void **)(closure->tramp + 2) = codeloc;
|
|
|
336 *(unsigned short *)(closure->tramp + 6) = 0x4ef9;
|
|
|
337
|
|
|
338 if (
|
|
|
339 #ifdef __MINT__
|
|
|
340 (cif->rtype->type == FFI_TYPE_LONGDOUBLE) ||
|
|
|
341 #endif
|
|
|
342 (((cif->rtype->type == FFI_TYPE_STRUCT)
|
|
|
343 && !cif->flags)))
|
|
|
344 *(void **)(closure->tramp + 8) = ffi_closure_struct_SYSV;
|
|
|
345 else
|
|
|
346 *(void **)(closure->tramp + 8) = ffi_closure_SYSV;
|
|
|
347
|
|
|
348 #ifdef __rtems__
|
|
|
349 rtems_cache_flush_multiple_data_lines( codeloc, FFI_TRAMPOLINE_SIZE );
|
|
|
350 #elif defined(__MINT__)
|
|
|
351 Ssystem(S_FLUSHCACHE, codeloc, FFI_TRAMPOLINE_SIZE);
|
|
|
352 #else
|
|
|
353 syscall(SYS_cacheflush, codeloc, FLUSH_SCOPE_LINE,
|
|
|
354 FLUSH_CACHE_BOTH, FFI_TRAMPOLINE_SIZE);
|
|
|
355 #endif
|
|
|
356
|
|
|
357 closure->cif = cif;
|
|
|
358 closure->user_data = user_data;
|
|
|
359 closure->fun = fun;
|
|
|
360
|
|
|
361 return FFI_OK;
|
|
|
362 }
|
