1 | n/a | /* ----------------------------------------------------------------------- |
---|
2 | n/a | ffi.c - Copyright (c) 2011 Timothy Wall |
---|
3 | n/a | Copyright (c) 2011 Plausible Labs Cooperative, Inc. |
---|
4 | n/a | Copyright (c) 2011 Anthony Green |
---|
5 | n/a | Copyright (c) 2011 Free Software Foundation |
---|
6 | n/a | Copyright (c) 1998, 2008, 2011 Red Hat, Inc. |
---|
7 | n/a | |
---|
8 | n/a | ARM Foreign Function Interface |
---|
9 | n/a | |
---|
10 | n/a | Permission is hereby granted, free of charge, to any person obtaining |
---|
11 | n/a | a copy of this software and associated documentation files (the |
---|
12 | n/a | ``Software''), to deal in the Software without restriction, including |
---|
13 | n/a | without limitation the rights to use, copy, modify, merge, publish, |
---|
14 | n/a | distribute, sublicense, and/or sell copies of the Software, and to |
---|
15 | n/a | permit persons to whom the Software is furnished to do so, subject to |
---|
16 | n/a | the following conditions: |
---|
17 | n/a | |
---|
18 | n/a | The above copyright notice and this permission notice shall be included |
---|
19 | n/a | in all copies or substantial portions of the Software. |
---|
20 | n/a | |
---|
21 | n/a | THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, |
---|
22 | n/a | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
---|
23 | n/a | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
---|
24 | n/a | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
---|
25 | n/a | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
---|
26 | n/a | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
---|
27 | n/a | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
---|
28 | n/a | DEALINGS IN THE SOFTWARE. |
---|
29 | n/a | ----------------------------------------------------------------------- */ |
---|
30 | n/a | |
---|
31 | n/a | #include <ffi.h> |
---|
32 | n/a | #include <ffi_common.h> |
---|
33 | n/a | |
---|
34 | n/a | #include <stdlib.h> |
---|
35 | n/a | |
---|
36 | n/a | /* Forward declares. */ |
---|
37 | n/a | static int vfp_type_p (ffi_type *); |
---|
38 | n/a | static void layout_vfp_args (ffi_cif *); |
---|
39 | n/a | |
---|
40 | n/a | int ffi_prep_args_SYSV(char *stack, extended_cif *ecif, float *vfp_space); |
---|
41 | n/a | int ffi_prep_args_VFP(char *stack, extended_cif *ecif, float *vfp_space); |
---|
42 | n/a | |
---|
43 | n/a | static char* ffi_align(ffi_type **p_arg, char *argp) |
---|
44 | n/a | { |
---|
45 | n/a | /* Align if necessary */ |
---|
46 | n/a | register size_t alignment = (*p_arg)->alignment; |
---|
47 | n/a | if (alignment < 4) |
---|
48 | n/a | { |
---|
49 | n/a | alignment = 4; |
---|
50 | n/a | } |
---|
51 | n/a | #ifdef _WIN32_WCE |
---|
52 | n/a | if (alignment > 4) |
---|
53 | n/a | { |
---|
54 | n/a | alignment = 4; |
---|
55 | n/a | } |
---|
56 | n/a | #endif |
---|
57 | n/a | if ((alignment - 1) & (unsigned) argp) |
---|
58 | n/a | { |
---|
59 | n/a | argp = (char *) ALIGN(argp, alignment); |
---|
60 | n/a | } |
---|
61 | n/a | |
---|
62 | n/a | if ((*p_arg)->type == FFI_TYPE_STRUCT) |
---|
63 | n/a | { |
---|
64 | n/a | argp = (char *) ALIGN(argp, 4); |
---|
65 | n/a | } |
---|
66 | n/a | return argp; |
---|
67 | n/a | } |
---|
68 | n/a | |
---|
69 | n/a | static size_t ffi_put_arg(ffi_type **arg_type, void **arg, char *stack) |
---|
70 | n/a | { |
---|
71 | n/a | register char* argp = stack; |
---|
72 | n/a | register ffi_type **p_arg = arg_type; |
---|
73 | n/a | register void **p_argv = arg; |
---|
74 | n/a | register size_t z = (*p_arg)->size; |
---|
75 | n/a | if (z < sizeof(int)) |
---|
76 | n/a | { |
---|
77 | n/a | z = sizeof(int); |
---|
78 | n/a | switch ((*p_arg)->type) |
---|
79 | n/a | { |
---|
80 | n/a | case FFI_TYPE_SINT8: |
---|
81 | n/a | *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv); |
---|
82 | n/a | break; |
---|
83 | n/a | |
---|
84 | n/a | case FFI_TYPE_UINT8: |
---|
85 | n/a | *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv); |
---|
86 | n/a | break; |
---|
87 | n/a | |
---|
88 | n/a | case FFI_TYPE_SINT16: |
---|
89 | n/a | *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv); |
---|
90 | n/a | break; |
---|
91 | n/a | |
---|
92 | n/a | case FFI_TYPE_UINT16: |
---|
93 | n/a | *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv); |
---|
94 | n/a | break; |
---|
95 | n/a | |
---|
96 | n/a | case FFI_TYPE_STRUCT: |
---|
97 | n/a | memcpy(argp, *p_argv, (*p_arg)->size); |
---|
98 | n/a | break; |
---|
99 | n/a | |
---|
100 | n/a | default: |
---|
101 | n/a | FFI_ASSERT(0); |
---|
102 | n/a | } |
---|
103 | n/a | } |
---|
104 | n/a | else if (z == sizeof(int)) |
---|
105 | n/a | { |
---|
106 | n/a | if ((*p_arg)->type == FFI_TYPE_FLOAT) |
---|
107 | n/a | *(float *) argp = *(float *)(* p_argv); |
---|
108 | n/a | else |
---|
109 | n/a | *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv); |
---|
110 | n/a | } |
---|
111 | n/a | else if (z == sizeof(double) && (*p_arg)->type == FFI_TYPE_DOUBLE) |
---|
112 | n/a | { |
---|
113 | n/a | *(double *) argp = *(double *)(* p_argv); |
---|
114 | n/a | } |
---|
115 | n/a | else |
---|
116 | n/a | { |
---|
117 | n/a | memcpy(argp, *p_argv, z); |
---|
118 | n/a | } |
---|
119 | n/a | return z; |
---|
120 | n/a | } |
---|
121 | n/a | /* ffi_prep_args is called by the assembly routine once stack space |
---|
122 | n/a | has been allocated for the function's arguments |
---|
123 | n/a | |
---|
124 | n/a | The vfp_space parameter is the load area for VFP regs, the return |
---|
125 | n/a | value is cif->vfp_used (word bitset of VFP regs used for passing |
---|
126 | n/a | arguments). These are only used for the VFP hard-float ABI. |
---|
127 | n/a | */ |
---|
128 | n/a | int ffi_prep_args_SYSV(char *stack, extended_cif *ecif, float *vfp_space) |
---|
129 | n/a | { |
---|
130 | n/a | register unsigned int i; |
---|
131 | n/a | register void **p_argv; |
---|
132 | n/a | register char *argp; |
---|
133 | n/a | register ffi_type **p_arg; |
---|
134 | n/a | argp = stack; |
---|
135 | n/a | |
---|
136 | n/a | |
---|
137 | n/a | if ( ecif->cif->flags == FFI_TYPE_STRUCT ) { |
---|
138 | n/a | *(void **) argp = ecif->rvalue; |
---|
139 | n/a | argp += 4; |
---|
140 | n/a | } |
---|
141 | n/a | |
---|
142 | n/a | p_argv = ecif->avalue; |
---|
143 | n/a | |
---|
144 | n/a | for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; |
---|
145 | n/a | (i != 0); |
---|
146 | n/a | i--, p_arg++, p_argv++) |
---|
147 | n/a | { |
---|
148 | n/a | argp = ffi_align(p_arg, argp); |
---|
149 | n/a | argp += ffi_put_arg(p_arg, p_argv, argp); |
---|
150 | n/a | } |
---|
151 | n/a | |
---|
152 | n/a | return 0; |
---|
153 | n/a | } |
---|
154 | n/a | |
---|
155 | n/a | int ffi_prep_args_VFP(char *stack, extended_cif *ecif, float *vfp_space) |
---|
156 | n/a | { |
---|
157 | n/a | register unsigned int i, vi = 0; |
---|
158 | n/a | register void **p_argv; |
---|
159 | n/a | register char *argp, *regp, *eo_regp; |
---|
160 | n/a | register ffi_type **p_arg; |
---|
161 | n/a | char stack_used = 0; |
---|
162 | n/a | char done_with_regs = 0; |
---|
163 | n/a | char is_vfp_type; |
---|
164 | n/a | |
---|
165 | n/a | // make sure we are using FFI_VFP |
---|
166 | n/a | FFI_ASSERT(ecif->cif->abi == FFI_VFP); |
---|
167 | n/a | |
---|
168 | n/a | /* the first 4 words on the stack are used for values passed in core |
---|
169 | n/a | * registers. */ |
---|
170 | n/a | regp = stack; |
---|
171 | n/a | eo_regp = argp = regp + 16; |
---|
172 | n/a | |
---|
173 | n/a | |
---|
174 | n/a | /* if the function returns an FFI_TYPE_STRUCT in memory, that address is |
---|
175 | n/a | * passed in r0 to the function */ |
---|
176 | n/a | if ( ecif->cif->flags == FFI_TYPE_STRUCT ) { |
---|
177 | n/a | *(void **) regp = ecif->rvalue; |
---|
178 | n/a | regp += 4; |
---|
179 | n/a | } |
---|
180 | n/a | |
---|
181 | n/a | p_argv = ecif->avalue; |
---|
182 | n/a | |
---|
183 | n/a | for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; |
---|
184 | n/a | (i != 0); |
---|
185 | n/a | i--, p_arg++, p_argv++) |
---|
186 | n/a | { |
---|
187 | n/a | is_vfp_type = vfp_type_p (*p_arg); |
---|
188 | n/a | |
---|
189 | n/a | /* Allocated in VFP registers. */ |
---|
190 | n/a | if(vi < ecif->cif->vfp_nargs && is_vfp_type) |
---|
191 | n/a | { |
---|
192 | n/a | char *vfp_slot = (char *)(vfp_space + ecif->cif->vfp_args[vi++]); |
---|
193 | n/a | ffi_put_arg(p_arg, p_argv, vfp_slot); |
---|
194 | n/a | continue; |
---|
195 | n/a | } |
---|
196 | n/a | /* Try allocating in core registers. */ |
---|
197 | n/a | else if (!done_with_regs && !is_vfp_type) |
---|
198 | n/a | { |
---|
199 | n/a | char *tregp = ffi_align(p_arg, regp); |
---|
200 | n/a | size_t size = (*p_arg)->size; |
---|
201 | n/a | size = (size < 4)? 4 : size; // pad |
---|
202 | n/a | /* Check if there is space left in the aligned register area to place |
---|
203 | n/a | * the argument */ |
---|
204 | n/a | if(tregp + size <= eo_regp) |
---|
205 | n/a | { |
---|
206 | n/a | regp = tregp + ffi_put_arg(p_arg, p_argv, tregp); |
---|
207 | n/a | done_with_regs = (regp == argp); |
---|
208 | n/a | // ensure we did not write into the stack area |
---|
209 | n/a | FFI_ASSERT(regp <= argp); |
---|
210 | n/a | continue; |
---|
211 | n/a | } |
---|
212 | n/a | /* In case there are no arguments in the stack area yet, |
---|
213 | n/a | the argument is passed in the remaining core registers and on the |
---|
214 | n/a | stack. */ |
---|
215 | n/a | else if (!stack_used) |
---|
216 | n/a | { |
---|
217 | n/a | stack_used = 1; |
---|
218 | n/a | done_with_regs = 1; |
---|
219 | n/a | argp = tregp + ffi_put_arg(p_arg, p_argv, tregp); |
---|
220 | n/a | FFI_ASSERT(eo_regp < argp); |
---|
221 | n/a | continue; |
---|
222 | n/a | } |
---|
223 | n/a | } |
---|
224 | n/a | /* Base case, arguments are passed on the stack */ |
---|
225 | n/a | stack_used = 1; |
---|
226 | n/a | argp = ffi_align(p_arg, argp); |
---|
227 | n/a | argp += ffi_put_arg(p_arg, p_argv, argp); |
---|
228 | n/a | } |
---|
229 | n/a | /* Indicate the VFP registers used. */ |
---|
230 | n/a | return ecif->cif->vfp_used; |
---|
231 | n/a | } |
---|
232 | n/a | |
---|
233 | n/a | /* Perform machine dependent cif processing */ |
---|
234 | n/a | ffi_status ffi_prep_cif_machdep(ffi_cif *cif) |
---|
235 | n/a | { |
---|
236 | n/a | int type_code; |
---|
237 | n/a | /* Round the stack up to a multiple of 8 bytes. This isn't needed |
---|
238 | n/a | everywhere, but it is on some platforms, and it doesn't harm anything |
---|
239 | n/a | when it isn't needed. */ |
---|
240 | n/a | cif->bytes = (cif->bytes + 7) & ~7; |
---|
241 | n/a | |
---|
242 | n/a | /* Set the return type flag */ |
---|
243 | n/a | switch (cif->rtype->type) |
---|
244 | n/a | { |
---|
245 | n/a | case FFI_TYPE_VOID: |
---|
246 | n/a | case FFI_TYPE_FLOAT: |
---|
247 | n/a | case FFI_TYPE_DOUBLE: |
---|
248 | n/a | cif->flags = (unsigned) cif->rtype->type; |
---|
249 | n/a | break; |
---|
250 | n/a | |
---|
251 | n/a | case FFI_TYPE_SINT64: |
---|
252 | n/a | case FFI_TYPE_UINT64: |
---|
253 | n/a | cif->flags = (unsigned) FFI_TYPE_SINT64; |
---|
254 | n/a | break; |
---|
255 | n/a | |
---|
256 | n/a | case FFI_TYPE_STRUCT: |
---|
257 | n/a | if (cif->abi == FFI_VFP |
---|
258 | n/a | && (type_code = vfp_type_p (cif->rtype)) != 0) |
---|
259 | n/a | { |
---|
260 | n/a | /* A Composite Type passed in VFP registers, either |
---|
261 | n/a | FFI_TYPE_STRUCT_VFP_FLOAT or FFI_TYPE_STRUCT_VFP_DOUBLE. */ |
---|
262 | n/a | cif->flags = (unsigned) type_code; |
---|
263 | n/a | } |
---|
264 | n/a | else if (cif->rtype->size <= 4) |
---|
265 | n/a | /* A Composite Type not larger than 4 bytes is returned in r0. */ |
---|
266 | n/a | cif->flags = (unsigned)FFI_TYPE_INT; |
---|
267 | n/a | else |
---|
268 | n/a | /* A Composite Type larger than 4 bytes, or whose size cannot |
---|
269 | n/a | be determined statically ... is stored in memory at an |
---|
270 | n/a | address passed [in r0]. */ |
---|
271 | n/a | cif->flags = (unsigned)FFI_TYPE_STRUCT; |
---|
272 | n/a | break; |
---|
273 | n/a | |
---|
274 | n/a | default: |
---|
275 | n/a | cif->flags = FFI_TYPE_INT; |
---|
276 | n/a | break; |
---|
277 | n/a | } |
---|
278 | n/a | |
---|
279 | n/a | /* Map out the register placements of VFP register args. |
---|
280 | n/a | The VFP hard-float calling conventions are slightly more sophisticated than |
---|
281 | n/a | the base calling conventions, so we do it here instead of in ffi_prep_args(). */ |
---|
282 | n/a | if (cif->abi == FFI_VFP) |
---|
283 | n/a | layout_vfp_args (cif); |
---|
284 | n/a | |
---|
285 | n/a | return FFI_OK; |
---|
286 | n/a | } |
---|
287 | n/a | |
---|
288 | n/a | /* Perform machine dependent cif processing for variadic calls */ |
---|
289 | n/a | ffi_status ffi_prep_cif_machdep_var(ffi_cif *cif, |
---|
290 | n/a | unsigned int nfixedargs, |
---|
291 | n/a | unsigned int ntotalargs) |
---|
292 | n/a | { |
---|
293 | n/a | /* VFP variadic calls actually use the SYSV ABI */ |
---|
294 | n/a | if (cif->abi == FFI_VFP) |
---|
295 | n/a | cif->abi = FFI_SYSV; |
---|
296 | n/a | |
---|
297 | n/a | return ffi_prep_cif_machdep(cif); |
---|
298 | n/a | } |
---|
299 | n/a | |
---|
300 | n/a | /* Prototypes for assembly functions, in sysv.S */ |
---|
301 | n/a | extern void ffi_call_SYSV (void (*fn)(void), extended_cif *, unsigned, unsigned, unsigned *); |
---|
302 | n/a | extern void ffi_call_VFP (void (*fn)(void), extended_cif *, unsigned, unsigned, unsigned *); |
---|
303 | n/a | |
---|
304 | n/a | void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) |
---|
305 | n/a | { |
---|
306 | n/a | extended_cif ecif; |
---|
307 | n/a | |
---|
308 | n/a | int small_struct = (cif->flags == FFI_TYPE_INT |
---|
309 | n/a | && cif->rtype->type == FFI_TYPE_STRUCT); |
---|
310 | n/a | int vfp_struct = (cif->flags == FFI_TYPE_STRUCT_VFP_FLOAT |
---|
311 | n/a | || cif->flags == FFI_TYPE_STRUCT_VFP_DOUBLE); |
---|
312 | n/a | |
---|
313 | n/a | unsigned int temp; |
---|
314 | n/a | |
---|
315 | n/a | ecif.cif = cif; |
---|
316 | n/a | ecif.avalue = avalue; |
---|
317 | n/a | |
---|
318 | n/a | /* If the return value is a struct and we don't have a return */ |
---|
319 | n/a | /* value address then we need to make one */ |
---|
320 | n/a | |
---|
321 | n/a | if ((rvalue == NULL) && |
---|
322 | n/a | (cif->flags == FFI_TYPE_STRUCT)) |
---|
323 | n/a | { |
---|
324 | n/a | ecif.rvalue = alloca(cif->rtype->size); |
---|
325 | n/a | } |
---|
326 | n/a | else if (small_struct) |
---|
327 | n/a | ecif.rvalue = &temp; |
---|
328 | n/a | else if (vfp_struct) |
---|
329 | n/a | { |
---|
330 | n/a | /* Largest case is double x 4. */ |
---|
331 | n/a | ecif.rvalue = alloca(32); |
---|
332 | n/a | } |
---|
333 | n/a | else |
---|
334 | n/a | ecif.rvalue = rvalue; |
---|
335 | n/a | |
---|
336 | n/a | switch (cif->abi) |
---|
337 | n/a | { |
---|
338 | n/a | case FFI_SYSV: |
---|
339 | n/a | ffi_call_SYSV (fn, &ecif, cif->bytes, cif->flags, ecif.rvalue); |
---|
340 | n/a | break; |
---|
341 | n/a | |
---|
342 | n/a | case FFI_VFP: |
---|
343 | n/a | #ifdef __ARM_EABI__ |
---|
344 | n/a | ffi_call_VFP (fn, &ecif, cif->bytes, cif->flags, ecif.rvalue); |
---|
345 | n/a | break; |
---|
346 | n/a | #endif |
---|
347 | n/a | |
---|
348 | n/a | default: |
---|
349 | n/a | FFI_ASSERT(0); |
---|
350 | n/a | break; |
---|
351 | n/a | } |
---|
352 | n/a | if (small_struct) |
---|
353 | n/a | { |
---|
354 | n/a | FFI_ASSERT(rvalue != NULL); |
---|
355 | n/a | memcpy (rvalue, &temp, cif->rtype->size); |
---|
356 | n/a | } |
---|
357 | n/a | |
---|
358 | n/a | else if (vfp_struct) |
---|
359 | n/a | { |
---|
360 | n/a | FFI_ASSERT(rvalue != NULL); |
---|
361 | n/a | memcpy (rvalue, ecif.rvalue, cif->rtype->size); |
---|
362 | n/a | } |
---|
363 | n/a | |
---|
364 | n/a | } |
---|
365 | n/a | |
---|
366 | n/a | /** private members **/ |
---|
367 | n/a | |
---|
368 | n/a | static void ffi_prep_incoming_args_SYSV (char *stack, void **ret, |
---|
369 | n/a | void** args, ffi_cif* cif, float *vfp_stack); |
---|
370 | n/a | |
---|
371 | n/a | static void ffi_prep_incoming_args_VFP (char *stack, void **ret, |
---|
372 | n/a | void** args, ffi_cif* cif, float *vfp_stack); |
---|
373 | n/a | |
---|
374 | n/a | void ffi_closure_SYSV (ffi_closure *); |
---|
375 | n/a | |
---|
376 | n/a | void ffi_closure_VFP (ffi_closure *); |
---|
377 | n/a | |
---|
378 | n/a | /* This function is jumped to by the trampoline */ |
---|
379 | n/a | |
---|
380 | n/a | unsigned int FFI_HIDDEN |
---|
381 | n/a | ffi_closure_inner (ffi_closure *closure, |
---|
382 | n/a | void **respp, void *args, void *vfp_args) |
---|
383 | n/a | { |
---|
384 | n/a | // our various things... |
---|
385 | n/a | ffi_cif *cif; |
---|
386 | n/a | void **arg_area; |
---|
387 | n/a | |
---|
388 | n/a | cif = closure->cif; |
---|
389 | n/a | arg_area = (void**) alloca (cif->nargs * sizeof (void*)); |
---|
390 | n/a | |
---|
391 | n/a | /* this call will initialize ARG_AREA, such that each |
---|
392 | n/a | * element in that array points to the corresponding |
---|
393 | n/a | * value on the stack; and if the function returns |
---|
394 | n/a | * a structure, it will re-set RESP to point to the |
---|
395 | n/a | * structure return address. */ |
---|
396 | n/a | if (cif->abi == FFI_VFP) |
---|
397 | n/a | ffi_prep_incoming_args_VFP(args, respp, arg_area, cif, vfp_args); |
---|
398 | n/a | else |
---|
399 | n/a | ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif, vfp_args); |
---|
400 | n/a | |
---|
401 | n/a | (closure->fun) (cif, *respp, arg_area, closure->user_data); |
---|
402 | n/a | |
---|
403 | n/a | return cif->flags; |
---|
404 | n/a | } |
---|
405 | n/a | |
---|
406 | n/a | /*@-exportheader@*/ |
---|
407 | n/a | static void |
---|
408 | n/a | ffi_prep_incoming_args_SYSV(char *stack, void **rvalue, |
---|
409 | n/a | void **avalue, ffi_cif *cif, |
---|
410 | n/a | /* Used only under VFP hard-float ABI. */ |
---|
411 | n/a | float *vfp_stack) |
---|
412 | n/a | /*@=exportheader@*/ |
---|
413 | n/a | { |
---|
414 | n/a | register unsigned int i; |
---|
415 | n/a | register void **p_argv; |
---|
416 | n/a | register char *argp; |
---|
417 | n/a | register ffi_type **p_arg; |
---|
418 | n/a | |
---|
419 | n/a | argp = stack; |
---|
420 | n/a | |
---|
421 | n/a | if ( cif->flags == FFI_TYPE_STRUCT ) { |
---|
422 | n/a | *rvalue = *(void **) argp; |
---|
423 | n/a | argp += 4; |
---|
424 | n/a | } |
---|
425 | n/a | |
---|
426 | n/a | p_argv = avalue; |
---|
427 | n/a | |
---|
428 | n/a | for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++) |
---|
429 | n/a | { |
---|
430 | n/a | size_t z; |
---|
431 | n/a | |
---|
432 | n/a | argp = ffi_align(p_arg, argp); |
---|
433 | n/a | |
---|
434 | n/a | z = (*p_arg)->size; |
---|
435 | n/a | |
---|
436 | n/a | /* because we're little endian, this is what it turns into. */ |
---|
437 | n/a | |
---|
438 | n/a | *p_argv = (void*) argp; |
---|
439 | n/a | |
---|
440 | n/a | p_argv++; |
---|
441 | n/a | argp += z; |
---|
442 | n/a | } |
---|
443 | n/a | |
---|
444 | n/a | return; |
---|
445 | n/a | } |
---|
446 | n/a | |
---|
447 | n/a | /*@-exportheader@*/ |
---|
448 | n/a | static void |
---|
449 | n/a | ffi_prep_incoming_args_VFP(char *stack, void **rvalue, |
---|
450 | n/a | void **avalue, ffi_cif *cif, |
---|
451 | n/a | /* Used only under VFP hard-float ABI. */ |
---|
452 | n/a | float *vfp_stack) |
---|
453 | n/a | /*@=exportheader@*/ |
---|
454 | n/a | { |
---|
455 | n/a | register unsigned int i, vi = 0; |
---|
456 | n/a | register void **p_argv; |
---|
457 | n/a | register char *argp, *regp, *eo_regp; |
---|
458 | n/a | register ffi_type **p_arg; |
---|
459 | n/a | char done_with_regs = 0; |
---|
460 | n/a | char stack_used = 0; |
---|
461 | n/a | char is_vfp_type; |
---|
462 | n/a | |
---|
463 | n/a | FFI_ASSERT(cif->abi == FFI_VFP); |
---|
464 | n/a | regp = stack; |
---|
465 | n/a | eo_regp = argp = regp + 16; |
---|
466 | n/a | |
---|
467 | n/a | if ( cif->flags == FFI_TYPE_STRUCT ) { |
---|
468 | n/a | *rvalue = *(void **) regp; |
---|
469 | n/a | regp += 4; |
---|
470 | n/a | } |
---|
471 | n/a | |
---|
472 | n/a | p_argv = avalue; |
---|
473 | n/a | |
---|
474 | n/a | for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++) |
---|
475 | n/a | { |
---|
476 | n/a | size_t z; |
---|
477 | n/a | is_vfp_type = vfp_type_p (*p_arg); |
---|
478 | n/a | |
---|
479 | n/a | if(vi < cif->vfp_nargs && is_vfp_type) |
---|
480 | n/a | { |
---|
481 | n/a | *p_argv++ = (void*)(vfp_stack + cif->vfp_args[vi++]); |
---|
482 | n/a | continue; |
---|
483 | n/a | } |
---|
484 | n/a | else if (!done_with_regs && !is_vfp_type) |
---|
485 | n/a | { |
---|
486 | n/a | char* tregp = ffi_align(p_arg, regp); |
---|
487 | n/a | |
---|
488 | n/a | z = (*p_arg)->size; |
---|
489 | n/a | z = (z < 4)? 4 : z; // pad |
---|
490 | n/a | |
---|
491 | n/a | /* if the arguments either fits into the registers or uses registers |
---|
492 | n/a | * and stack, while we haven't read other things from the stack */ |
---|
493 | n/a | if(tregp + z <= eo_regp || !stack_used) |
---|
494 | n/a | { |
---|
495 | n/a | /* because we're little endian, this is what it turns into. */ |
---|
496 | n/a | *p_argv = (void*) tregp; |
---|
497 | n/a | |
---|
498 | n/a | p_argv++; |
---|
499 | n/a | regp = tregp + z; |
---|
500 | n/a | // if we read past the last core register, make sure we have not read |
---|
501 | n/a | // from the stack before and continue reading after regp |
---|
502 | n/a | if(regp > eo_regp) |
---|
503 | n/a | { |
---|
504 | n/a | if(stack_used) |
---|
505 | n/a | { |
---|
506 | n/a | abort(); // we should never read past the end of the register |
---|
507 | n/a | // are if the stack is already in use |
---|
508 | n/a | } |
---|
509 | n/a | argp = regp; |
---|
510 | n/a | } |
---|
511 | n/a | if(regp >= eo_regp) |
---|
512 | n/a | { |
---|
513 | n/a | done_with_regs = 1; |
---|
514 | n/a | stack_used = 1; |
---|
515 | n/a | } |
---|
516 | n/a | continue; |
---|
517 | n/a | } |
---|
518 | n/a | } |
---|
519 | n/a | stack_used = 1; |
---|
520 | n/a | |
---|
521 | n/a | argp = ffi_align(p_arg, argp); |
---|
522 | n/a | |
---|
523 | n/a | z = (*p_arg)->size; |
---|
524 | n/a | |
---|
525 | n/a | /* because we're little endian, this is what it turns into. */ |
---|
526 | n/a | |
---|
527 | n/a | *p_argv = (void*) argp; |
---|
528 | n/a | |
---|
529 | n/a | p_argv++; |
---|
530 | n/a | argp += z; |
---|
531 | n/a | } |
---|
532 | n/a | |
---|
533 | n/a | return; |
---|
534 | n/a | } |
---|
535 | n/a | |
---|
536 | n/a | /* How to make a trampoline. */ |
---|
537 | n/a | |
---|
538 | n/a | extern unsigned int ffi_arm_trampoline[3]; |
---|
539 | n/a | |
---|
540 | n/a | #if FFI_EXEC_TRAMPOLINE_TABLE |
---|
541 | n/a | |
---|
542 | n/a | #include <mach/mach.h> |
---|
543 | n/a | #include <pthread.h> |
---|
544 | n/a | #include <stdio.h> |
---|
545 | n/a | #include <stdlib.h> |
---|
546 | n/a | |
---|
547 | n/a | extern void *ffi_closure_trampoline_table_page; |
---|
548 | n/a | |
---|
549 | n/a | typedef struct ffi_trampoline_table ffi_trampoline_table; |
---|
550 | n/a | typedef struct ffi_trampoline_table_entry ffi_trampoline_table_entry; |
---|
551 | n/a | |
---|
552 | n/a | struct ffi_trampoline_table { |
---|
553 | n/a | /* contiguous writable and executable pages */ |
---|
554 | n/a | vm_address_t config_page; |
---|
555 | n/a | vm_address_t trampoline_page; |
---|
556 | n/a | |
---|
557 | n/a | /* free list tracking */ |
---|
558 | n/a | uint16_t free_count; |
---|
559 | n/a | ffi_trampoline_table_entry *free_list; |
---|
560 | n/a | ffi_trampoline_table_entry *free_list_pool; |
---|
561 | n/a | |
---|
562 | n/a | ffi_trampoline_table *prev; |
---|
563 | n/a | ffi_trampoline_table *next; |
---|
564 | n/a | }; |
---|
565 | n/a | |
---|
566 | n/a | struct ffi_trampoline_table_entry { |
---|
567 | n/a | void *(*trampoline)(); |
---|
568 | n/a | ffi_trampoline_table_entry *next; |
---|
569 | n/a | }; |
---|
570 | n/a | |
---|
571 | n/a | /* Override the standard architecture trampoline size */ |
---|
572 | n/a | // XXX TODO - Fix |
---|
573 | n/a | #undef FFI_TRAMPOLINE_SIZE |
---|
574 | n/a | #define FFI_TRAMPOLINE_SIZE 12 |
---|
575 | n/a | |
---|
576 | n/a | /* The trampoline configuration is placed at 4080 bytes prior to the trampoline's entry point */ |
---|
577 | n/a | #define FFI_TRAMPOLINE_CODELOC_CONFIG(codeloc) ((void **) (((uint8_t *) codeloc) - 4080)); |
---|
578 | n/a | |
---|
579 | n/a | /* The first 16 bytes of the config page are unused, as they are unaddressable from the trampoline page. */ |
---|
580 | n/a | #define FFI_TRAMPOLINE_CONFIG_PAGE_OFFSET 16 |
---|
581 | n/a | |
---|
582 | n/a | /* Total number of trampolines that fit in one trampoline table */ |
---|
583 | n/a | #define FFI_TRAMPOLINE_COUNT ((PAGE_SIZE - FFI_TRAMPOLINE_CONFIG_PAGE_OFFSET) / FFI_TRAMPOLINE_SIZE) |
---|
584 | n/a | |
---|
585 | n/a | static pthread_mutex_t ffi_trampoline_lock = PTHREAD_MUTEX_INITIALIZER; |
---|
586 | n/a | static ffi_trampoline_table *ffi_trampoline_tables = NULL; |
---|
587 | n/a | |
---|
588 | n/a | static ffi_trampoline_table * |
---|
589 | n/a | ffi_trampoline_table_alloc () |
---|
590 | n/a | { |
---|
591 | n/a | ffi_trampoline_table *table = NULL; |
---|
592 | n/a | |
---|
593 | n/a | /* Loop until we can allocate two contiguous pages */ |
---|
594 | n/a | while (table == NULL) { |
---|
595 | n/a | vm_address_t config_page = 0x0; |
---|
596 | n/a | kern_return_t kt; |
---|
597 | n/a | |
---|
598 | n/a | /* Try to allocate two pages */ |
---|
599 | n/a | kt = vm_allocate (mach_task_self (), &config_page, PAGE_SIZE*2, VM_FLAGS_ANYWHERE); |
---|
600 | n/a | if (kt != KERN_SUCCESS) { |
---|
601 | n/a | fprintf(stderr, "vm_allocate() failure: %d at %s:%d\n", kt, __FILE__, __LINE__); |
---|
602 | n/a | break; |
---|
603 | n/a | } |
---|
604 | n/a | |
---|
605 | n/a | /* Now drop the second half of the allocation to make room for the trampoline table */ |
---|
606 | n/a | vm_address_t trampoline_page = config_page+PAGE_SIZE; |
---|
607 | n/a | kt = vm_deallocate (mach_task_self (), trampoline_page, PAGE_SIZE); |
---|
608 | n/a | if (kt != KERN_SUCCESS) { |
---|
609 | n/a | fprintf(stderr, "vm_deallocate() failure: %d at %s:%d\n", kt, __FILE__, __LINE__); |
---|
610 | n/a | break; |
---|
611 | n/a | } |
---|
612 | n/a | |
---|
613 | n/a | /* Remap the trampoline table to directly follow the config page */ |
---|
614 | n/a | vm_prot_t cur_prot; |
---|
615 | n/a | vm_prot_t max_prot; |
---|
616 | n/a | |
---|
617 | n/a | kt = vm_remap (mach_task_self (), &trampoline_page, PAGE_SIZE, 0x0, FALSE, mach_task_self (), (vm_address_t) &ffi_closure_trampoline_table_page, FALSE, &cur_prot, &max_prot, VM_INHERIT_SHARE); |
---|
618 | n/a | |
---|
619 | n/a | /* If we lost access to the destination trampoline page, drop our config allocation mapping and retry */ |
---|
620 | n/a | if (kt != KERN_SUCCESS) { |
---|
621 | n/a | /* Log unexpected failures */ |
---|
622 | n/a | if (kt != KERN_NO_SPACE) { |
---|
623 | n/a | fprintf(stderr, "vm_remap() failure: %d at %s:%d\n", kt, __FILE__, __LINE__); |
---|
624 | n/a | } |
---|
625 | n/a | |
---|
626 | n/a | vm_deallocate (mach_task_self (), config_page, PAGE_SIZE); |
---|
627 | n/a | continue; |
---|
628 | n/a | } |
---|
629 | n/a | |
---|
630 | n/a | /* We have valid trampoline and config pages */ |
---|
631 | n/a | table = calloc (1, sizeof(ffi_trampoline_table)); |
---|
632 | n/a | table->free_count = FFI_TRAMPOLINE_COUNT; |
---|
633 | n/a | table->config_page = config_page; |
---|
634 | n/a | table->trampoline_page = trampoline_page; |
---|
635 | n/a | |
---|
636 | n/a | /* Create and initialize the free list */ |
---|
637 | n/a | table->free_list_pool = calloc(FFI_TRAMPOLINE_COUNT, sizeof(ffi_trampoline_table_entry)); |
---|
638 | n/a | |
---|
639 | n/a | uint16_t i; |
---|
640 | n/a | for (i = 0; i < table->free_count; i++) { |
---|
641 | n/a | ffi_trampoline_table_entry *entry = &table->free_list_pool[i]; |
---|
642 | n/a | entry->trampoline = (void *) (table->trampoline_page + (i * FFI_TRAMPOLINE_SIZE)); |
---|
643 | n/a | |
---|
644 | n/a | if (i < table->free_count - 1) |
---|
645 | n/a | entry->next = &table->free_list_pool[i+1]; |
---|
646 | n/a | } |
---|
647 | n/a | |
---|
648 | n/a | table->free_list = table->free_list_pool; |
---|
649 | n/a | } |
---|
650 | n/a | |
---|
651 | n/a | return table; |
---|
652 | n/a | } |
---|
653 | n/a | |
---|
654 | n/a | void * |
---|
655 | n/a | ffi_closure_alloc (size_t size, void **code) |
---|
656 | n/a | { |
---|
657 | n/a | /* Create the closure */ |
---|
658 | n/a | ffi_closure *closure = malloc(size); |
---|
659 | n/a | if (closure == NULL) |
---|
660 | n/a | return NULL; |
---|
661 | n/a | |
---|
662 | n/a | pthread_mutex_lock(&ffi_trampoline_lock); |
---|
663 | n/a | |
---|
664 | n/a | /* Check for an active trampoline table with available entries. */ |
---|
665 | n/a | ffi_trampoline_table *table = ffi_trampoline_tables; |
---|
666 | n/a | if (table == NULL || table->free_list == NULL) { |
---|
667 | n/a | table = ffi_trampoline_table_alloc (); |
---|
668 | n/a | if (table == NULL) { |
---|
669 | n/a | free(closure); |
---|
670 | n/a | return NULL; |
---|
671 | n/a | } |
---|
672 | n/a | |
---|
673 | n/a | /* Insert the new table at the top of the list */ |
---|
674 | n/a | table->next = ffi_trampoline_tables; |
---|
675 | n/a | if (table->next != NULL) |
---|
676 | n/a | table->next->prev = table; |
---|
677 | n/a | |
---|
678 | n/a | ffi_trampoline_tables = table; |
---|
679 | n/a | } |
---|
680 | n/a | |
---|
681 | n/a | /* Claim the free entry */ |
---|
682 | n/a | ffi_trampoline_table_entry *entry = ffi_trampoline_tables->free_list; |
---|
683 | n/a | ffi_trampoline_tables->free_list = entry->next; |
---|
684 | n/a | ffi_trampoline_tables->free_count--; |
---|
685 | n/a | entry->next = NULL; |
---|
686 | n/a | |
---|
687 | n/a | pthread_mutex_unlock(&ffi_trampoline_lock); |
---|
688 | n/a | |
---|
689 | n/a | /* Initialize the return values */ |
---|
690 | n/a | *code = entry->trampoline; |
---|
691 | n/a | closure->trampoline_table = table; |
---|
692 | n/a | closure->trampoline_table_entry = entry; |
---|
693 | n/a | |
---|
694 | n/a | return closure; |
---|
695 | n/a | } |
---|
696 | n/a | |
---|
697 | n/a | void |
---|
698 | n/a | ffi_closure_free (void *ptr) |
---|
699 | n/a | { |
---|
700 | n/a | ffi_closure *closure = ptr; |
---|
701 | n/a | |
---|
702 | n/a | pthread_mutex_lock(&ffi_trampoline_lock); |
---|
703 | n/a | |
---|
704 | n/a | /* Fetch the table and entry references */ |
---|
705 | n/a | ffi_trampoline_table *table = closure->trampoline_table; |
---|
706 | n/a | ffi_trampoline_table_entry *entry = closure->trampoline_table_entry; |
---|
707 | n/a | |
---|
708 | n/a | /* Return the entry to the free list */ |
---|
709 | n/a | entry->next = table->free_list; |
---|
710 | n/a | table->free_list = entry; |
---|
711 | n/a | table->free_count++; |
---|
712 | n/a | |
---|
713 | n/a | /* If all trampolines within this table are free, and at least one other table exists, deallocate |
---|
714 | n/a | * the table */ |
---|
715 | n/a | if (table->free_count == FFI_TRAMPOLINE_COUNT && ffi_trampoline_tables != table) { |
---|
716 | n/a | /* Remove from the list */ |
---|
717 | n/a | if (table->prev != NULL) |
---|
718 | n/a | table->prev->next = table->next; |
---|
719 | n/a | |
---|
720 | n/a | if (table->next != NULL) |
---|
721 | n/a | table->next->prev = table->prev; |
---|
722 | n/a | |
---|
723 | n/a | /* Deallocate pages */ |
---|
724 | n/a | kern_return_t kt; |
---|
725 | n/a | kt = vm_deallocate (mach_task_self (), table->config_page, PAGE_SIZE); |
---|
726 | n/a | if (kt != KERN_SUCCESS) |
---|
727 | n/a | fprintf(stderr, "vm_deallocate() failure: %d at %s:%d\n", kt, __FILE__, __LINE__); |
---|
728 | n/a | |
---|
729 | n/a | kt = vm_deallocate (mach_task_self (), table->trampoline_page, PAGE_SIZE); |
---|
730 | n/a | if (kt != KERN_SUCCESS) |
---|
731 | n/a | fprintf(stderr, "vm_deallocate() failure: %d at %s:%d\n", kt, __FILE__, __LINE__); |
---|
732 | n/a | |
---|
733 | n/a | /* Deallocate free list */ |
---|
734 | n/a | free (table->free_list_pool); |
---|
735 | n/a | free (table); |
---|
736 | n/a | } else if (ffi_trampoline_tables != table) { |
---|
737 | n/a | /* Otherwise, bump this table to the top of the list */ |
---|
738 | n/a | table->prev = NULL; |
---|
739 | n/a | table->next = ffi_trampoline_tables; |
---|
740 | n/a | if (ffi_trampoline_tables != NULL) |
---|
741 | n/a | ffi_trampoline_tables->prev = table; |
---|
742 | n/a | |
---|
743 | n/a | ffi_trampoline_tables = table; |
---|
744 | n/a | } |
---|
745 | n/a | |
---|
746 | n/a | pthread_mutex_unlock (&ffi_trampoline_lock); |
---|
747 | n/a | |
---|
748 | n/a | /* Free the closure */ |
---|
749 | n/a | free (closure); |
---|
750 | n/a | } |
---|
751 | n/a | |
---|
752 | n/a | #else |
---|
753 | n/a | |
---|
754 | n/a | #define FFI_INIT_TRAMPOLINE(TRAMP,FUN,CTX) \ |
---|
755 | n/a | ({ unsigned char *__tramp = (unsigned char*)(TRAMP); \ |
---|
756 | n/a | unsigned int __fun = (unsigned int)(FUN); \ |
---|
757 | n/a | unsigned int __ctx = (unsigned int)(CTX); \ |
---|
758 | n/a | unsigned char *insns = (unsigned char *)(CTX); \ |
---|
759 | n/a | memcpy (__tramp, ffi_arm_trampoline, sizeof ffi_arm_trampoline); \ |
---|
760 | n/a | *(unsigned int*) &__tramp[12] = __ctx; \ |
---|
761 | n/a | *(unsigned int*) &__tramp[16] = __fun; \ |
---|
762 | n/a | __clear_cache((&__tramp[0]), (&__tramp[19])); /* Clear data mapping. */ \ |
---|
763 | n/a | __clear_cache(insns, insns + 3 * sizeof (unsigned int)); \ |
---|
764 | n/a | /* Clear instruction \ |
---|
765 | n/a | mapping. */ \ |
---|
766 | n/a | }) |
---|
767 | n/a | |
---|
768 | n/a | #endif |
---|
769 | n/a | |
---|
770 | n/a | /* the cif must already be prep'ed */ |
---|
771 | n/a | |
---|
772 | n/a | ffi_status |
---|
773 | n/a | ffi_prep_closure_loc (ffi_closure* closure, |
---|
774 | n/a | ffi_cif* cif, |
---|
775 | n/a | void (*fun)(ffi_cif*,void*,void**,void*), |
---|
776 | n/a | void *user_data, |
---|
777 | n/a | void *codeloc) |
---|
778 | n/a | { |
---|
779 | n/a | void (*closure_func)(ffi_closure*) = NULL; |
---|
780 | n/a | |
---|
781 | n/a | if (cif->abi == FFI_SYSV) |
---|
782 | n/a | closure_func = &ffi_closure_SYSV; |
---|
783 | n/a | #ifdef __ARM_EABI__ |
---|
784 | n/a | else if (cif->abi == FFI_VFP) |
---|
785 | n/a | closure_func = &ffi_closure_VFP; |
---|
786 | n/a | #endif |
---|
787 | n/a | else |
---|
788 | n/a | return FFI_BAD_ABI; |
---|
789 | n/a | |
---|
790 | n/a | #if FFI_EXEC_TRAMPOLINE_TABLE |
---|
791 | n/a | void **config = FFI_TRAMPOLINE_CODELOC_CONFIG(codeloc); |
---|
792 | n/a | config[0] = closure; |
---|
793 | n/a | config[1] = closure_func; |
---|
794 | n/a | #else |
---|
795 | n/a | FFI_INIT_TRAMPOLINE (&closure->tramp[0], \ |
---|
796 | n/a | closure_func, \ |
---|
797 | n/a | codeloc); |
---|
798 | n/a | #endif |
---|
799 | n/a | |
---|
800 | n/a | closure->cif = cif; |
---|
801 | n/a | closure->user_data = user_data; |
---|
802 | n/a | closure->fun = fun; |
---|
803 | n/a | |
---|
804 | n/a | return FFI_OK; |
---|
805 | n/a | } |
---|
806 | n/a | |
---|
807 | n/a | /* Below are routines for VFP hard-float support. */ |
---|
808 | n/a | |
---|
809 | n/a | static int rec_vfp_type_p (ffi_type *t, int *elt, int *elnum) |
---|
810 | n/a | { |
---|
811 | n/a | switch (t->type) |
---|
812 | n/a | { |
---|
813 | n/a | case FFI_TYPE_FLOAT: |
---|
814 | n/a | case FFI_TYPE_DOUBLE: |
---|
815 | n/a | *elt = (int) t->type; |
---|
816 | n/a | *elnum = 1; |
---|
817 | n/a | return 1; |
---|
818 | n/a | |
---|
819 | n/a | case FFI_TYPE_STRUCT_VFP_FLOAT: |
---|
820 | n/a | *elt = FFI_TYPE_FLOAT; |
---|
821 | n/a | *elnum = t->size / sizeof (float); |
---|
822 | n/a | return 1; |
---|
823 | n/a | |
---|
824 | n/a | case FFI_TYPE_STRUCT_VFP_DOUBLE: |
---|
825 | n/a | *elt = FFI_TYPE_DOUBLE; |
---|
826 | n/a | *elnum = t->size / sizeof (double); |
---|
827 | n/a | return 1; |
---|
828 | n/a | |
---|
829 | n/a | case FFI_TYPE_STRUCT:; |
---|
830 | n/a | { |
---|
831 | n/a | int base_elt = 0, total_elnum = 0; |
---|
832 | n/a | ffi_type **el = t->elements; |
---|
833 | n/a | while (*el) |
---|
834 | n/a | { |
---|
835 | n/a | int el_elt = 0, el_elnum = 0; |
---|
836 | n/a | if (! rec_vfp_type_p (*el, &el_elt, &el_elnum) |
---|
837 | n/a | || (base_elt && base_elt != el_elt) |
---|
838 | n/a | || total_elnum + el_elnum > 4) |
---|
839 | n/a | return 0; |
---|
840 | n/a | base_elt = el_elt; |
---|
841 | n/a | total_elnum += el_elnum; |
---|
842 | n/a | el++; |
---|
843 | n/a | } |
---|
844 | n/a | *elnum = total_elnum; |
---|
845 | n/a | *elt = base_elt; |
---|
846 | n/a | return 1; |
---|
847 | n/a | } |
---|
848 | n/a | default: ; |
---|
849 | n/a | } |
---|
850 | n/a | return 0; |
---|
851 | n/a | } |
---|
852 | n/a | |
---|
853 | n/a | static int vfp_type_p (ffi_type *t) |
---|
854 | n/a | { |
---|
855 | n/a | int elt, elnum; |
---|
856 | n/a | if (rec_vfp_type_p (t, &elt, &elnum)) |
---|
857 | n/a | { |
---|
858 | n/a | if (t->type == FFI_TYPE_STRUCT) |
---|
859 | n/a | { |
---|
860 | n/a | if (elnum == 1) |
---|
861 | n/a | t->type = elt; |
---|
862 | n/a | else |
---|
863 | n/a | t->type = (elt == FFI_TYPE_FLOAT |
---|
864 | n/a | ? FFI_TYPE_STRUCT_VFP_FLOAT |
---|
865 | n/a | : FFI_TYPE_STRUCT_VFP_DOUBLE); |
---|
866 | n/a | } |
---|
867 | n/a | return (int) t->type; |
---|
868 | n/a | } |
---|
869 | n/a | return 0; |
---|
870 | n/a | } |
---|
871 | n/a | |
---|
872 | n/a | static int place_vfp_arg (ffi_cif *cif, ffi_type *t) |
---|
873 | n/a | { |
---|
874 | n/a | short reg = cif->vfp_reg_free; |
---|
875 | n/a | int nregs = t->size / sizeof (float); |
---|
876 | n/a | int align = ((t->type == FFI_TYPE_STRUCT_VFP_FLOAT |
---|
877 | n/a | || t->type == FFI_TYPE_FLOAT) ? 1 : 2); |
---|
878 | n/a | /* Align register number. */ |
---|
879 | n/a | if ((reg & 1) && align == 2) |
---|
880 | n/a | reg++; |
---|
881 | n/a | while (reg + nregs <= 16) |
---|
882 | n/a | { |
---|
883 | n/a | int s, new_used = 0; |
---|
884 | n/a | for (s = reg; s < reg + nregs; s++) |
---|
885 | n/a | { |
---|
886 | n/a | new_used |= (1 << s); |
---|
887 | n/a | if (cif->vfp_used & (1 << s)) |
---|
888 | n/a | { |
---|
889 | n/a | reg += align; |
---|
890 | n/a | goto next_reg; |
---|
891 | n/a | } |
---|
892 | n/a | } |
---|
893 | n/a | /* Found regs to allocate. */ |
---|
894 | n/a | cif->vfp_used |= new_used; |
---|
895 | n/a | cif->vfp_args[cif->vfp_nargs++] = reg; |
---|
896 | n/a | |
---|
897 | n/a | /* Update vfp_reg_free. */ |
---|
898 | n/a | if (cif->vfp_used & (1 << cif->vfp_reg_free)) |
---|
899 | n/a | { |
---|
900 | n/a | reg += nregs; |
---|
901 | n/a | while (cif->vfp_used & (1 << reg)) |
---|
902 | n/a | reg += 1; |
---|
903 | n/a | cif->vfp_reg_free = reg; |
---|
904 | n/a | } |
---|
905 | n/a | return 0; |
---|
906 | n/a | next_reg: ; |
---|
907 | n/a | } |
---|
908 | n/a | // done, mark all regs as used |
---|
909 | n/a | cif->vfp_reg_free = 16; |
---|
910 | n/a | cif->vfp_used = 0xFFFF; |
---|
911 | n/a | return 1; |
---|
912 | n/a | } |
---|
913 | n/a | |
---|
914 | n/a | static void layout_vfp_args (ffi_cif *cif) |
---|
915 | n/a | { |
---|
916 | n/a | int i; |
---|
917 | n/a | /* Init VFP fields */ |
---|
918 | n/a | cif->vfp_used = 0; |
---|
919 | n/a | cif->vfp_nargs = 0; |
---|
920 | n/a | cif->vfp_reg_free = 0; |
---|
921 | n/a | memset (cif->vfp_args, -1, 16); /* Init to -1. */ |
---|
922 | n/a | |
---|
923 | n/a | for (i = 0; i < cif->nargs; i++) |
---|
924 | n/a | { |
---|
925 | n/a | ffi_type *t = cif->arg_types[i]; |
---|
926 | n/a | if (vfp_type_p (t) && place_vfp_arg (cif, t) == 1) |
---|
927 | n/a | { |
---|
928 | n/a | break; |
---|
929 | n/a | } |
---|
930 | n/a | } |
---|
931 | n/a | } |
---|