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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2012, 2013 Xilinx, Inc
3	n/a
4	n/a	MicroBlaze 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	extern void ffi_call_SYSV(void ()(void, extended_cif), extended_cif,
31	n/a	unsigned int, unsigned int, unsigned int, void (fn)(void),
32	n/a	unsigned int, unsigned int);
33	n/a
34	n/a	extern void ffi_closure_SYSV(void);
35	n/a
36	n/a	#define WORD_SIZE sizeof(unsigned int)
37	n/a	#define ARGS_REGISTER_SIZE (WORD_SIZE * 6)
38	n/a	#define WORD_ALIGN(x) ALIGN(x, WORD_SIZE)
39	n/a
40	n/a	/* ffi_prep_args is called by the assembly routine once stack space
41	n/a	has been allocated for the function's arguments */
42	n/a	void ffi_prep_args(void* stack, extended_cif* ecif)
43	n/a	{
44	n/a	unsigned int i;
45	n/a	ffi_type** p_arg;
46	n/a	void** p_argv;
47	n/a	void* stack_args_p = stack;
48	n/a
49	n/a	p_argv = ecif->avalue;
50	n/a
51	n/a	if (ecif == NULL \|\| ecif->cif == NULL) {
52	n/a	return; /* no description to prepare */
53	n/a	}
54	n/a
55	n/a	if ((ecif->cif->rtype != NULL) &&
56	n/a	(ecif->cif->rtype->type == FFI_TYPE_STRUCT))
57	n/a	{
58	n/a	/* if return type is a struct which is referenced on the stack/reg5,
59	n/a	* by a pointer. Stored the return value pointer in r5.
60	n/a	*/
61	n/a	char* addr = stack_args_p;
62	n/a	memcpy(addr, &(ecif->rvalue), WORD_SIZE);
63	n/a	stack_args_p += WORD_SIZE;
64	n/a	}
65	n/a
66	n/a	if (ecif->avalue == NULL) {
67	n/a	return; /* no arguments to prepare */
68	n/a	}
69	n/a
70	n/a	for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs;
71	n/a	i++, p_arg++)
72	n/a	{
73	n/a	size_t size = (*p_arg)->size;
74	n/a	int type = (*p_arg)->type;
75	n/a	void* value = p_argv[i];
76	n/a	char* addr = stack_args_p;
77	n/a	int aligned_size = WORD_ALIGN(size);
78	n/a
79	n/a	/* force word alignment on the stack */
80	n/a	stack_args_p += aligned_size;
81	n/a
82	n/a	switch (type)
83	n/a	{
84	n/a	case FFI_TYPE_UINT8:
85	n/a	(unsigned int )addr = (unsigned int)(UINT8)(value);
86	n/a	break;
87	n/a	case FFI_TYPE_SINT8:
88	n/a	(signed int )addr = (signed int)(SINT8)(value);
89	n/a	break;
90	n/a	case FFI_TYPE_UINT16:
91	n/a	(unsigned int )addr = (unsigned int)(UINT16)(value);
92	n/a	break;
93	n/a	case FFI_TYPE_SINT16:
94	n/a	(signed int )addr = (signed int)(SINT16)(value);
95	n/a	break;
96	n/a	case FFI_TYPE_STRUCT:
97	n/a	#if __BIG_ENDIAN__
98	n/a	/*
99	n/a	* MicroBlaze toolchain appears to emit:
100	n/a	* bsrli r5, r5, 8 (caller)
101	n/a	* ...
102	n/a	* <branch to callee>
103	n/a	* ...
104	n/a	* bslli r5, r5, 8 (callee)
105	n/a	*
106	n/a	* For structs like "struct a { uint8_t a[3]; };", when passed
107	n/a	* by value.
108	n/a	*
109	n/a	* Structs like "struct b { uint16_t a; };" are also expected
110	n/a	* to be packed strangely in registers.
111	n/a	*
112	n/a	* This appears to be because the microblaze toolchain expects
113	n/a	* "struct b == uint16_t", which is only any issue for big
114	n/a	* endian.
115	n/a	*
116	n/a	* The following is a work around for big-endian only, for the
117	n/a	* above mentioned case, it will re-align the contents of a
118	n/a	* <= 3-byte struct value.
119	n/a	*/
120	n/a	if (size < WORD_SIZE)
121	n/a	{
122	n/a	memcpy (addr + (WORD_SIZE - size), value, size);
123	n/a	break;
124	n/a	}
125	n/a	#endif
126	n/a	case FFI_TYPE_SINT32:
127	n/a	case FFI_TYPE_UINT32:
128	n/a	case FFI_TYPE_FLOAT:
129	n/a	case FFI_TYPE_SINT64:
130	n/a	case FFI_TYPE_UINT64:
131	n/a	case FFI_TYPE_DOUBLE:
132	n/a	default:
133	n/a	memcpy(addr, value, aligned_size);
134	n/a	}
135	n/a	}
136	n/a	}
137	n/a
138	n/a	ffi_status ffi_prep_cif_machdep(ffi_cif* cif)
139	n/a	{
140	n/a	/* check ABI */
141	n/a	switch (cif->abi)
142	n/a	{
143	n/a	case FFI_SYSV:
144	n/a	break;
145	n/a	default:
146	n/a	return FFI_BAD_ABI;
147	n/a	}
148	n/a	return FFI_OK;
149	n/a	}
150	n/a
151	n/a	void ffi_call(ffi_cif* cif, void (fn)(void), void rvalue, void** avalue)
152	n/a	{
153	n/a	extended_cif ecif;
154	n/a	ecif.cif = cif;
155	n/a	ecif.avalue = avalue;
156	n/a
157	n/a	/* If the return value is a struct and we don't have a return */
158	n/a	/* value address then we need to make one */
159	n/a	if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) {
160	n/a	ecif.rvalue = alloca(cif->rtype->size);
161	n/a	} else {
162	n/a	ecif.rvalue = rvalue;
163	n/a	}
164	n/a
165	n/a	switch (cif->abi)
166	n/a	{
167	n/a	case FFI_SYSV:
168	n/a	ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags,
169	n/a	ecif.rvalue, fn, cif->rtype->type, cif->rtype->size);
170	n/a	break;
171	n/a	default:
172	n/a	FFI_ASSERT(0);
173	n/a	break;
174	n/a	}
175	n/a	}
176	n/a
177	n/a	void ffi_closure_call_SYSV(void* register_args, void* stack_args,
178	n/a	ffi_closure* closure, void* rvalue,
179	n/a	unsigned int* rtype, unsigned int* rsize)
180	n/a	{
181	n/a	/* prepare arguments for closure call */
182	n/a	ffi_cif* cif = closure->cif;
183	n/a	ffi_type** arg_types = cif->arg_types;
184	n/a
185	n/a	/* re-allocate data for the args. This needs to be done in order to keep
186	n/a	* multi-word objects (e.g. structs) in contiguous memory. Callers are not
187	n/a	* required to store the value of args in the lower 6 words in the stack
188	n/a	* (although they are allocated in the stack).
189	n/a	*/
190	n/a	char* stackclone = alloca(cif->bytes);
191	n/a	void** avalue = alloca(cif->nargs * sizeof(void*));
192	n/a	void* struct_rvalue = NULL;
193	n/a	char* ptr = stackclone;
194	n/a	int i;
195	n/a
196	n/a	/* copy registers into stack clone */
197	n/a	int registers_used = cif->bytes;
198	n/a	if (registers_used > ARGS_REGISTER_SIZE) {
199	n/a	registers_used = ARGS_REGISTER_SIZE;
200	n/a	}
201	n/a	memcpy(stackclone, register_args, registers_used);
202	n/a
203	n/a	/* copy stack allocated args into stack clone */
204	n/a	if (cif->bytes > ARGS_REGISTER_SIZE) {
205	n/a	int stack_used = cif->bytes - ARGS_REGISTER_SIZE;
206	n/a	memcpy(stackclone + ARGS_REGISTER_SIZE, stack_args, stack_used);
207	n/a	}
208	n/a
209	n/a	/* preserve struct type return pointer passing */
210	n/a	if ((cif->rtype != NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) {
211	n/a	struct_rvalue = ((void*)ptr);
212	n/a	ptr += WORD_SIZE;
213	n/a	}
214	n/a
215	n/a	/* populate arg pointer list */
216	n/a	for (i = 0; i < cif->nargs; i++)
217	n/a	{
218	n/a	switch (arg_types[i]->type)
219	n/a	{
220	n/a	case FFI_TYPE_SINT8:
221	n/a	case FFI_TYPE_UINT8:
222	n/a	#ifdef __BIG_ENDIAN__
223	n/a	avalue[i] = ptr + 3;
224	n/a	#else
225	n/a	avalue[i] = ptr;
226	n/a	#endif
227	n/a	break;
228	n/a	case FFI_TYPE_SINT16:
229	n/a	case FFI_TYPE_UINT16:
230	n/a	#ifdef __BIG_ENDIAN__
231	n/a	avalue[i] = ptr + 2;
232	n/a	#else
233	n/a	avalue[i] = ptr;
234	n/a	#endif
235	n/a	break;
236	n/a	case FFI_TYPE_STRUCT:
237	n/a	#if __BIG_ENDIAN__
238	n/a	/*
239	n/a	* Work around strange ABI behaviour.
240	n/a	* (see info in ffi_prep_args)
241	n/a	*/
242	n/a	if (arg_types[i]->size < WORD_SIZE)
243	n/a	{
244	n/a	memcpy (ptr, ptr + (WORD_SIZE - arg_types[i]->size), arg_types[i]->size);
245	n/a	}
246	n/a	#endif
247	n/a	avalue[i] = (void*)ptr;
248	n/a	break;
249	n/a	case FFI_TYPE_UINT64:
250	n/a	case FFI_TYPE_SINT64:
251	n/a	case FFI_TYPE_DOUBLE:
252	n/a	avalue[i] = ptr;
253	n/a	break;
254	n/a	case FFI_TYPE_SINT32:
255	n/a	case FFI_TYPE_UINT32:
256	n/a	case FFI_TYPE_FLOAT:
257	n/a	default:
258	n/a	/* default 4-byte argument */
259	n/a	avalue[i] = ptr;
260	n/a	break;
261	n/a	}
262	n/a	ptr += WORD_ALIGN(arg_types[i]->size);
263	n/a	}
264	n/a
265	n/a	/* set the return type info passed back to the wrapper */
266	n/a	*rsize = cif->rtype->size;
267	n/a	*rtype = cif->rtype->type;
268	n/a	if (struct_rvalue != NULL) {
269	n/a	closure->fun(cif, struct_rvalue, avalue, closure->user_data);
270	n/a	/* copy struct return pointer value into function return value */
271	n/a	((void*)rvalue) = struct_rvalue;
272	n/a	} else {
273	n/a	closure->fun(cif, rvalue, avalue, closure->user_data);
274	n/a	}
275	n/a	}
276	n/a
277	n/a	ffi_status ffi_prep_closure_loc(
278	n/a	ffi_closure* closure, ffi_cif* cif,
279	n/a	void (fun)(ffi_cif, void, void, void),
280	n/a	void* user_data, void* codeloc)
281	n/a	{
282	n/a	unsigned long* tramp = (unsigned long*)&(closure->tramp[0]);
283	n/a	unsigned long cls = (unsigned long)codeloc;
284	n/a	unsigned long fn = 0;
285	n/a	unsigned long fn_closure_call_sysv = (unsigned long)ffi_closure_call_SYSV;
286	n/a
287	n/a	closure->cif = cif;
288	n/a	closure->fun = fun;
289	n/a	closure->user_data = user_data;
290	n/a
291	n/a	switch (cif->abi)
292	n/a	{
293	n/a	case FFI_SYSV:
294	n/a	fn = (unsigned long)ffi_closure_SYSV;
295	n/a
296	n/a	/* load r11 (temp) with fn */
297	n/a	/* imm fn(upper) */
298	n/a	tramp[0] = 0xb0000000 \| ((fn >> 16) & 0xffff);
299	n/a	/* addik r11, r0, fn(lower) */
300	n/a	tramp[1] = 0x31600000 \| (fn & 0xffff);
301	n/a
302	n/a	/* load r12 (temp) with cls */
303	n/a	/* imm cls(upper) */
304	n/a	tramp[2] = 0xb0000000 \| ((cls >> 16) & 0xffff);
305	n/a	/* addik r12, r0, cls(lower) */
306	n/a	tramp[3] = 0x31800000 \| (cls & 0xffff);
307	n/a
308	n/a	/* load r3 (temp) with ffi_closure_call_SYSV */
309	n/a	/* imm fn_closure_call_sysv(upper) */
310	n/a	tramp[4] = 0xb0000000 \| ((fn_closure_call_sysv >> 16) & 0xffff);
311	n/a	/* addik r3, r0, fn_closure_call_sysv(lower) */
312	n/a	tramp[5] = 0x30600000 \| (fn_closure_call_sysv & 0xffff);
313	n/a	/* branch/jump to address stored in r11 (fn) */
314	n/a	tramp[6] = 0x98085800; /* bra r11 */
315	n/a
316	n/a	break;
317	n/a	default:
318	n/a	return FFI_BAD_ABI;
319	n/a	}
320	n/a	return FFI_OK;
321	n/a	}