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

#	count	content
1	n/a	/* ----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2013 Imagination Technologies
3	n/a
4	n/a	Meta Foreign Function Interface
5	n/a	Permission is hereby granted, free of charge, to any person obtaining
6	n/a	a copy of this software and associated documentation files (the
7	n/a	`Software''), to deal in the Software without restriction, including
8	n/a	without limitation the rights to use, copy, modify, merge, publish,
9	n/a	distribute, sublicense, and/or sell copies of the Software, and to
10	n/a	permit persons to whom the Software is furnished to do so, subject to
11	n/a	the following conditions:
12	n/a
13	n/a	The above copyright notice and this permission notice shall be included
14	n/a	in all copies or substantial portions of the Software.
15	n/a
16	n/a	THE SOFTWARE IS PROVIDED `AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
17	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19	n/a	IN NO EVENT SHALL SIMON POSNJAK BE LIABLE FOR ANY CLAIM, DAMAGES OR
20	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22	n/a	OTHER DEALINGS IN THE SOFTWARE.
23	n/a	----------------------------------------------------------------------- */
24	n/a
25	n/a	#include <ffi.h>
26	n/a	#include <ffi_common.h>
27	n/a
28	n/a	#include <stdlib.h>
29	n/a
30	n/a	#define MIN(a,b) (((a) < (b)) ? (a) : (b))
31	n/a
32	n/a	/*
33	n/a	* ffi_prep_args is called by the assembly routine once stack space has been
34	n/a	* allocated for the function's arguments
35	n/a	*/
36	n/a
37	n/a	unsigned int ffi_prep_args(char stack, extended_cif ecif)
38	n/a	{
39	n/a	register unsigned int i;
40	n/a	register void **p_argv;
41	n/a	register char *argp;
42	n/a	register ffi_type **p_arg;
43	n/a
44	n/a	argp = stack;
45	n/a
46	n/a	/* Store return value */
47	n/a	if ( ecif->cif->flags == FFI_TYPE_STRUCT ) {
48	n/a	argp -= 4;
49	n/a	(void *) argp = ecif->rvalue;
50	n/a	}
51	n/a
52	n/a	p_argv = ecif->avalue;
53	n/a
54	n/a	/* point to next location */
55	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; (i != 0); i--, p_arg++, p_argv++)
56	n/a	{
57	n/a	size_t z;
58	n/a
59	n/a	/* Move argp to address of argument */
60	n/a	z = (*p_arg)->size;
61	n/a	argp -= z;
62	n/a
63	n/a	/* Align if necessary */
64	n/a	argp = (char ) ALIGN_DOWN(ALIGN_DOWN(argp, (p_arg)->alignment), 4);
65	n/a
66	n/a	if (z < sizeof(int)) {
67	n/a	z = sizeof(int);
68	n/a	switch ((*p_arg)->type)
69	n/a	{
70	n/a	case FFI_TYPE_SINT8:
71	n/a	(signed int ) argp = (signed int)(SINT8 )(* p_argv);
72	n/a	break;
73	n/a	case FFI_TYPE_UINT8:
74	n/a	(unsigned int ) argp = (unsigned int)(UINT8 )(* p_argv);
75	n/a	break;
76	n/a	case FFI_TYPE_SINT16:
77	n/a	(signed int ) argp = (signed int)(SINT16 )(* p_argv);
78	n/a	break;
79	n/a	case FFI_TYPE_UINT16:
80	n/a	(unsigned int ) argp = (unsigned int)(UINT16 )(* p_argv);
81	n/a	case FFI_TYPE_STRUCT:
82	n/a	memcpy(argp, p_argv, (p_arg)->size);
83	n/a	break;
84	n/a	default:
85	n/a	FFI_ASSERT(0);
86	n/a	}
87	n/a	} else if ( z == sizeof(int)) {
88	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
89	n/a	} else {
90	n/a	memcpy(argp, *p_argv, z);
91	n/a	}
92	n/a	}
93	n/a
94	n/a	/* return the size of the arguments to be passed in registers,
95	n/a	padded to an 8 byte boundary to preserve stack alignment */
96	n/a	return ALIGN(MIN(stack - argp, 6*4), 8);
97	n/a	}
98	n/a
99	n/a	/* Perform machine dependent cif processing */
100	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
101	n/a	{
102	n/a	ffi_type **ptr;
103	n/a	unsigned i, bytes = 0;
104	n/a
105	n/a	for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++) {
106	n/a	if ((*ptr)->size == 0)
107	n/a	return FFI_BAD_TYPEDEF;
108	n/a
109	n/a	/* Perform a sanity check on the argument type, do this
110	n/a	check after the initialization. */
111	n/a	FFI_ASSERT_VALID_TYPE(*ptr);
112	n/a
113	n/a	/* Add any padding if necessary */
114	n/a	if (((*ptr)->alignment - 1) & bytes)
115	n/a	bytes = ALIGN(bytes, (*ptr)->alignment);
116	n/a
117	n/a	bytes += ALIGN((*ptr)->size, 4);
118	n/a	}
119	n/a
120	n/a	/* Ensure arg space is aligned to an 8-byte boundary */
121	n/a	bytes = ALIGN(bytes, 8);
122	n/a
123	n/a	/* Make space for the return structure pointer */
124	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT) {
125	n/a	bytes += sizeof(void*);
126	n/a
127	n/a	/* Ensure stack is aligned to an 8-byte boundary */
128	n/a	bytes = ALIGN(bytes, 8);
129	n/a	}
130	n/a
131	n/a	cif->bytes = bytes;
132	n/a
133	n/a	/* Set the return type flag */
134	n/a	switch (cif->rtype->type) {
135	n/a	case FFI_TYPE_VOID:
136	n/a	case FFI_TYPE_FLOAT:
137	n/a	case FFI_TYPE_DOUBLE:
138	n/a	cif->flags = (unsigned) cif->rtype->type;
139	n/a	break;
140	n/a	case FFI_TYPE_SINT64:
141	n/a	case FFI_TYPE_UINT64:
142	n/a	cif->flags = (unsigned) FFI_TYPE_SINT64;
143	n/a	break;
144	n/a	case FFI_TYPE_STRUCT:
145	n/a	/* Meta can store return values which are <= 64 bits */
146	n/a	if (cif->rtype->size <= 4)
147	n/a	/* Returned to D0Re0 as 32-bit value */
148	n/a	cif->flags = (unsigned)FFI_TYPE_INT;
149	n/a	else if ((cif->rtype->size > 4) && (cif->rtype->size <= 8))
150	n/a	/* Returned valued is stored to D1Re0\|R0Re0 */
151	n/a	cif->flags = (unsigned)FFI_TYPE_DOUBLE;
152	n/a	else
153	n/a	/* value stored in memory */
154	n/a	cif->flags = (unsigned)FFI_TYPE_STRUCT;
155	n/a	break;
156	n/a	default:
157	n/a	cif->flags = (unsigned)FFI_TYPE_INT;
158	n/a	break;
159	n/a	}
160	n/a	return FFI_OK;
161	n/a	}
162	n/a
163	n/a	extern void ffi_call_SYSV(void (fn)(void), extended_cif , unsigned, unsigned, double *);
164	n/a
165	n/a	/*
166	n/a	* Exported in API. Entry point
167	n/a	* cif -> ffi_cif object
168	n/a	* fn -> function pointer
169	n/a	* rvalue -> pointer to return value
170	n/a	* avalue -> vector of void * pointers pointing to memory locations holding the
171	n/a	* arguments
172	n/a	*/
173	n/a	void ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
174	n/a	{
175	n/a	extended_cif ecif;
176	n/a
177	n/a	int small_struct = (((cif->flags == FFI_TYPE_INT) \|\| (cif->flags == FFI_TYPE_DOUBLE)) && (cif->rtype->type == FFI_TYPE_STRUCT));
178	n/a	ecif.cif = cif;
179	n/a	ecif.avalue = avalue;
180	n/a
181	n/a	double temp;
182	n/a
183	n/a	/*
184	n/a	* If the return value is a struct and we don't have a return value address
185	n/a	* then we need to make one
186	n/a	*/
187	n/a
188	n/a	if ((rvalue == NULL ) && (cif->flags == FFI_TYPE_STRUCT))
189	n/a	ecif.rvalue = alloca(cif->rtype->size);
190	n/a	else if (small_struct)
191	n/a	ecif.rvalue = &temp;
192	n/a	else
193	n/a	ecif.rvalue = rvalue;
194	n/a
195	n/a	switch (cif->abi) {
196	n/a	case FFI_SYSV:
197	n/a	ffi_call_SYSV(fn, &ecif, cif->bytes, cif->flags, ecif.rvalue);
198	n/a	break;
199	n/a	default:
200	n/a	FFI_ASSERT(0);
201	n/a	break;
202	n/a	}
203	n/a
204	n/a	if (small_struct)
205	n/a	memcpy (rvalue, &temp, cif->rtype->size);
206	n/a	}
207	n/a
208	n/a	/* private members */
209	n/a
210	n/a	static void ffi_prep_incoming_args_SYSV (char , void , void *,
211	n/a	ffi_cif, float );
212	n/a
213	n/a	void ffi_closure_SYSV (ffi_closure *);
214	n/a
215	n/a	/* Do NOT change that without changing the FFI_TRAMPOLINE_SIZE */
216	n/a	extern unsigned int ffi_metag_trampoline[10]; /* 10 instructions */
217	n/a
218	n/a	/* end of private members */
219	n/a
220	n/a	/*
221	n/a	* __tramp: trampoline memory location
222	n/a	* __fun: assembly routine
223	n/a	* __ctx: memory location for wrapper
224	n/a	*
225	n/a	* At this point, tramp[0] == __ctx !
226	n/a	*/
227	n/a	void ffi_init_trampoline(unsigned char *__tramp, unsigned int __fun, unsigned int __ctx) {
228	n/a	memcpy (__tramp, ffi_metag_trampoline, sizeof(ffi_metag_trampoline));
229	n/a	(unsigned int) &__tramp[40] = __ctx;
230	n/a	(unsigned int) &__tramp[44] = __fun;
231	n/a	/* This will flush the instruction cache */
232	n/a	__builtin_meta2_cachewd(&__tramp[0], 1);
233	n/a	__builtin_meta2_cachewd(&__tramp[47], 1);
234	n/a	}
235	n/a
236	n/a
237	n/a
238	n/a	/* the cif must already be prepared */
239	n/a
240	n/a	ffi_status
241	n/a	ffi_prep_closure_loc (ffi_closure *closure,
242	n/a	ffi_cif* cif,
243	n/a	void (fun)(ffi_cif,void,void,void),
244	n/a	void *user_data,
245	n/a	void *codeloc)
246	n/a	{
247	n/a	void (closure_func)(ffi_closure) = NULL;
248	n/a
249	n/a	if (cif->abi == FFI_SYSV)
250	n/a	closure_func = &ffi_closure_SYSV;
251	n/a	else
252	n/a	return FFI_BAD_ABI;
253	n/a
254	n/a	ffi_init_trampoline(
255	n/a	(unsigned char*)&closure->tramp[0],
256	n/a	(unsigned int)closure_func,
257	n/a	(unsigned int)codeloc);
258	n/a
259	n/a	closure->cif = cif;
260	n/a	closure->user_data = user_data;
261	n/a	closure->fun = fun;
262	n/a
263	n/a	return FFI_OK;
264	n/a	}
265	n/a
266	n/a
267	n/a	/* This function is jumped to by the trampoline */
268	n/a	unsigned int ffi_closure_SYSV_inner (closure, respp, args, vfp_args)
269	n/a	ffi_closure *closure;
270	n/a	void **respp;
271	n/a	void *args;
272	n/a	void *vfp_args;
273	n/a	{
274	n/a	ffi_cif *cif;
275	n/a	void **arg_area;
276	n/a
277	n/a	cif = closure->cif;
278	n/a	arg_area = (void*) alloca (cif->nargs sizeof (void*));
279	n/a
280	n/a	/*
281	n/a	* This call will initialize ARG_AREA, such that each
282	n/a	* element in that array points to the corresponding
283	n/a	* value on the stack; and if the function returns
284	n/a	* a structure, it will re-set RESP to point to the
285	n/a	* structure return address.
286	n/a	*/
287	n/a	ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif, vfp_args);
288	n/a
289	n/a	(closure->fun) ( cif, *respp, arg_area, closure->user_data);
290	n/a
291	n/a	return cif->flags;
292	n/a	}
293	n/a
294	n/a	static void ffi_prep_incoming_args_SYSV(char stack, void *rvalue,
295	n/a	void *avalue, ffi_cif cif,
296	n/a	float *vfp_stack)
297	n/a	{
298	n/a	register unsigned int i;
299	n/a	register void **p_argv;
300	n/a	register char *argp;
301	n/a	register ffi_type **p_arg;
302	n/a
303	n/a	/* stack points to original arguments */
304	n/a	argp = stack;
305	n/a
306	n/a	/* Store return value */
307	n/a	if ( cif->flags == FFI_TYPE_STRUCT ) {
308	n/a	argp -= 4;
309	n/a	rvalue = (void **) argp;
310	n/a	}
311	n/a
312	n/a	p_argv = avalue;
313	n/a
314	n/a	for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++) {
315	n/a	size_t z;
316	n/a	size_t alignment;
317	n/a
318	n/a	alignment = (*p_arg)->alignment;
319	n/a	if (alignment < 4)
320	n/a	alignment = 4;
321	n/a	if ((alignment - 1) & (unsigned)argp)
322	n/a	argp = (char *) ALIGN(argp, alignment);
323	n/a
324	n/a	z = (*p_arg)->size;
325	n/a	p_argv = (void) argp;
326	n/a	p_argv++;
327	n/a	argp -= z;
328	n/a	}
329	n/a	return;
330	n/a	}