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 }
363