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

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