Python code coverage for Modules/_ctypes/libffi/src/arm/ffi.c

#	count	content
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	}