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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2003, 2004, 2006, 2007, 2012 Kaz Kojima
3	n/a	Copyright (c) 2008 Anthony Green
4	n/a
5	n/a	SuperH SHmedia Foreign Function Interface
6	n/a
7	n/a	Permission is hereby granted, free of charge, to any person obtaining
8	n/a	a copy of this software and associated documentation files (the
9	n/a	``Software''), to deal in the Software without restriction, including
10	n/a	without limitation the rights to use, copy, modify, merge, publish,
11	n/a	distribute, sublicense, and/or sell copies of the Software, and to
12	n/a	permit persons to whom the Software is furnished to do so, subject to
13	n/a	the following conditions:
14	n/a
15	n/a	The above copyright notice and this permission notice shall be included
16	n/a	in all copies or substantial portions of the Software.
17	n/a
18	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25	n/a	DEALINGS IN THE SOFTWARE.
26	n/a	----------------------------------------------------------------------- */
27	n/a
28	n/a	#include <ffi.h>
29	n/a	#include <ffi_common.h>
30	n/a
31	n/a	#include <stdlib.h>
32	n/a
33	n/a	#define NGREGARG 8
34	n/a	#define NFREGARG 12
35	n/a
36	n/a	static int
37	n/a	return_type (ffi_type *arg)
38	n/a	{
39	n/a
40	n/a	if (arg->type != FFI_TYPE_STRUCT)
41	n/a	return arg->type;
42	n/a
43	n/a	/* gcc uses r2 if the result can be packed in on register. */
44	n/a	if (arg->size <= sizeof (UINT8))
45	n/a	return FFI_TYPE_UINT8;
46	n/a	else if (arg->size <= sizeof (UINT16))
47	n/a	return FFI_TYPE_UINT16;
48	n/a	else if (arg->size <= sizeof (UINT32))
49	n/a	return FFI_TYPE_UINT32;
50	n/a	else if (arg->size <= sizeof (UINT64))
51	n/a	return FFI_TYPE_UINT64;
52	n/a
53	n/a	return FFI_TYPE_STRUCT;
54	n/a	}
55	n/a
56	n/a	/* ffi_prep_args is called by the assembly routine once stack space
57	n/a	has been allocated for the function's arguments */
58	n/a
59	n/a	void ffi_prep_args(char stack, extended_cif ecif)
60	n/a	{
61	n/a	register unsigned int i;
62	n/a	register unsigned int avn;
63	n/a	register void **p_argv;
64	n/a	register char *argp;
65	n/a	register ffi_type **p_arg;
66	n/a
67	n/a	argp = stack;
68	n/a
69	n/a	if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT)
70	n/a	{
71	n/a	(void *) argp = ecif->rvalue;
72	n/a	argp += sizeof (UINT64);
73	n/a	}
74	n/a
75	n/a	avn = ecif->cif->nargs;
76	n/a	p_argv = ecif->avalue;
77	n/a
78	n/a	for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++)
79	n/a	{
80	n/a	size_t z;
81	n/a	int align;
82	n/a
83	n/a	z = (*p_arg)->size;
84	n/a	align = (*p_arg)->alignment;
85	n/a	if (z < sizeof (UINT32))
86	n/a	{
87	n/a	switch ((*p_arg)->type)
88	n/a	{
89	n/a	case FFI_TYPE_SINT8:
90	n/a	(SINT64 ) argp = (SINT64) (SINT8 )(*p_argv);
91	n/a	break;
92	n/a
93	n/a	case FFI_TYPE_UINT8:
94	n/a	(UINT64 ) argp = (UINT64) (UINT8 )(*p_argv);
95	n/a	break;
96	n/a
97	n/a	case FFI_TYPE_SINT16:
98	n/a	(SINT64 ) argp = (SINT64) (SINT16 )(*p_argv);
99	n/a	break;
100	n/a
101	n/a	case FFI_TYPE_UINT16:
102	n/a	(UINT64 ) argp = (UINT64) (UINT16 )(*p_argv);
103	n/a	break;
104	n/a
105	n/a	case FFI_TYPE_STRUCT:
106	n/a	memcpy (argp, *p_argv, z);
107	n/a	break;
108	n/a
109	n/a	default:
110	n/a	FFI_ASSERT(0);
111	n/a	}
112	n/a	argp += sizeof (UINT64);
113	n/a	}
114	n/a	else if (z == sizeof (UINT32) && align == sizeof (UINT32))
115	n/a	{
116	n/a	switch ((*p_arg)->type)
117	n/a	{
118	n/a	case FFI_TYPE_INT:
119	n/a	case FFI_TYPE_SINT32:
120	n/a	(SINT64 ) argp = (SINT64) (SINT32 ) (*p_argv);
121	n/a	break;
122	n/a
123	n/a	case FFI_TYPE_FLOAT:
124	n/a	case FFI_TYPE_POINTER:
125	n/a	case FFI_TYPE_UINT32:
126	n/a	case FFI_TYPE_STRUCT:
127	n/a	(UINT64 ) argp = (UINT64) (UINT32 ) (*p_argv);
128	n/a	break;
129	n/a
130	n/a	default:
131	n/a	FFI_ASSERT(0);
132	n/a	break;
133	n/a	}
134	n/a	argp += sizeof (UINT64);
135	n/a	}
136	n/a	else if (z == sizeof (UINT64)
137	n/a	&& align == sizeof (UINT64)
138	n/a	&& ((int) *p_argv & (sizeof (UINT64) - 1)) == 0)
139	n/a	{
140	n/a	(UINT64 ) argp = (UINT64 ) (*p_argv);
141	n/a	argp += sizeof (UINT64);
142	n/a	}
143	n/a	else
144	n/a	{
145	n/a	int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64);
146	n/a
147	n/a	memcpy (argp, *p_argv, z);
148	n/a	argp += n * sizeof (UINT64);
149	n/a	}
150	n/a	}
151	n/a
152	n/a	return;
153	n/a	}
154	n/a
155	n/a	/* Perform machine dependent cif processing */
156	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
157	n/a	{
158	n/a	int i, j;
159	n/a	int size, type;
160	n/a	int n, m;
161	n/a	int greg;
162	n/a	int freg;
163	n/a	int fpair = -1;
164	n/a
165	n/a	greg = (return_type (cif->rtype) == FFI_TYPE_STRUCT ? 1 : 0);
166	n/a	freg = 0;
167	n/a	cif->flags2 = 0;
168	n/a
169	n/a	for (i = j = 0; i < cif->nargs; i++)
170	n/a	{
171	n/a	type = (cif->arg_types)[i]->type;
172	n/a	switch (type)
173	n/a	{
174	n/a	case FFI_TYPE_FLOAT:
175	n/a	greg++;
176	n/a	cif->bytes += sizeof (UINT64) - sizeof (float);
177	n/a	if (freg >= NFREGARG - 1)
178	n/a	continue;
179	n/a	if (fpair < 0)
180	n/a	{
181	n/a	fpair = freg;
182	n/a	freg += 2;
183	n/a	}
184	n/a	else
185	n/a	fpair = -1;
186	n/a	cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++);
187	n/a	break;
188	n/a
189	n/a	case FFI_TYPE_DOUBLE:
190	n/a	if (greg++ >= NGREGARG && (freg + 1) >= NFREGARG)
191	n/a	continue;
192	n/a	if ((freg + 1) < NFREGARG)
193	n/a	{
194	n/a	freg += 2;
195	n/a	cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++);
196	n/a	}
197	n/a	else
198	n/a	cif->flags2 += FFI_TYPE_INT << (2 * j++);
199	n/a	break;
200	n/a
201	n/a	default:
202	n/a	size = (cif->arg_types)[i]->size;
203	n/a	if (size < sizeof (UINT64))
204	n/a	cif->bytes += sizeof (UINT64) - size;
205	n/a	n = (size + sizeof (UINT64) - 1) / sizeof (UINT64);
206	n/a	if (greg >= NGREGARG)
207	n/a	continue;
208	n/a	else if (greg + n - 1 >= NGREGARG)
209	n/a	greg = NGREGARG;
210	n/a	else
211	n/a	greg += n;
212	n/a	for (m = 0; m < n; m++)
213	n/a	cif->flags2 += FFI_TYPE_INT << (2 * j++);
214	n/a	break;
215	n/a	}
216	n/a	}
217	n/a
218	n/a	/* Set the return type flag */
219	n/a	switch (cif->rtype->type)
220	n/a	{
221	n/a	case FFI_TYPE_STRUCT:
222	n/a	cif->flags = return_type (cif->rtype);
223	n/a	break;
224	n/a
225	n/a	case FFI_TYPE_VOID:
226	n/a	case FFI_TYPE_FLOAT:
227	n/a	case FFI_TYPE_DOUBLE:
228	n/a	case FFI_TYPE_SINT64:
229	n/a	case FFI_TYPE_UINT64:
230	n/a	cif->flags = cif->rtype->type;
231	n/a	break;
232	n/a
233	n/a	default:
234	n/a	cif->flags = FFI_TYPE_INT;
235	n/a	break;
236	n/a	}
237	n/a
238	n/a	return FFI_OK;
239	n/a	}
240	n/a
241	n/a	/@-declundef@/
242	n/a	/@-exportheader@/
243	n/a	extern void ffi_call_SYSV(void ()(char , extended_cif *),
244	n/a	/@out@/ extended_cif *,
245	n/a	unsigned, unsigned, long long,
246	n/a	/@out@/ unsigned *,
247	n/a	void (*fn)(void));
248	n/a	/@=declundef@/
249	n/a	/@=exportheader@/
250	n/a
251	n/a	void ffi_call(/@dependent@/ ffi_cif *cif,
252	n/a	void (*fn)(void),
253	n/a	/@out@/ void *rvalue,
254	n/a	/@dependent@/ void **avalue)
255	n/a	{
256	n/a	extended_cif ecif;
257	n/a	UINT64 trvalue;
258	n/a
259	n/a	ecif.cif = cif;
260	n/a	ecif.avalue = avalue;
261	n/a
262	n/a	/* If the return value is a struct and we don't have a return */
263	n/a	/* value address then we need to make one */
264	n/a
265	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT
266	n/a	&& return_type (cif->rtype) != FFI_TYPE_STRUCT)
267	n/a	ecif.rvalue = &trvalue;
268	n/a	else if ((rvalue == NULL) &&
269	n/a	(cif->rtype->type == FFI_TYPE_STRUCT))
270	n/a	{
271	n/a	ecif.rvalue = alloca(cif->rtype->size);
272	n/a	}
273	n/a	else
274	n/a	ecif.rvalue = rvalue;
275	n/a
276	n/a	switch (cif->abi)
277	n/a	{
278	n/a	case FFI_SYSV:
279	n/a	ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, cif->flags2,
280	n/a	ecif.rvalue, fn);
281	n/a	break;
282	n/a	default:
283	n/a	FFI_ASSERT(0);
284	n/a	break;
285	n/a	}
286	n/a
287	n/a	if (rvalue
288	n/a	&& cif->rtype->type == FFI_TYPE_STRUCT
289	n/a	&& return_type (cif->rtype) != FFI_TYPE_STRUCT)
290	n/a	memcpy (rvalue, &trvalue, cif->rtype->size);
291	n/a	}
292	n/a
293	n/a	extern void ffi_closure_SYSV (void);
294	n/a	extern void __ic_invalidate (void *line);
295	n/a
296	n/a	ffi_status
297	n/a	ffi_prep_closure_loc (ffi_closure *closure,
298	n/a	ffi_cif *cif,
299	n/a	void (fun)(ffi_cif, void, void, void),
300	n/a	void *user_data,
301	n/a	void *codeloc)
302	n/a	{
303	n/a	unsigned int *tramp;
304	n/a
305	n/a	if (cif->abi != FFI_SYSV)
306	n/a	return FFI_BAD_ABI;
307	n/a
308	n/a	tramp = (unsigned int *) &closure->tramp[0];
309	n/a	/* Since ffi_closure is an aligned object, the ffi trampoline is
310	n/a	called as an SHcompact code. Sigh.
311	n/a	SHcompact part:
312	n/a	mova @(1,pc),r0; add #1,r0; jmp @r0; nop;
313	n/a	SHmedia part:
314	n/a	movi fnaddr >> 16,r1; shori fnaddr,r1; ptabs/l r1,tr0
315	n/a	movi cxt >> 16,r1; shori cxt,r1; blink tr0,r63 */
316	n/a	#ifdef __LITTLE_ENDIAN__
317	n/a	tramp[0] = 0x7001c701;
318	n/a	tramp[1] = 0x0009402b;
319	n/a	#else
320	n/a	tramp[0] = 0xc7017001;
321	n/a	tramp[1] = 0x402b0009;
322	n/a	#endif
323	n/a	tramp[2] = 0xcc000010 \| (((UINT32) ffi_closure_SYSV) >> 16) << 10;
324	n/a	tramp[3] = 0xc8000010 \| (((UINT32) ffi_closure_SYSV) & 0xffff) << 10;
325	n/a	tramp[4] = 0x6bf10600;
326	n/a	tramp[5] = 0xcc000010 \| (((UINT32) codeloc) >> 16) << 10;
327	n/a	tramp[6] = 0xc8000010 \| (((UINT32) codeloc) & 0xffff) << 10;
328	n/a	tramp[7] = 0x4401fff0;
329	n/a
330	n/a	closure->cif = cif;
331	n/a	closure->fun = fun;
332	n/a	closure->user_data = user_data;
333	n/a
334	n/a	/* Flush the icache. */
335	n/a	asm volatile ("ocbwb %0,0; synco; icbi %1,0; synci" : : "r" (tramp),
336	n/a	"r"(codeloc));
337	n/a
338	n/a	return FFI_OK;
339	n/a	}
340	n/a
341	n/a	/* Basically the trampoline invokes ffi_closure_SYSV, and on
342	n/a	* entry, r3 holds the address of the closure.
343	n/a	* After storing the registers that could possibly contain
344	n/a	* parameters to be passed into the stack frame and setting
345	n/a	* up space for a return value, ffi_closure_SYSV invokes the
346	n/a	* following helper function to do most of the work.
347	n/a	*/
348	n/a
349	n/a	int
350	n/a	ffi_closure_helper_SYSV (ffi_closure closure, UINT64 rvalue,
351	n/a	UINT64 pgr, UINT64 pfr, UINT64 *pst)
352	n/a	{
353	n/a	void **avalue;
354	n/a	ffi_type **p_arg;
355	n/a	int i, avn;
356	n/a	int greg, freg;
357	n/a	ffi_cif *cif;
358	n/a	int fpair = -1;
359	n/a
360	n/a	cif = closure->cif;
361	n/a	avalue = alloca (cif->nargs * sizeof (void *));
362	n/a
363	n/a	/* Copy the caller's structure return value address so that the closure
364	n/a	returns the data directly to the caller. */
365	n/a	if (return_type (cif->rtype) == FFI_TYPE_STRUCT)
366	n/a	{
367	n/a	rvalue = (UINT64 ) pgr;
368	n/a	greg = 1;
369	n/a	}
370	n/a	else
371	n/a	greg = 0;
372	n/a
373	n/a	freg = 0;
374	n/a	cif = closure->cif;
375	n/a	avn = cif->nargs;
376	n/a
377	n/a	/* Grab the addresses of the arguments from the stack frame. */
378	n/a	for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)
379	n/a	{
380	n/a	size_t z;
381	n/a	void *p;
382	n/a
383	n/a	z = (*p_arg)->size;
384	n/a	if (z < sizeof (UINT32))
385	n/a	{
386	n/a	p = pgr + greg++;
387	n/a
388	n/a	switch ((*p_arg)->type)
389	n/a	{
390	n/a	case FFI_TYPE_SINT8:
391	n/a	case FFI_TYPE_UINT8:
392	n/a	case FFI_TYPE_SINT16:
393	n/a	case FFI_TYPE_UINT16:
394	n/a	case FFI_TYPE_STRUCT:
395	n/a	#ifdef __LITTLE_ENDIAN__
396	n/a	avalue[i] = p;
397	n/a	#else
398	n/a	avalue[i] = ((char *) p) + sizeof (UINT32) - z;
399	n/a	#endif
400	n/a	break;
401	n/a
402	n/a	default:
403	n/a	FFI_ASSERT(0);
404	n/a	}
405	n/a	}
406	n/a	else if (z == sizeof (UINT32))
407	n/a	{
408	n/a	if ((*p_arg)->type == FFI_TYPE_FLOAT)
409	n/a	{
410	n/a	if (freg < NFREGARG - 1)
411	n/a	{
412	n/a	if (fpair >= 0)
413	n/a	{
414	n/a	avalue[i] = (UINT32 *) pfr + fpair;
415	n/a	fpair = -1;
416	n/a	}
417	n/a	else
418	n/a	{
419	n/a	#ifdef __LITTLE_ENDIAN__
420	n/a	fpair = freg;
421	n/a	avalue[i] = (UINT32 *) pfr + (1 ^ freg);
422	n/a	#else
423	n/a	fpair = 1 ^ freg;
424	n/a	avalue[i] = (UINT32 *) pfr + freg;
425	n/a	#endif
426	n/a	freg += 2;
427	n/a	}
428	n/a	}
429	n/a	else
430	n/a	#ifdef __LITTLE_ENDIAN__
431	n/a	avalue[i] = pgr + greg;
432	n/a	#else
433	n/a	avalue[i] = (UINT32 *) (pgr + greg) + 1;
434	n/a	#endif
435	n/a	}
436	n/a	else
437	n/a	#ifdef __LITTLE_ENDIAN__
438	n/a	avalue[i] = pgr + greg;
439	n/a	#else
440	n/a	avalue[i] = (UINT32 *) (pgr + greg) + 1;
441	n/a	#endif
442	n/a	greg++;
443	n/a	}
444	n/a	else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
445	n/a	{
446	n/a	if (freg + 1 >= NFREGARG)
447	n/a	avalue[i] = pgr + greg;
448	n/a	else
449	n/a	{
450	n/a	avalue[i] = pfr + (freg >> 1);
451	n/a	freg += 2;
452	n/a	}
453	n/a	greg++;
454	n/a	}
455	n/a	else
456	n/a	{
457	n/a	int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64);
458	n/a
459	n/a	avalue[i] = pgr + greg;
460	n/a	greg += n;
461	n/a	}
462	n/a	}
463	n/a
464	n/a	(closure->fun) (cif, rvalue, avalue, closure->user_data);
465	n/a
466	n/a	/* Tell ffi_closure_SYSV how to perform return type promotions. */
467	n/a	return return_type (cif->rtype);
468	n/a	}
469	n/a