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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 1998 Cygnus Solutions
3	n/a	Copyright (c) 2004 Simon Posnjak
4	n/a	Copyright (c) 2005 Axis Communications AB
5	n/a	Copyright (C) 2007 Free Software Foundation, Inc.
6	n/a
7	n/a	CRIS Foreign Function Interface
8	n/a
9	n/a	Permission is hereby granted, free of charge, to any person obtaining
10	n/a	a copy of this software and associated documentation files (the
11	n/a	``Software''), to deal in the Software without restriction, including
12	n/a	without limitation the rights to use, copy, modify, merge, publish,
13	n/a	distribute, sublicense, and/or sell copies of the Software, and to
14	n/a	permit persons to whom the Software is furnished to do so, subject to
15	n/a	the following conditions:
16	n/a
17	n/a	The above copyright notice and this permission notice shall be included
18	n/a	in all copies or substantial portions of the Software.
19	n/a
20	n/a	THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
21	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23	n/a	IN NO EVENT SHALL SIMON POSNJAK BE LIABLE FOR ANY CLAIM, DAMAGES OR
24	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26	n/a	OTHER 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	#define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG)
33	n/a
34	n/a	static ffi_status
35	n/a	initialize_aggregate_packed_struct (ffi_type * arg)
36	n/a	{
37	n/a	ffi_type **ptr;
38	n/a
39	n/a	FFI_ASSERT (arg != NULL);
40	n/a
41	n/a	FFI_ASSERT (arg->elements != NULL);
42	n/a	FFI_ASSERT (arg->size == 0);
43	n/a	FFI_ASSERT (arg->alignment == 0);
44	n/a
45	n/a	ptr = &(arg->elements[0]);
46	n/a
47	n/a	while ((*ptr) != NULL)
48	n/a	{
49	n/a	if (((*ptr)->size == 0)
50	n/a	&& (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
51	n/a	return FFI_BAD_TYPEDEF;
52	n/a
53	n/a	FFI_ASSERT (ffi_type_test ((*ptr)));
54	n/a
55	n/a	arg->size += (*ptr)->size;
56	n/a
57	n/a	arg->alignment = (arg->alignment > (*ptr)->alignment) ?
58	n/a	arg->alignment : (*ptr)->alignment;
59	n/a
60	n/a	ptr++;
61	n/a	}
62	n/a
63	n/a	if (arg->size == 0)
64	n/a	return FFI_BAD_TYPEDEF;
65	n/a	else
66	n/a	return FFI_OK;
67	n/a	}
68	n/a
69	n/a	int
70	n/a	ffi_prep_args (char stack, extended_cif ecif)
71	n/a	{
72	n/a	unsigned int i;
73	n/a	unsigned int struct_count = 0;
74	n/a	void **p_argv;
75	n/a	char *argp;
76	n/a	ffi_type **p_arg;
77	n/a
78	n/a	argp = stack;
79	n/a
80	n/a	p_argv = ecif->avalue;
81	n/a
82	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
83	n/a	(i != 0); i--, p_arg++)
84	n/a	{
85	n/a	size_t z;
86	n/a
87	n/a	switch ((*p_arg)->type)
88	n/a	{
89	n/a	case FFI_TYPE_STRUCT:
90	n/a	{
91	n/a	z = (*p_arg)->size;
92	n/a	if (z <= 4)
93	n/a	{
94	n/a	memcpy (argp, *p_argv, z);
95	n/a	z = 4;
96	n/a	}
97	n/a	else if (z <= 8)
98	n/a	{
99	n/a	memcpy (argp, *p_argv, z);
100	n/a	z = 8;
101	n/a	}
102	n/a	else
103	n/a	{
104	n/a	unsigned int uiLocOnStack;
105	n/a	z = sizeof (void *);
106	n/a	uiLocOnStack = 4 * ecif->cif->nargs + struct_count;
107	n/a	struct_count = struct_count + (*p_arg)->size;
108	n/a	(unsigned int ) argp =
109	n/a	(unsigned int) (UINT32 *) (stack + uiLocOnStack);
110	n/a	memcpy ((stack + uiLocOnStack), p_argv, (p_arg)->size);
111	n/a	}
112	n/a	break;
113	n/a	}
114	n/a	default:
115	n/a	z = (*p_arg)->size;
116	n/a	if (z < sizeof (int))
117	n/a	{
118	n/a	switch ((*p_arg)->type)
119	n/a	{
120	n/a	case FFI_TYPE_SINT8:
121	n/a	(signed int ) argp = (signed int) (SINT8 ) (*p_argv);
122	n/a	break;
123	n/a
124	n/a	case FFI_TYPE_UINT8:
125	n/a	(unsigned int ) argp =
126	n/a	(unsigned int) (UINT8 ) (*p_argv);
127	n/a	break;
128	n/a
129	n/a	case FFI_TYPE_SINT16:
130	n/a	(signed int ) argp = (signed int) (SINT16 ) (*p_argv);
131	n/a	break;
132	n/a
133	n/a	case FFI_TYPE_UINT16:
134	n/a	(unsigned int ) argp =
135	n/a	(unsigned int) (UINT16 ) (*p_argv);
136	n/a	break;
137	n/a
138	n/a	default:
139	n/a	FFI_ASSERT (0);
140	n/a	}
141	n/a	z = sizeof (int);
142	n/a	}
143	n/a	else if (z == sizeof (int))
144	n/a	(unsigned int ) argp = (unsigned int) (UINT32 ) (*p_argv);
145	n/a	else
146	n/a	memcpy (argp, *p_argv, z);
147	n/a	break;
148	n/a	}
149	n/a	p_argv++;
150	n/a	argp += z;
151	n/a	}
152	n/a
153	n/a	return (struct_count);
154	n/a	}
155	n/a
156	n/a	ffi_status FFI_HIDDEN
157	n/a	ffi_prep_cif_core (ffi_cif * cif,
158	n/a	ffi_abi abi, unsigned int isvariadic,
159	n/a	unsigned int nfixedargs, unsigned int ntotalargs,
160	n/a	ffi_type * rtype, ffi_type ** atypes)
161	n/a	{
162	n/a	unsigned bytes = 0;
163	n/a	unsigned int i;
164	n/a	ffi_type **ptr;
165	n/a
166	n/a	FFI_ASSERT (cif != NULL);
167	n/a	FFI_ASSERT((!isvariadic) \|\| (nfixedargs >= 1));
168	n/a	FFI_ASSERT(nfixedargs <= ntotalargs);
169	n/a	FFI_ASSERT (abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI);
170	n/a
171	n/a	cif->abi = abi;
172	n/a	cif->arg_types = atypes;
173	n/a	cif->nargs = ntotalargs;
174	n/a	cif->rtype = rtype;
175	n/a
176	n/a	cif->flags = 0;
177	n/a
178	n/a	if ((cif->rtype->size == 0)
179	n/a	&& (initialize_aggregate_packed_struct (cif->rtype) != FFI_OK))
180	n/a	return FFI_BAD_TYPEDEF;
181	n/a
182	n/a	FFI_ASSERT_VALID_TYPE (cif->rtype);
183	n/a
184	n/a	for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
185	n/a	{
186	n/a	if (((*ptr)->size == 0)
187	n/a	&& (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
188	n/a	return FFI_BAD_TYPEDEF;
189	n/a
190	n/a	FFI_ASSERT_VALID_TYPE (*ptr);
191	n/a
192	n/a	if (((*ptr)->alignment - 1) & bytes)
193	n/a	bytes = ALIGN (bytes, (*ptr)->alignment);
194	n/a	if ((*ptr)->type == FFI_TYPE_STRUCT)
195	n/a	{
196	n/a	if ((*ptr)->size > 8)
197	n/a	{
198	n/a	bytes += (*ptr)->size;
199	n/a	bytes += sizeof (void *);
200	n/a	}
201	n/a	else
202	n/a	{
203	n/a	if ((*ptr)->size > 4)
204	n/a	bytes += 8;
205	n/a	else
206	n/a	bytes += 4;
207	n/a	}
208	n/a	}
209	n/a	else
210	n/a	bytes += STACK_ARG_SIZE ((*ptr)->size);
211	n/a	}
212	n/a
213	n/a	cif->bytes = bytes;
214	n/a
215	n/a	return ffi_prep_cif_machdep (cif);
216	n/a	}
217	n/a
218	n/a	ffi_status
219	n/a	ffi_prep_cif_machdep (ffi_cif * cif)
220	n/a	{
221	n/a	switch (cif->rtype->type)
222	n/a	{
223	n/a	case FFI_TYPE_VOID:
224	n/a	case FFI_TYPE_STRUCT:
225	n/a	case FFI_TYPE_FLOAT:
226	n/a	case FFI_TYPE_DOUBLE:
227	n/a	case FFI_TYPE_SINT64:
228	n/a	case FFI_TYPE_UINT64:
229	n/a	cif->flags = (unsigned) cif->rtype->type;
230	n/a	break;
231	n/a
232	n/a	default:
233	n/a	cif->flags = FFI_TYPE_INT;
234	n/a	break;
235	n/a	}
236	n/a
237	n/a	return FFI_OK;
238	n/a	}
239	n/a
240	n/a	extern void ffi_call_SYSV (int ()(char , extended_cif *),
241	n/a	extended_cif *,
242	n/a	unsigned, unsigned, unsigned , void (fn) ())
243	n/a	__attribute__ ((__visibility__ ("hidden")));
244	n/a
245	n/a	void
246	n/a	ffi_call (ffi_cif * cif, void (fn) (), void rvalue, void **avalue)
247	n/a	{
248	n/a	extended_cif ecif;
249	n/a
250	n/a	ecif.cif = cif;
251	n/a	ecif.avalue = avalue;
252	n/a
253	n/a	if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
254	n/a	{
255	n/a	ecif.rvalue = alloca (cif->rtype->size);
256	n/a	}
257	n/a	else
258	n/a	ecif.rvalue = rvalue;
259	n/a
260	n/a	switch (cif->abi)
261	n/a	{
262	n/a	case FFI_SYSV:
263	n/a	ffi_call_SYSV (ffi_prep_args, &ecif, cif->bytes,
264	n/a	cif->flags, ecif.rvalue, fn);
265	n/a	break;
266	n/a	default:
267	n/a	FFI_ASSERT (0);
268	n/a	break;
269	n/a	}
270	n/a	}
271	n/a
272	n/a	/* Because the following variables are not exported outside libffi, we
273	n/a	mark them hidden. */
274	n/a
275	n/a	/* Assembly code for the jump stub. */
276	n/a	extern const char ffi_cris_trampoline_template[]
277	n/a	__attribute__ ((__visibility__ ("hidden")));
278	n/a
279	n/a	/* Offset into ffi_cris_trampoline_template of where to put the
280	n/a	ffi_prep_closure_inner function. */
281	n/a	extern const int ffi_cris_trampoline_fn_offset
282	n/a	__attribute__ ((__visibility__ ("hidden")));
283	n/a
284	n/a	/* Offset into ffi_cris_trampoline_template of where to put the
285	n/a	closure data. */
286	n/a	extern const int ffi_cris_trampoline_closure_offset
287	n/a	__attribute__ ((__visibility__ ("hidden")));
288	n/a
289	n/a	/* This function is sibling-called (jumped to) by the closure
290	n/a	trampoline. We get R10..R13 at PARAMS[0..3] and a copy of [SP] at
291	n/a	PARAMS[4] to simplify handling of a straddling parameter. A copy
292	n/a	of R9 is at PARAMS[5] and SP at PARAMS[6]. These parameters are
293	n/a	put at the appropriate place in CLOSURE which is then executed and
294	n/a	the return value is passed back to the caller. */
295	n/a
296	n/a	static unsigned long long
297	n/a	ffi_prep_closure_inner (void *params, ffi_closure closure)
298	n/a	{
299	n/a	char register_args = (char ) params;
300	n/a	void *struct_ret = params[5];
301	n/a	char *stack_args = params[6];
302	n/a	char *ptr = register_args;
303	n/a	ffi_cif *cif = closure->cif;
304	n/a	ffi_type **arg_types = cif->arg_types;
305	n/a
306	n/a	/* Max room needed is number of arguments as 64-bit values. */
307	n/a	void *avalue = alloca (closure->cif->nargs sizeof(void *));
308	n/a	int i;
309	n/a	int doing_regs;
310	n/a	long long llret = 0;
311	n/a
312	n/a	/* Find the address of each argument. */
313	n/a	for (i = 0, doing_regs = 1; i < cif->nargs; i++)
314	n/a	{
315	n/a	/* Types up to and including 8 bytes go by-value. */
316	n/a	if (arg_types[i]->size <= 4)
317	n/a	{
318	n/a	avalue[i] = ptr;
319	n/a	ptr += 4;
320	n/a	}
321	n/a	else if (arg_types[i]->size <= 8)
322	n/a	{
323	n/a	avalue[i] = ptr;
324	n/a	ptr += 8;
325	n/a	}
326	n/a	else
327	n/a	{
328	n/a	FFI_ASSERT (arg_types[i]->type == FFI_TYPE_STRUCT);
329	n/a
330	n/a	/* Passed by-reference, so copy the pointer. */
331	n/a	avalue[i] = (void *) ptr;
332	n/a	ptr += 4;
333	n/a	}
334	n/a
335	n/a	/* If we've handled more arguments than fit in registers, start
336	n/a	looking at the those passed on the stack. Step over the
337	n/a	first one if we had a straddling parameter. */
338	n/a	if (doing_regs && ptr >= register_args + 4*4)
339	n/a	{
340	n/a	ptr = stack_args + ((ptr > register_args + 4*4) ? 4 : 0);
341	n/a	doing_regs = 0;
342	n/a	}
343	n/a	}
344	n/a
345	n/a	/* Invoke the closure. */
346	n/a	(closure->fun) (cif,
347	n/a
348	n/a	cif->rtype->type == FFI_TYPE_STRUCT
349	n/a	/* The caller allocated space for the return
350	n/a	structure, and passed a pointer to this space in
351	n/a	R9. */
352	n/a	? struct_ret
353	n/a
354	n/a	/* We take advantage of being able to ignore that
355	n/a	the high part isn't set if the return value is
356	n/a	not in R10:R11, but in R10 only. */
357	n/a	: (void *) &llret,
358	n/a
359	n/a	avalue, closure->user_data);
360	n/a
361	n/a	return llret;
362	n/a	}
363	n/a
364	n/a	/* API function: Prepare the trampoline. */
365	n/a
366	n/a	ffi_status
367	n/a	ffi_prep_closure_loc (ffi_closure* closure,
368	n/a	ffi_cif* cif,
369	n/a	void (fun)(ffi_cif , void , void , void),
370	n/a	void *user_data,
371	n/a	void *codeloc)
372	n/a	{
373	n/a	void *innerfn = ffi_prep_closure_inner;
374	n/a	FFI_ASSERT (cif->abi == FFI_SYSV);
375	n/a	closure->cif = cif;
376	n/a	closure->user_data = user_data;
377	n/a	closure->fun = fun;
378	n/a	memcpy (closure->tramp, ffi_cris_trampoline_template,
379	n/a	FFI_CRIS_TRAMPOLINE_CODE_PART_SIZE);
380	n/a	memcpy (closure->tramp + ffi_cris_trampoline_fn_offset,
381	n/a	&innerfn, sizeof (void *));
382	n/a	memcpy (closure->tramp + ffi_cris_trampoline_closure_offset,
383	n/a	&codeloc, sizeof (void *));
384	n/a
385	n/a	return FFI_OK;
386	n/a	}