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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2013 Synopsys, Inc. (www.synopsys.com)
3	n/a
4	n/a	ARC 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, EXPRESS
18	n/a	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19	n/a	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20	n/a	IN NO EVENT SHALL RENESAS TECHNOLOGY BE LIABLE FOR ANY CLAIM, DAMAGES OR
21	n/a	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22	n/a	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23	n/a	OTHER DEALINGS IN THE SOFTWARE.
24	n/a	----------------------------------------------------------------------- */
25	n/a
26	n/a	#include <ffi.h>
27	n/a	#include <ffi_common.h>
28	n/a
29	n/a	#include <stdlib.h>
30	n/a	#include <stdint.h>
31	n/a
32	n/a	#include <sys/cachectl.h>
33	n/a
34	n/a	/* for little endian ARC, the code is in fact stored as mixed endian for
35	n/a	performance reasons */
36	n/a	#if __BIG_ENDIAN__
37	n/a	#define CODE_ENDIAN(x) (x)
38	n/a	#else
39	n/a	#define CODE_ENDIAN(x) ( (((uint32_t) (x)) << 16) \| (((uint32_t) (x)) >> 16))
40	n/a	#endif
41	n/a
42	n/a	/* ffi_prep_args is called by the assembly routine once stack
43	n/a	space has been allocated for the function's arguments. */
44	n/a
45	n/a	void
46	n/a	ffi_prep_args (char stack, extended_cif ecif)
47	n/a	{
48	n/a	unsigned int i;
49	n/a	int tmp;
50	n/a	void **p_argv;
51	n/a	char *argp;
52	n/a	ffi_type **p_arg;
53	n/a
54	n/a	tmp = 0;
55	n/a	argp = stack;
56	n/a
57	n/a	if (ecif->cif->rtype->type == FFI_TYPE_STRUCT)
58	n/a	{
59	n/a	(void *) argp = ecif->rvalue;
60	n/a	argp += 4;
61	n/a	}
62	n/a
63	n/a	p_argv = ecif->avalue;
64	n/a
65	n/a	for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
66	n/a	(i != 0); i--, p_arg++)
67	n/a	{
68	n/a	size_t z;
69	n/a	int alignment;
70	n/a
71	n/a	/* align alignment to 4 */
72	n/a	alignment = (((*p_arg)->alignment - 1) \| 3) + 1;
73	n/a
74	n/a	/* Align if necessary. */
75	n/a	if ((alignment - 1) & (unsigned) argp)
76	n/a	argp = (char *) ALIGN (argp, alignment);
77	n/a
78	n/a	z = (*p_arg)->size;
79	n/a	if (z < sizeof (int))
80	n/a	{
81	n/a	z = sizeof (int);
82	n/a
83	n/a	switch ((*p_arg)->type)
84	n/a	{
85	n/a	case FFI_TYPE_SINT8:
86	n/a	(signed int ) argp = (signed int) (SINT8 ) (*p_argv);
87	n/a	break;
88	n/a
89	n/a	case FFI_TYPE_UINT8:
90	n/a	(unsigned int ) argp = (unsigned int) (UINT8 ) (*p_argv);
91	n/a	break;
92	n/a
93	n/a	case FFI_TYPE_SINT16:
94	n/a	(signed int ) argp = (signed int) (SINT16 ) (*p_argv);
95	n/a	break;
96	n/a
97	n/a	case FFI_TYPE_UINT16:
98	n/a	(unsigned int ) argp = (unsigned int) (UINT16 ) (*p_argv);
99	n/a	break;
100	n/a
101	n/a	case FFI_TYPE_STRUCT:
102	n/a	memcpy (argp, p_argv, (p_arg)->size);
103	n/a	break;
104	n/a
105	n/a	default:
106	n/a	FFI_ASSERT (0);
107	n/a	}
108	n/a	}
109	n/a	else if (z == sizeof (int))
110	n/a	{
111	n/a	(unsigned int ) argp = (unsigned int) (UINT32 ) (*p_argv);
112	n/a	}
113	n/a	else
114	n/a	{
115	n/a	if ((*p_arg)->type == FFI_TYPE_STRUCT)
116	n/a	{
117	n/a	memcpy (argp, *p_argv, z);
118	n/a	}
119	n/a	else
120	n/a	{
121	n/a	/* Double or long long 64bit. */
122	n/a	memcpy (argp, *p_argv, z);
123	n/a	}
124	n/a	}
125	n/a	p_argv++;
126	n/a	argp += z;
127	n/a	}
128	n/a
129	n/a	return;
130	n/a	}
131	n/a
132	n/a	/* Perform machine dependent cif processing. */
133	n/a	ffi_status
134	n/a	ffi_prep_cif_machdep (ffi_cif * cif)
135	n/a	{
136	n/a	/* Set the return type flag. */
137	n/a	switch (cif->rtype->type)
138	n/a	{
139	n/a	case FFI_TYPE_VOID:
140	n/a	cif->flags = (unsigned) cif->rtype->type;
141	n/a	break;
142	n/a
143	n/a	case FFI_TYPE_STRUCT:
144	n/a	cif->flags = (unsigned) cif->rtype->type;
145	n/a	break;
146	n/a
147	n/a	case FFI_TYPE_SINT64:
148	n/a	case FFI_TYPE_UINT64:
149	n/a	case FFI_TYPE_DOUBLE:
150	n/a	cif->flags = FFI_TYPE_DOUBLE;
151	n/a	break;
152	n/a
153	n/a	case FFI_TYPE_FLOAT:
154	n/a	default:
155	n/a	cif->flags = FFI_TYPE_INT;
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	extern void ffi_call_ARCompact (void ()(char , extended_cif *),
163	n/a	extended_cif *, unsigned, unsigned,
164	n/a	unsigned , void (fn) (void));
165	n/a
166	n/a	void
167	n/a	ffi_call (ffi_cif * cif, void (fn) (void), void rvalue, void **avalue)
168	n/a	{
169	n/a	extended_cif ecif;
170	n/a
171	n/a	ecif.cif = cif;
172	n/a	ecif.avalue = avalue;
173	n/a
174	n/a	/* If the return value is a struct and we don't have
175	n/a	a return value address then we need to make one. */
176	n/a	if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
177	n/a	{
178	n/a	ecif.rvalue = alloca (cif->rtype->size);
179	n/a	}
180	n/a	else
181	n/a	ecif.rvalue = rvalue;
182	n/a
183	n/a	switch (cif->abi)
184	n/a	{
185	n/a	case FFI_ARCOMPACT:
186	n/a	ffi_call_ARCompact (ffi_prep_args, &ecif, cif->bytes,
187	n/a	cif->flags, ecif.rvalue, fn);
188	n/a	break;
189	n/a
190	n/a	default:
191	n/a	FFI_ASSERT (0);
192	n/a	break;
193	n/a	}
194	n/a	}
195	n/a
196	n/a	int
197	n/a	ffi_closure_inner_ARCompact (ffi_closure * closure, void *rvalue,
198	n/a	ffi_arg * args)
199	n/a	{
200	n/a	void arg_area, p_argv;
201	n/a	ffi_cif *cif = closure->cif;
202	n/a	char argp = (char ) args;
203	n/a	ffi_type **p_argt;
204	n/a	int i;
205	n/a
206	n/a	arg_area = (void *) alloca (cif->nargs sizeof (void *));
207	n/a
208	n/a	/* handle hidden argument */
209	n/a	if (cif->flags == FFI_TYPE_STRUCT)
210	n/a	{
211	n/a	rvalue = (void *) argp;
212	n/a	argp += 4;
213	n/a	}
214	n/a
215	n/a	p_argv = arg_area;
216	n/a
217	n/a	for (i = 0, p_argt = cif->arg_types; i < cif->nargs;
218	n/a	i++, p_argt++, p_argv++)
219	n/a	{
220	n/a	size_t z;
221	n/a	int alignment;
222	n/a
223	n/a	/* align alignment to 4 */
224	n/a	alignment = (((*p_argt)->alignment - 1) \| 3) + 1;
225	n/a
226	n/a	/* Align if necessary. */
227	n/a	if ((alignment - 1) & (unsigned) argp)
228	n/a	argp = (char *) ALIGN (argp, alignment);
229	n/a
230	n/a	z = (*p_argt)->size;
231	n/a	p_argv = (void ) argp;
232	n/a	argp += z;
233	n/a	}
234	n/a
235	n/a	(closure->fun) (cif, rvalue, arg_area, closure->user_data);
236	n/a
237	n/a	return cif->flags;
238	n/a	}
239	n/a
240	n/a	extern void ffi_closure_ARCompact (void);
241	n/a
242	n/a	ffi_status
243	n/a	ffi_prep_closure_loc (ffi_closure * closure, ffi_cif * cif,
244	n/a	void (fun) (ffi_cif , void , void , void ),
245	n/a	void user_data, void codeloc)
246	n/a	{
247	n/a	uint32_t tramp = (uint32_t ) & (closure->tramp[0]);
248	n/a
249	n/a	switch (cif->abi)
250	n/a	{
251	n/a	case FFI_ARCOMPACT:
252	n/a	FFI_ASSERT (tramp == codeloc);
253	n/a	tramp[0] = CODE_ENDIAN (0x200a1fc0); /* mov r8, pcl */
254	n/a	tramp[1] = CODE_ENDIAN (0x20200f80); /* j [long imm] */
255	n/a	tramp[2] = CODE_ENDIAN (ffi_closure_ARCompact);
256	n/a	break;
257	n/a
258	n/a	default:
259	n/a	return FFI_BAD_ABI;
260	n/a	}
261	n/a
262	n/a	closure->cif = cif;
263	n/a	closure->fun = fun;
264	n/a	closure->user_data = user_data;
265	n/a	cacheflush (codeloc, FFI_TRAMPOLINE_SIZE, BCACHE);
266	n/a
267	n/a	return FFI_OK;
268	n/a	}