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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (C) 2004 Anthony Green
3	n/a	Copyright (C) 2007 Free Software Foundation, Inc.
4	n/a	Copyright (C) 2008 Red Hat, Inc.
5	n/a
6	n/a	FR-V Foreign Function Interface
7	n/a
8	n/a	Permission is hereby granted, free of charge, to any person obtaining
9	n/a	a copy of this software and associated documentation files (the
10	n/a	``Software''), to deal in the Software without restriction, including
11	n/a	without limitation the rights to use, copy, modify, merge, publish,
12	n/a	distribute, sublicense, and/or sell copies of the Software, and to
13	n/a	permit persons to whom the Software is furnished to do so, subject to
14	n/a	the following conditions:
15	n/a
16	n/a	The above copyright notice and this permission notice shall be included
17	n/a	in all copies or substantial portions of the Software.
18	n/a
19	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
20	n/a	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22	n/a	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
23	n/a	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
24	n/a	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25	n/a	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26	n/a	DEALINGS IN THE SOFTWARE.
27	n/a	----------------------------------------------------------------------- */
28	n/a
29	n/a	#include <ffi.h>
30	n/a	#include <ffi_common.h>
31	n/a
32	n/a	#include <stdlib.h>
33	n/a
34	n/a	/* ffi_prep_args is called by the assembly routine once stack space
35	n/a	has been allocated for the function's arguments */
36	n/a
37	n/a	void 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	register int count = 0;
44	n/a
45	n/a	p_argv = ecif->avalue;
46	n/a	argp = stack;
47	n/a
48	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
49	n/a	(i != 0);
50	n/a	i--, p_arg++)
51	n/a	{
52	n/a	size_t z;
53	n/a
54	n/a	z = (*p_arg)->size;
55	n/a
56	n/a	if ((*p_arg)->type == FFI_TYPE_STRUCT)
57	n/a	{
58	n/a	z = sizeof(void*);
59	n/a	(void ) argp = p_argv;
60	n/a	}
61	n/a	/* if ((*p_arg)->type == FFI_TYPE_FLOAT)
62	n/a	{
63	n/a	if (count > 24)
64	n/a	{
65	n/a	// This is going on the stack. Turn it into a double.
66	n/a	(double ) argp = (double) (float)(* p_argv);
67	n/a	z = sizeof(double);
68	n/a	}
69	n/a	else
70	n/a	(void ) argp = (void *)( p_argv);
71	n/a	} */
72	n/a	else if (z < sizeof(int))
73	n/a	{
74	n/a	z = sizeof(int);
75	n/a	switch ((*p_arg)->type)
76	n/a	{
77	n/a	case FFI_TYPE_SINT8:
78	n/a	(signed int ) argp = (signed int)(SINT8 )(* p_argv);
79	n/a	break;
80	n/a
81	n/a	case FFI_TYPE_UINT8:
82	n/a	(unsigned int ) argp = (unsigned int)(UINT8 )(* p_argv);
83	n/a	break;
84	n/a
85	n/a	case FFI_TYPE_SINT16:
86	n/a	(signed int ) argp = (signed int)(SINT16 )(* p_argv);
87	n/a	break;
88	n/a
89	n/a	case FFI_TYPE_UINT16:
90	n/a	(unsigned int ) argp = (unsigned int)(UINT16 )(* p_argv);
91	n/a	break;
92	n/a
93	n/a	default:
94	n/a	FFI_ASSERT(0);
95	n/a	}
96	n/a	}
97	n/a	else if (z == sizeof(int))
98	n/a	{
99	n/a	(unsigned int ) argp = (unsigned int)(UINT32 )(* p_argv);
100	n/a	}
101	n/a	else
102	n/a	{
103	n/a	memcpy(argp, *p_argv, z);
104	n/a	}
105	n/a	p_argv++;
106	n/a	argp += z;
107	n/a	count += z;
108	n/a	}
109	n/a
110	n/a	return (stack + ((count > 24) ? 24 : ALIGN_DOWN(count, 8)));
111	n/a	}
112	n/a
113	n/a	/* Perform machine dependent cif processing */
114	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
115	n/a	{
116	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT)
117	n/a	cif->flags = -1;
118	n/a	else
119	n/a	cif->flags = cif->rtype->size;
120	n/a
121	n/a	cif->bytes = ALIGN (cif->bytes, 8);
122	n/a
123	n/a	return FFI_OK;
124	n/a	}
125	n/a
126	n/a	extern void ffi_call_EABI(void ()(char , extended_cif ),
127	n/a	extended_cif *,
128	n/a	unsigned, unsigned,
129	n/a	unsigned *,
130	n/a	void (*fn)(void));
131	n/a
132	n/a	void ffi_call(ffi_cif *cif,
133	n/a	void (*fn)(void),
134	n/a	void *rvalue,
135	n/a	void **avalue)
136	n/a	{
137	n/a	extended_cif ecif;
138	n/a
139	n/a	ecif.cif = cif;
140	n/a	ecif.avalue = avalue;
141	n/a
142	n/a	/* If the return value is a struct and we don't have a return */
143	n/a	/* value address then we need to make one */
144	n/a
145	n/a	if ((rvalue == NULL) &&
146	n/a	(cif->rtype->type == FFI_TYPE_STRUCT))
147	n/a	{
148	n/a	ecif.rvalue = alloca(cif->rtype->size);
149	n/a	}
150	n/a	else
151	n/a	ecif.rvalue = rvalue;
152	n/a
153	n/a
154	n/a	switch (cif->abi)
155	n/a	{
156	n/a	case FFI_EABI:
157	n/a	ffi_call_EABI(ffi_prep_args, &ecif, cif->bytes,
158	n/a	cif->flags, ecif.rvalue, fn);
159	n/a	break;
160	n/a	default:
161	n/a	FFI_ASSERT(0);
162	n/a	break;
163	n/a	}
164	n/a	}
165	n/a
166	n/a	void ffi_closure_eabi (unsigned arg1, unsigned arg2, unsigned arg3,
167	n/a	unsigned arg4, unsigned arg5, unsigned arg6)
168	n/a	{
169	n/a	/* This function is called by a trampoline. The trampoline stows a
170	n/a	pointer to the ffi_closure object in gr7. We must save this
171	n/a	pointer in a place that will persist while we do our work. */
172	n/a	register ffi_closure *creg __asm__ ("gr7");
173	n/a	ffi_closure *closure = creg;
174	n/a
175	n/a	/* Arguments that don't fit in registers are found on the stack
176	n/a	at a fixed offset above the current frame pointer. */
177	n/a	register char *frame_pointer __asm__ ("fp");
178	n/a	char *stack_args = frame_pointer + 16;
179	n/a
180	n/a	/* Lay the register arguments down in a continuous chunk of memory. */
181	n/a	unsigned register_args[6] =
182	n/a	{ arg1, arg2, arg3, arg4, arg5, arg6 };
183	n/a
184	n/a	ffi_cif *cif = closure->cif;
185	n/a	ffi_type **arg_types = cif->arg_types;
186	n/a	void *avalue = alloca (cif->nargs sizeof(void *));
187	n/a	char ptr = (char ) register_args;
188	n/a	int i;
189	n/a
190	n/a	/* Find the address of each argument. */
191	n/a	for (i = 0; i < cif->nargs; i++)
192	n/a	{
193	n/a	switch (arg_types[i]->type)
194	n/a	{
195	n/a	case FFI_TYPE_SINT8:
196	n/a	case FFI_TYPE_UINT8:
197	n/a	avalue[i] = ptr + 3;
198	n/a	break;
199	n/a	case FFI_TYPE_SINT16:
200	n/a	case FFI_TYPE_UINT16:
201	n/a	avalue[i] = ptr + 2;
202	n/a	break;
203	n/a	case FFI_TYPE_SINT32:
204	n/a	case FFI_TYPE_UINT32:
205	n/a	case FFI_TYPE_FLOAT:
206	n/a	avalue[i] = ptr;
207	n/a	break;
208	n/a	case FFI_TYPE_STRUCT:
209	n/a	avalue[i] = (void*)ptr;
210	n/a	break;
211	n/a	default:
212	n/a	/* This is an 8-byte value. */
213	n/a	avalue[i] = ptr;
214	n/a	ptr += 4;
215	n/a	break;
216	n/a	}
217	n/a	ptr += 4;
218	n/a
219	n/a	/* If we've handled more arguments than fit in registers,
220	n/a	start looking at the those passed on the stack. */
221	n/a	if (ptr == ((char )register_args + (64)))
222	n/a	ptr = stack_args;
223	n/a	}
224	n/a
225	n/a	/* Invoke the closure. */
226	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT)
227	n/a	{
228	n/a	/* The caller allocates space for the return structure, and
229	n/a	passes a pointer to this space in gr3. Use this value directly
230	n/a	as the return value. */
231	n/a	register void *return_struct_ptr __asm__("gr3");
232	n/a	(closure->fun) (cif, return_struct_ptr, avalue, closure->user_data);
233	n/a	}
234	n/a	else
235	n/a	{
236	n/a	/* Allocate space for the return value and call the function. */
237	n/a	long long rvalue;
238	n/a	(closure->fun) (cif, &rvalue, avalue, closure->user_data);
239	n/a
240	n/a	/* Functions return 4-byte or smaller results in gr8. 8-byte
241	n/a	values also use gr9. We fill the both, even for small return
242	n/a	values, just to avoid a branch. */
243	n/a	asm ("ldi @(%0, #0), gr8" : : "r" (&rvalue));
244	n/a	asm ("ldi @(%0, #0), gr9" : : "r" (&((int *) &rvalue)[1]));
245	n/a	}
246	n/a	}
247	n/a
248	n/a	ffi_status
249	n/a	ffi_prep_closure_loc (ffi_closure* closure,
250	n/a	ffi_cif* cif,
251	n/a	void (fun)(ffi_cif, void, void, void),
252	n/a	void *user_data,
253	n/a	void *codeloc)
254	n/a	{
255	n/a	unsigned int tramp = (unsigned int ) &closure->tramp[0];
256	n/a	unsigned long fn = (long) ffi_closure_eabi;
257	n/a	unsigned long cls = (long) codeloc;
258	n/a	#ifdef __FRV_FDPIC__
259	n/a	register void *got __asm__("gr15");
260	n/a	#endif
261	n/a	int i;
262	n/a
263	n/a	fn = (unsigned long) ffi_closure_eabi;
264	n/a
265	n/a	#ifdef __FRV_FDPIC__
266	n/a	tramp[0] = &((unsigned int *)codeloc)[2];
267	n/a	tramp[1] = got;
268	n/a	tramp[2] = 0x8cfc0000 + (fn & 0xffff); /* setlos lo(fn), gr6 */
269	n/a	tramp[3] = 0x8efc0000 + (cls & 0xffff); /* setlos lo(cls), gr7 */
270	n/a	tramp[4] = 0x8cf80000 + (fn >> 16); /* sethi hi(fn), gr6 */
271	n/a	tramp[5] = 0x8ef80000 + (cls >> 16); /* sethi hi(cls), gr7 */
272	n/a	tramp[6] = 0x9cc86000; /* ldi @(gr6, #0), gr14 */
273	n/a	tramp[7] = 0x8030e000; /* jmpl @(gr14, gr0) */
274	n/a	#else
275	n/a	tramp[0] = 0x8cfc0000 + (fn & 0xffff); /* setlos lo(fn), gr6 */
276	n/a	tramp[1] = 0x8efc0000 + (cls & 0xffff); /* setlos lo(cls), gr7 */
277	n/a	tramp[2] = 0x8cf80000 + (fn >> 16); /* sethi hi(fn), gr6 */
278	n/a	tramp[3] = 0x8ef80000 + (cls >> 16); /* sethi hi(cls), gr7 */
279	n/a	tramp[4] = 0x80300006; /* jmpl @(gr0, gr6) */
280	n/a	#endif
281	n/a
282	n/a	closure->cif = cif;
283	n/a	closure->fun = fun;
284	n/a	closure->user_data = user_data;
285	n/a
286	n/a	/* Cache flushing. */
287	n/a	for (i = 0; i < FFI_TRAMPOLINE_SIZE; i++)
288	n/a	__asm__ volatile ("dcf @(%0,%1)\n\tici @(%2,%1)" :: "r" (tramp), "r" (i),
289	n/a	"r" (codeloc));
290	n/a
291	n/a	return FFI_OK;
292	n/a	}