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

#	count	content
1	n/a	/*
2	n/a	* Copyright (c) 2013 Miodrag Vallat. <miod@openbsd.org>
3	n/a	*
4	n/a	* Permission is hereby granted, free of charge, to any person obtaining
5	n/a	* a copy of this software and associated documentation files (the
6	n/a	* ``Software''), to deal in the Software without restriction, including
7	n/a	* without limitation the rights to use, copy, modify, merge, publish,
8	n/a	* distribute, sublicense, and/or sell copies of the Software, and to
9	n/a	* permit persons to whom the Software is furnished to do so, subject to
10	n/a	* the following conditions:
11	n/a	*
12	n/a	* The above copyright notice and this permission notice shall be included
13	n/a	* in all copies or substantial portions of the Software.
14	n/a	*
15	n/a	* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
16	n/a	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17	n/a	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18	n/a	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19	n/a	* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20	n/a	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21	n/a	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22	n/a	*/
23	n/a
24	n/a	/*
25	n/a	* m88k Foreign Function Interface
26	n/a	*
27	n/a	* This file attempts to provide all the FFI entry points which can reliably
28	n/a	* be implemented in C.
29	n/a	*
30	n/a	* Only OpenBSD/m88k is currently supported; other platforms (such as
31	n/a	* Motorola's SysV/m88k) could be supported with the following tweaks:
32	n/a	*
33	n/a	* - non-OpenBSD systems use an `outgoing parameter area' as part of the
34	n/a	* 88BCS calling convention, which is not supported under OpenBSD from
35	n/a	* release 3.6 onwards. Supporting it should be as easy as taking it
36	n/a	* into account when adjusting the stack, in the assembly code.
37	n/a	*
38	n/a	* - the logic deciding whether a function argument gets passed through
39	n/a	* registers, or on the stack, has changed several times in OpenBSD in
40	n/a	* edge cases (especially for structs larger than 32 bytes being passed
41	n/a	* by value). The code below attemps to match the logic used by the
42	n/a	* system compiler of OpenBSD 5.3, i.e. gcc 3.3.6 with many m88k backend
43	n/a	* fixes.
44	n/a	*/
45	n/a
46	n/a	#include <ffi.h>
47	n/a	#include <ffi_common.h>
48	n/a
49	n/a	#include <stdlib.h>
50	n/a	#include <unistd.h>
51	n/a
52	n/a	void ffi_call_OBSD (unsigned int, extended_cif , unsigned int, void ,
53	n/a	void (*fn) ());
54	n/a	void ffi_prep_args (void , extended_cif *);
55	n/a	void ffi_closure_OBSD (ffi_closure *);
56	n/a	void ffi_closure_struct_OBSD (ffi_closure *);
57	n/a	unsigned int ffi_closure_OBSD_inner (ffi_closure , void , unsigned int *,
58	n/a	char *);
59	n/a	void ffi_cacheflush_OBSD (unsigned int, unsigned int);
60	n/a
61	n/a	#define CIF_FLAGS_INT (1 << 0)
62	n/a	#define CIF_FLAGS_DINT (1 << 1)
63	n/a
64	n/a	/*
65	n/a	* Foreign Function Interface API
66	n/a	*/
67	n/a
68	n/a	/* ffi_prep_args is called by the assembly routine once stack space has
69	n/a	been allocated for the function's arguments. */
70	n/a
71	n/a	void *
72	n/a	ffi_prep_args (void stack, extended_cif ecif)
73	n/a	{
74	n/a	unsigned int i;
75	n/a	void **p_argv;
76	n/a	char argp, stackp;
77	n/a	unsigned int *regp;
78	n/a	unsigned int regused;
79	n/a	ffi_type **p_arg;
80	n/a	void *struct_value_ptr;
81	n/a
82	n/a	regp = (unsigned int *)stack;
83	n/a	stackp = (char *)(regp + 8);
84	n/a	regused = 0;
85	n/a
86	n/a	if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
87	n/a	&& !ecif->cif->flags)
88	n/a	struct_value_ptr = ecif->rvalue;
89	n/a	else
90	n/a	struct_value_ptr = NULL;
91	n/a
92	n/a	p_argv = ecif->avalue;
93	n/a
94	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; i != 0; i--, p_arg++)
95	n/a	{
96	n/a	size_t z;
97	n/a	unsigned short t, a;
98	n/a
99	n/a	z = (*p_arg)->size;
100	n/a	t = (*p_arg)->type;
101	n/a	a = (*p_arg)->alignment;
102	n/a
103	n/a	/*
104	n/a	* Figure out whether the argument can be passed through registers
105	n/a	* or on the stack.
106	n/a	* The rule is that registers can only receive simple types not larger
107	n/a	* than 64 bits, or structs the exact size of a register and aligned to
108	n/a	* the size of a register.
109	n/a	*/
110	n/a	if (t == FFI_TYPE_STRUCT)
111	n/a	{
112	n/a	if (z == sizeof (int) && a == sizeof (int) && regused < 8)
113	n/a	argp = (char *)regp;
114	n/a	else
115	n/a	argp = stackp;
116	n/a	}
117	n/a	else
118	n/a	{
119	n/a	if (z > sizeof (int) && regused < 8 - 1)
120	n/a	{
121	n/a	/* align to an even register pair */
122	n/a	if (regused & 1)
123	n/a	{
124	n/a	regp++;
125	n/a	regused++;
126	n/a	}
127	n/a	}
128	n/a	if (regused < 8)
129	n/a	argp = (char *)regp;
130	n/a	else
131	n/a	argp = stackp;
132	n/a	}
133	n/a
134	n/a	/* Enforce proper stack alignment of 64-bit types */
135	n/a	if (argp == stackp && a > sizeof (int))
136	n/a	{
137	n/a	stackp = (char *) ALIGN(stackp, a);
138	n/a	argp = stackp;
139	n/a	}
140	n/a
141	n/a	switch (t)
142	n/a	{
143	n/a	case FFI_TYPE_SINT8:
144	n/a	(signed int ) argp = (signed int) (SINT8 ) *p_argv;
145	n/a	break;
146	n/a
147	n/a	case FFI_TYPE_UINT8:
148	n/a	(unsigned int ) argp = (unsigned int) (UINT8 ) *p_argv;
149	n/a	break;
150	n/a
151	n/a	case FFI_TYPE_SINT16:
152	n/a	(signed int ) argp = (signed int) (SINT16 ) *p_argv;
153	n/a	break;
154	n/a
155	n/a	case FFI_TYPE_UINT16:
156	n/a	(unsigned int ) argp = (unsigned int) (UINT16 ) *p_argv;
157	n/a	break;
158	n/a
159	n/a	case FFI_TYPE_INT:
160	n/a	case FFI_TYPE_FLOAT:
161	n/a	case FFI_TYPE_UINT32:
162	n/a	case FFI_TYPE_SINT32:
163	n/a	case FFI_TYPE_POINTER:
164	n/a	(unsigned int ) argp = (unsigned int ) *p_argv;
165	n/a	break;
166	n/a
167	n/a	case FFI_TYPE_DOUBLE:
168	n/a	case FFI_TYPE_UINT64:
169	n/a	case FFI_TYPE_SINT64:
170	n/a	case FFI_TYPE_STRUCT:
171	n/a	memcpy (argp, *p_argv, z);
172	n/a	break;
173	n/a
174	n/a	default:
175	n/a	FFI_ASSERT (0);
176	n/a	}
177	n/a
178	n/a	/* Align if necessary. */
179	n/a	if ((sizeof (int) - 1) & z)
180	n/a	z = ALIGN(z, sizeof (int));
181	n/a
182	n/a	p_argv++;
183	n/a
184	n/a	/* Be careful, once all registers are filled, and about to continue
185	n/a	on stack, regp == stackp. Therefore the check for regused as well. */
186	n/a	if (argp == (char *)regp && regused < 8)
187	n/a	{
188	n/a	regp += z / sizeof (int);
189	n/a	regused += z / sizeof (int);
190	n/a	}
191	n/a	else
192	n/a	stackp += z;
193	n/a	}
194	n/a
195	n/a	return struct_value_ptr;
196	n/a	}
197	n/a
198	n/a	/* Perform machine dependent cif processing */
199	n/a	ffi_status
200	n/a	ffi_prep_cif_machdep (ffi_cif *cif)
201	n/a	{
202	n/a	/* Set the return type flag */
203	n/a	switch (cif->rtype->type)
204	n/a	{
205	n/a	case FFI_TYPE_VOID:
206	n/a	cif->flags = 0;
207	n/a	break;
208	n/a
209	n/a	case FFI_TYPE_STRUCT:
210	n/a	if (cif->rtype->size == sizeof (int) &&
211	n/a	cif->rtype->alignment == sizeof (int))
212	n/a	cif->flags = CIF_FLAGS_INT;
213	n/a	else
214	n/a	cif->flags = 0;
215	n/a	break;
216	n/a
217	n/a	case FFI_TYPE_DOUBLE:
218	n/a	case FFI_TYPE_SINT64:
219	n/a	case FFI_TYPE_UINT64:
220	n/a	cif->flags = CIF_FLAGS_DINT;
221	n/a	break;
222	n/a
223	n/a	default:
224	n/a	cif->flags = CIF_FLAGS_INT;
225	n/a	break;
226	n/a	}
227	n/a
228	n/a	return FFI_OK;
229	n/a	}
230	n/a
231	n/a	void
232	n/a	ffi_call (ffi_cif cif, void (fn) (), void rvalue, void *avalue)
233	n/a	{
234	n/a	extended_cif ecif;
235	n/a
236	n/a	ecif.cif = cif;
237	n/a	ecif.avalue = avalue;
238	n/a
239	n/a	/* If the return value is a struct and we don't have a return value
240	n/a	address then we need to make one. */
241	n/a
242	n/a	if (rvalue == NULL
243	n/a	&& cif->rtype->type == FFI_TYPE_STRUCT
244	n/a	&& (cif->rtype->size != sizeof (int)
245	n/a	\|\| cif->rtype->alignment != sizeof (int)))
246	n/a	ecif.rvalue = alloca (cif->rtype->size);
247	n/a	else
248	n/a	ecif.rvalue = rvalue;
249	n/a
250	n/a	switch (cif->abi)
251	n/a	{
252	n/a	case FFI_OBSD:
253	n/a	ffi_call_OBSD (cif->bytes, &ecif, cif->flags, ecif.rvalue, fn);
254	n/a	break;
255	n/a
256	n/a	default:
257	n/a	FFI_ASSERT (0);
258	n/a	break;
259	n/a	}
260	n/a	}
261	n/a
262	n/a	/*
263	n/a	* Closure API
264	n/a	*/
265	n/a
266	n/a	static void
267	n/a	ffi_prep_closure_args_OBSD (ffi_cif cif, void avalue, unsigned int regp,
268	n/a	char *stackp)
269	n/a	{
270	n/a	unsigned int i;
271	n/a	void **p_argv;
272	n/a	char *argp;
273	n/a	unsigned int regused;
274	n/a	ffi_type **p_arg;
275	n/a
276	n/a	regused = 0;
277	n/a
278	n/a	p_argv = avalue;
279	n/a
280	n/a	for (i = cif->nargs, p_arg = cif->arg_types; i != 0; i--, p_arg++)
281	n/a	{
282	n/a	size_t z;
283	n/a	unsigned short t, a;
284	n/a
285	n/a	z = (*p_arg)->size;
286	n/a	t = (*p_arg)->type;
287	n/a	a = (*p_arg)->alignment;
288	n/a
289	n/a	/*
290	n/a	* Figure out whether the argument has been passed through registers
291	n/a	* or on the stack.
292	n/a	* The rule is that registers can only receive simple types not larger
293	n/a	* than 64 bits, or structs the exact size of a register and aligned to
294	n/a	* the size of a register.
295	n/a	*/
296	n/a	if (t == FFI_TYPE_STRUCT)
297	n/a	{
298	n/a	if (z == sizeof (int) && a == sizeof (int) && regused < 8)
299	n/a	argp = (char *)regp;
300	n/a	else
301	n/a	argp = stackp;
302	n/a	}
303	n/a	else
304	n/a	{
305	n/a	if (z > sizeof (int) && regused < 8 - 1)
306	n/a	{
307	n/a	/* align to an even register pair */
308	n/a	if (regused & 1)
309	n/a	{
310	n/a	regp++;
311	n/a	regused++;
312	n/a	}
313	n/a	}
314	n/a	if (regused < 8)
315	n/a	argp = (char *)regp;
316	n/a	else
317	n/a	argp = stackp;
318	n/a	}
319	n/a
320	n/a	/* Enforce proper stack alignment of 64-bit types */
321	n/a	if (argp == stackp && a > sizeof (int))
322	n/a	{
323	n/a	stackp = (char *) ALIGN(stackp, a);
324	n/a	argp = stackp;
325	n/a	}
326	n/a
327	n/a	if (z < sizeof (int) && t != FFI_TYPE_STRUCT)
328	n/a	p_argv = (void ) (argp + sizeof (int) - z);
329	n/a	else
330	n/a	p_argv = (void ) argp;
331	n/a
332	n/a	/* Align if necessary */
333	n/a	if ((sizeof (int) - 1) & z)
334	n/a	z = ALIGN(z, sizeof (int));
335	n/a
336	n/a	p_argv++;
337	n/a
338	n/a	/* Be careful, once all registers are exhausted, and about to fetch from
339	n/a	stack, regp == stackp. Therefore the check for regused as well. */
340	n/a	if (argp == (char *)regp && regused < 8)
341	n/a	{
342	n/a	regp += z / sizeof (int);
343	n/a	regused += z / sizeof (int);
344	n/a	}
345	n/a	else
346	n/a	stackp += z;
347	n/a	}
348	n/a	}
349	n/a
350	n/a	unsigned int
351	n/a	ffi_closure_OBSD_inner (ffi_closure closure, void resp, unsigned int *regp,
352	n/a	char *stackp)
353	n/a	{
354	n/a	ffi_cif *cif;
355	n/a	void **arg_area;
356	n/a
357	n/a	cif = closure->cif;
358	n/a	arg_area = (void*) alloca (cif->nargs sizeof (void *));
359	n/a
360	n/a	ffi_prep_closure_args_OBSD(cif, arg_area, regp, stackp);
361	n/a
362	n/a	(closure->fun) (cif, resp, arg_area, closure->user_data);
363	n/a
364	n/a	return cif->flags;
365	n/a	}
366	n/a
367	n/a	ffi_status
368	n/a	ffi_prep_closure_loc (ffi_closure* closure, ffi_cif* cif,
369	n/a	void (fun)(ffi_cif,void,void,void),
370	n/a	void user_data, void codeloc)
371	n/a	{
372	n/a	unsigned int tramp = (unsigned int ) codeloc;
373	n/a	void *fn;
374	n/a
375	n/a	FFI_ASSERT (cif->abi == FFI_OBSD);
376	n/a
377	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT && !cif->flags)
378	n/a	fn = &ffi_closure_struct_OBSD;
379	n/a	else
380	n/a	fn = &ffi_closure_OBSD;
381	n/a
382	n/a	/* or.u %r10, %r0, %hi16(fn) */
383	n/a	tramp[0] = 0x5d400000 \| (((unsigned int)fn) >> 16);
384	n/a	/* or.u %r13, %r0, %hi16(closure) */
385	n/a	tramp[1] = 0x5da00000 \| ((unsigned int)closure >> 16);
386	n/a	/* or %r10, %r10, %lo16(fn) */
387	n/a	tramp[2] = 0x594a0000 \| (((unsigned int)fn) & 0xffff);
388	n/a	/* jmp.n %r10 */
389	n/a	tramp[3] = 0xf400c40a;
390	n/a	/* or %r13, %r13, %lo16(closure) */
391	n/a	tramp[4] = 0x59ad0000 \| ((unsigned int)closure & 0xffff);
392	n/a
393	n/a	ffi_cacheflush_OBSD((unsigned int)codeloc, FFI_TRAMPOLINE_SIZE);
394	n/a
395	n/a	closure->cif = cif;
396	n/a	closure->user_data = user_data;
397	n/a	closure->fun = fun;
398	n/a
399	n/a	return FFI_OK;
400	n/a	}