Python code coverage for Modules/_ctypes/libffi/src/vax/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	* vax 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
31	n/a	#include <ffi.h>
32	n/a	#include <ffi_common.h>
33	n/a
34	n/a	#include <stdlib.h>
35	n/a	#include <unistd.h>
36	n/a
37	n/a	#define CIF_FLAGS_CHAR 1 /* for struct only */
38	n/a	#define CIF_FLAGS_SHORT 2 /* for struct only */
39	n/a	#define CIF_FLAGS_INT 4
40	n/a	#define CIF_FLAGS_DINT 8
41	n/a
42	n/a	/*
43	n/a	* Foreign Function Interface API
44	n/a	*/
45	n/a
46	n/a	void ffi_call_elfbsd (extended_cif , unsigned, unsigned, void ,
47	n/a	void (*) ());
48	n/a	void ffi_prep_args (extended_cif ecif, void *stack);
49	n/a
50	n/a	void *
51	n/a	ffi_prep_args (extended_cif ecif, void stack)
52	n/a	{
53	n/a	unsigned int i;
54	n/a	void **p_argv;
55	n/a	char *argp;
56	n/a	ffi_type **p_arg;
57	n/a	void *struct_value_ptr;
58	n/a
59	n/a	argp = stack;
60	n/a
61	n/a	if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
62	n/a	&& !ecif->cif->flags)
63	n/a	struct_value_ptr = ecif->rvalue;
64	n/a	else
65	n/a	struct_value_ptr = NULL;
66	n/a
67	n/a	p_argv = ecif->avalue;
68	n/a
69	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
70	n/a	i != 0;
71	n/a	i--, p_arg++)
72	n/a	{
73	n/a	size_t z;
74	n/a
75	n/a	z = (*p_arg)->size;
76	n/a	if (z < sizeof (int))
77	n/a	{
78	n/a	switch ((*p_arg)->type)
79	n/a	{
80	n/a	case FFI_TYPE_SINT8:
81	n/a	(signed int ) argp = (signed int) (SINT8 ) *p_argv;
82	n/a	break;
83	n/a
84	n/a	case FFI_TYPE_UINT8:
85	n/a	(unsigned int ) argp = (unsigned int) (UINT8 ) *p_argv;
86	n/a	break;
87	n/a
88	n/a	case FFI_TYPE_SINT16:
89	n/a	(signed int ) argp = (signed int) (SINT16 ) *p_argv;
90	n/a	break;
91	n/a
92	n/a	case FFI_TYPE_UINT16:
93	n/a	(unsigned int ) argp = (unsigned int) (UINT16 ) *p_argv;
94	n/a	break;
95	n/a
96	n/a	case FFI_TYPE_STRUCT:
97	n/a	memcpy (argp, *p_argv, z);
98	n/a	break;
99	n/a
100	n/a	default:
101	n/a	FFI_ASSERT (0);
102	n/a	}
103	n/a	z = sizeof (int);
104	n/a	}
105	n/a	else
106	n/a	{
107	n/a	memcpy (argp, *p_argv, z);
108	n/a
109	n/a	/* Align if necessary. */
110	n/a	if ((sizeof(int) - 1) & z)
111	n/a	z = ALIGN(z, sizeof(int));
112	n/a	}
113	n/a
114	n/a	p_argv++;
115	n/a	argp += z;
116	n/a	}
117	n/a
118	n/a	return struct_value_ptr;
119	n/a	}
120	n/a
121	n/a	ffi_status
122	n/a	ffi_prep_cif_machdep (ffi_cif *cif)
123	n/a	{
124	n/a	/* Set the return type flag */
125	n/a	switch (cif->rtype->type)
126	n/a	{
127	n/a	case FFI_TYPE_VOID:
128	n/a	cif->flags = 0;
129	n/a	break;
130	n/a
131	n/a	case FFI_TYPE_STRUCT:
132	n/a	if (cif->rtype->elements[0]->type == FFI_TYPE_STRUCT &&
133	n/a	cif->rtype->elements[1])
134	n/a	{
135	n/a	cif->flags = 0;
136	n/a	break;
137	n/a	}
138	n/a
139	n/a	if (cif->rtype->size == sizeof (char))
140	n/a	cif->flags = CIF_FLAGS_CHAR;
141	n/a	else if (cif->rtype->size == sizeof (short))
142	n/a	cif->flags = CIF_FLAGS_SHORT;
143	n/a	else if (cif->rtype->size == sizeof (int))
144	n/a	cif->flags = CIF_FLAGS_INT;
145	n/a	else if (cif->rtype->size == 2 * sizeof (int))
146	n/a	cif->flags = CIF_FLAGS_DINT;
147	n/a	else
148	n/a	cif->flags = 0;
149	n/a	break;
150	n/a
151	n/a	default:
152	n/a	if (cif->rtype->size <= sizeof (int))
153	n/a	cif->flags = CIF_FLAGS_INT;
154	n/a	else
155	n/a	cif->flags = CIF_FLAGS_DINT;
156	n/a	break;
157	n/a	}
158	n/a
159	n/a	return FFI_OK;
160	n/a	}
161	n/a
162	n/a	void
163	n/a	ffi_call (ffi_cif cif, void (fn) (), void rvalue, void *avalue)
164	n/a	{
165	n/a	extended_cif ecif;
166	n/a
167	n/a	ecif.cif = cif;
168	n/a	ecif.avalue = avalue;
169	n/a
170	n/a	/* If the return value is a struct and we don't have a return value
171	n/a	address then we need to make one. */
172	n/a
173	n/a	if (rvalue == NULL
174	n/a	&& cif->rtype->type == FFI_TYPE_STRUCT
175	n/a	&& cif->flags == 0)
176	n/a	ecif.rvalue = alloca (cif->rtype->size);
177	n/a	else
178	n/a	ecif.rvalue = rvalue;
179	n/a
180	n/a	switch (cif->abi)
181	n/a	{
182	n/a	case FFI_ELFBSD:
183	n/a	ffi_call_elfbsd (&ecif, cif->bytes, cif->flags, ecif.rvalue, fn);
184	n/a	break;
185	n/a
186	n/a	default:
187	n/a	FFI_ASSERT (0);
188	n/a	break;
189	n/a	}
190	n/a	}
191	n/a
192	n/a	/*
193	n/a	* Closure API
194	n/a	*/
195	n/a
196	n/a	void ffi_closure_elfbsd (void);
197	n/a	void ffi_closure_struct_elfbsd (void);
198	n/a	unsigned int ffi_closure_elfbsd_inner (ffi_closure , void , char *);
199	n/a
200	n/a	static void
201	n/a	ffi_prep_closure_elfbsd (ffi_cif cif, void avalue, char stackp)
202	n/a	{
203	n/a	unsigned int i;
204	n/a	void **p_argv;
205	n/a	ffi_type **p_arg;
206	n/a
207	n/a	p_argv = avalue;
208	n/a
209	n/a	for (i = cif->nargs, p_arg = cif->arg_types; i != 0; i--, p_arg++)
210	n/a	{
211	n/a	size_t z;
212	n/a
213	n/a	z = (*p_arg)->size;
214	n/a	*p_argv = stackp;
215	n/a
216	n/a	/* Align if necessary */
217	n/a	if ((sizeof (int) - 1) & z)
218	n/a	z = ALIGN(z, sizeof (int));
219	n/a
220	n/a	p_argv++;
221	n/a	stackp += z;
222	n/a	}
223	n/a	}
224	n/a
225	n/a	unsigned int
226	n/a	ffi_closure_elfbsd_inner (ffi_closure closure, void resp, char *stack)
227	n/a	{
228	n/a	ffi_cif *cif;
229	n/a	void **arg_area;
230	n/a
231	n/a	cif = closure->cif;
232	n/a	arg_area = (void *) alloca (cif->nargs sizeof (void *));
233	n/a
234	n/a	ffi_prep_closure_elfbsd (cif, arg_area, stack);
235	n/a
236	n/a	(closure->fun) (cif, resp, arg_area, closure->user_data);
237	n/a
238	n/a	return cif->flags;
239	n/a	}
240	n/a
241	n/a	ffi_status
242	n/a	ffi_prep_closure_loc (ffi_closure closure, ffi_cif cif,
243	n/a	void (fun)(ffi_cif , void , void , void ),
244	n/a	void user_data, void codeloc)
245	n/a	{
246	n/a	char tramp = (char ) codeloc;
247	n/a	void *fn;
248	n/a
249	n/a	FFI_ASSERT (cif->abi == FFI_ELFBSD);
250	n/a
251	n/a	/* entry mask */
252	n/a	(unsigned short )(tramp + 0) = 0x0000;
253	n/a	/* movl #closure, r0 */
254	n/a	tramp[2] = 0xd0;
255	n/a	tramp[3] = 0x8f;
256	n/a	(unsigned int )(tramp + 4) = (unsigned int) closure;
257	n/a	tramp[8] = 0x50;
258	n/a
259	n/a	if (cif->rtype->type == FFI_TYPE_STRUCT
260	n/a	&& !cif->flags)
261	n/a	fn = &ffi_closure_struct_elfbsd;
262	n/a	else
263	n/a	fn = &ffi_closure_elfbsd;
264	n/a
265	n/a	/* jmpl #fn */
266	n/a	tramp[9] = 0x17;
267	n/a	tramp[10] = 0xef;
268	n/a	(unsigned int )(tramp + 11) = (unsigned int)fn + 2 -
269	n/a	(unsigned int)tramp - 9 - 6;
270	n/a
271	n/a	closure->cif = cif;
272	n/a	closure->user_data = user_data;
273	n/a	closure->fun = fun;
274	n/a
275	n/a	return FFI_OK;
276	n/a	}