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

#	count	content
1	n/a	/* -----------------------------------------------------------------------
2	n/a	ffi.c - Copyright (c) 2012 Tilera Corp.
3	n/a
4	n/a	TILE 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	#include <stdlib.h>
30	n/a	#include <stdint.h>
31	n/a	#include <unistd.h>
32	n/a	#include <arch/abi.h>
33	n/a	#include <arch/icache.h>
34	n/a	#include <arch/opcode.h>
35	n/a
36	n/a
37	n/a	/* The first 10 registers are used to pass arguments and return values. */
38	n/a	#define NUM_ARG_REGS 10
39	n/a
40	n/a	/* Performs a raw function call with the given NUM_ARG_REGS register arguments
41	n/a	and the specified additional stack arguments (if any). */
42	n/a	extern void ffi_call_tile(ffi_sarg reg_args[NUM_ARG_REGS],
43	n/a	const ffi_sarg *stack_args,
44	n/a	size_t stack_args_bytes,
45	n/a	void (*fnaddr)(void))
46	n/a	FFI_HIDDEN;
47	n/a
48	n/a	/* This handles the raw call from the closure stub, cleaning up the
49	n/a	parameters and delegating to ffi_closure_tile_inner. */
50	n/a	extern void ffi_closure_tile(void) FFI_HIDDEN;
51	n/a
52	n/a
53	n/a	ffi_status
54	n/a	ffi_prep_cif_machdep(ffi_cif *cif)
55	n/a	{
56	n/a	/* We always allocate room for all registers. Even if we don't
57	n/a	use them as parameters, they get returned in the same array
58	n/a	as struct return values so we need to make room. */
59	n/a	if (cif->bytes < NUM_ARG_REGS * FFI_SIZEOF_ARG)
60	n/a	cif->bytes = NUM_ARG_REGS * FFI_SIZEOF_ARG;
61	n/a
62	n/a	if (cif->rtype->size > NUM_ARG_REGS * FFI_SIZEOF_ARG)
63	n/a	cif->flags = FFI_TYPE_STRUCT;
64	n/a	else
65	n/a	cif->flags = FFI_TYPE_INT;
66	n/a
67	n/a	/* Nothing to do. */
68	n/a	return FFI_OK;
69	n/a	}
70	n/a
71	n/a
72	n/a	static long
73	n/a	assign_to_ffi_arg(ffi_sarg out, void in, const ffi_type *type,
74	n/a	int write_to_reg)
75	n/a	{
76	n/a	switch (type->type)
77	n/a	{
78	n/a	case FFI_TYPE_SINT8:
79	n/a	out = (SINT8 *)in;
80	n/a	return 1;
81	n/a
82	n/a	case FFI_TYPE_UINT8:
83	n/a	out = (UINT8 *)in;
84	n/a	return 1;
85	n/a
86	n/a	case FFI_TYPE_SINT16:
87	n/a	out = (SINT16 *)in;
88	n/a	return 1;
89	n/a
90	n/a	case FFI_TYPE_UINT16:
91	n/a	out = (UINT16 *)in;
92	n/a	return 1;
93	n/a
94	n/a	case FFI_TYPE_SINT32:
95	n/a	case FFI_TYPE_UINT32:
96	n/a	#ifndef __LP64__
97	n/a	case FFI_TYPE_POINTER:
98	n/a	#endif
99	n/a	/* Note that even unsigned 32-bit quantities are sign extended
100	n/a	on tilegx when stored in a register. */
101	n/a	out = (SINT32 *)in;
102	n/a	return 1;
103	n/a
104	n/a	case FFI_TYPE_FLOAT:
105	n/a	#ifdef __tilegx__
106	n/a	if (write_to_reg)
107	n/a	{
108	n/a	/* Properly sign extend the value. */
109	n/a	union { float f; SINT32 s32; } val;
110	n/a	val.f = (float )in;
111	n/a	*out = val.s32;
112	n/a	}
113	n/a	else
114	n/a	#endif
115	n/a	{
116	n/a	(float )out = (float )in;
117	n/a	}
118	n/a	return 1;
119	n/a
120	n/a	case FFI_TYPE_SINT64:
121	n/a	case FFI_TYPE_UINT64:
122	n/a	case FFI_TYPE_DOUBLE:
123	n/a	#ifdef __LP64__
124	n/a	case FFI_TYPE_POINTER:
125	n/a	#endif
126	n/a	(UINT64 )out = (UINT64 )in;
127	n/a	return sizeof(UINT64) / FFI_SIZEOF_ARG;
128	n/a
129	n/a	case FFI_TYPE_STRUCT:
130	n/a	memcpy(out, in, type->size);
131	n/a	return (type->size + FFI_SIZEOF_ARG - 1) / FFI_SIZEOF_ARG;
132	n/a
133	n/a	case FFI_TYPE_VOID:
134	n/a	/* Must be a return type. Nothing to do. */
135	n/a	return 0;
136	n/a
137	n/a	default:
138	n/a	FFI_ASSERT(0);
139	n/a	return -1;
140	n/a	}
141	n/a	}
142	n/a
143	n/a
144	n/a	void
145	n/a	ffi_call(ffi_cif cif, void (fn)(void), void rvalue, void *avalue)
146	n/a	{
147	n/a	ffi_sarg * const arg_mem = alloca(cif->bytes);
148	n/a	ffi_sarg * const reg_args = arg_mem;
149	n/a	ffi_sarg * const stack_args = &reg_args[NUM_ARG_REGS];
150	n/a	ffi_sarg *argp = arg_mem;
151	n/a	ffi_type ** const arg_types = cif->arg_types;
152	n/a	const long num_args = cif->nargs;
153	n/a	long i;
154	n/a
155	n/a	if (cif->flags == FFI_TYPE_STRUCT)
156	n/a	{
157	n/a	/* Pass a hidden pointer to the return value. We make sure there
158	n/a	is scratch space for the callee to store the return value even if
159	n/a	our caller doesn't care about it. */
160	n/a	*argp++ = (intptr_t)(rvalue ? rvalue : alloca(cif->rtype->size));
161	n/a
162	n/a	/* No more work needed to return anything. */
163	n/a	rvalue = NULL;
164	n/a	}
165	n/a
166	n/a	for (i = 0; i < num_args; i++)
167	n/a	{
168	n/a	ffi_type *type = arg_types[i];
169	n/a	void * const arg_in = avalue[i];
170	n/a	ptrdiff_t arg_word = argp - arg_mem;
171	n/a
172	n/a	#ifndef __tilegx__
173	n/a	/* Doubleword-aligned values are always in an even-number register
174	n/a	pair, or doubleword-aligned stack slot if out of registers. */
175	n/a	long align = arg_word & (type->alignment > FFI_SIZEOF_ARG);
176	n/a	argp += align;
177	n/a	arg_word += align;
178	n/a	#endif
179	n/a
180	n/a	if (type->type == FFI_TYPE_STRUCT)
181	n/a	{
182	n/a	const size_t arg_size_in_words =
183	n/a	(type->size + FFI_SIZEOF_ARG - 1) / FFI_SIZEOF_ARG;
184	n/a
185	n/a	if (arg_word < NUM_ARG_REGS &&
186	n/a	arg_word + arg_size_in_words > NUM_ARG_REGS)
187	n/a	{
188	n/a	/* Args are not allowed to span registers and the stack. */
189	n/a	argp = stack_args;
190	n/a	}
191	n/a
192	n/a	memcpy(argp, arg_in, type->size);
193	n/a	argp += arg_size_in_words;
194	n/a	}
195	n/a	else
196	n/a	{
197	n/a	argp += assign_to_ffi_arg(argp, arg_in, arg_types[i], 1);
198	n/a	}
199	n/a	}
200	n/a
201	n/a	/* Actually do the call. */
202	n/a	ffi_call_tile(reg_args, stack_args,
203	n/a	cif->bytes - (NUM_ARG_REGS * FFI_SIZEOF_ARG), fn);
204	n/a
205	n/a	if (rvalue != NULL)
206	n/a	assign_to_ffi_arg(rvalue, reg_args, cif->rtype, 0);
207	n/a	}
208	n/a
209	n/a
210	n/a	/* Template code for closure. */
211	n/a	extern const UINT64 ffi_template_tramp_tile[] FFI_HIDDEN;
212	n/a
213	n/a
214	n/a	ffi_status
215	n/a	ffi_prep_closure_loc (ffi_closure *closure,
216	n/a	ffi_cif *cif,
217	n/a	void (fun)(ffi_cif, void, void, void),
218	n/a	void *user_data,
219	n/a	void *codeloc)
220	n/a	{
221	n/a	#ifdef __tilegx__
222	n/a	/* TILE-Gx */
223	n/a	SINT64 c;
224	n/a	SINT64 h;
225	n/a	int s;
226	n/a	UINT64 *out;
227	n/a
228	n/a	if (cif->abi != FFI_UNIX)
229	n/a	return FFI_BAD_ABI;
230	n/a
231	n/a	out = (UINT64 *)closure->tramp;
232	n/a
233	n/a	c = (intptr_t)closure;
234	n/a	h = (intptr_t)ffi_closure_tile;
235	n/a	s = 0;
236	n/a
237	n/a	/* Find the smallest shift count that doesn't lose information
238	n/a	(i.e. no need to explicitly insert high bits of the address that
239	n/a	are just the sign extension of the low bits). */
240	n/a	while ((c >> s) != (SINT16)(c >> s) \|\| (h >> s) != (SINT16)(h >> s))
241	n/a	s += 16;
242	n/a
243	n/a	#define OPS(a, b, shift) \
244	n/a	(create_Imm16_X0((a) >> (shift)) \| create_Imm16_X1((b) >> (shift)))
245	n/a
246	n/a	/* Emit the moveli. */
247	n/a	*out++ = ffi_template_tramp_tile[0] \| OPS(c, h, s);
248	n/a	for (s -= 16; s >= 0; s -= 16)
249	n/a	*out++ = ffi_template_tramp_tile[1] \| OPS(c, h, s);
250	n/a
251	n/a	#undef OPS
252	n/a
253	n/a	*out++ = ffi_template_tramp_tile[2];
254	n/a
255	n/a	#else
256	n/a	/* TILEPro */
257	n/a	UINT64 *out;
258	n/a	intptr_t delta;
259	n/a
260	n/a	if (cif->abi != FFI_UNIX)
261	n/a	return FFI_BAD_ABI;
262	n/a
263	n/a	out = (UINT64 *)closure->tramp;
264	n/a	delta = (intptr_t)ffi_closure_tile - (intptr_t)codeloc;
265	n/a
266	n/a	*out++ = ffi_template_tramp_tile[0] \| create_JOffLong_X1(delta >> 3);
267	n/a	#endif
268	n/a
269	n/a	closure->cif = cif;
270	n/a	closure->fun = fun;
271	n/a	closure->user_data = user_data;
272	n/a
273	n/a	invalidate_icache(closure->tramp, (char *)out - closure->tramp,
274	n/a	getpagesize());
275	n/a
276	n/a	return FFI_OK;
277	n/a	}
278	n/a
279	n/a
280	n/a	/* This is called by the assembly wrapper for closures. This does
281	n/a	all of the work. On entry reg_args[0] holds the values the registers
282	n/a	had when the closure was invoked. On return reg_args[1] holds the register
283	n/a	values to be returned to the caller (many of which may be garbage). */
284	n/a	void FFI_HIDDEN
285	n/a	ffi_closure_tile_inner(ffi_closure *closure,
286	n/a	ffi_sarg reg_args[2][NUM_ARG_REGS],
287	n/a	ffi_sarg *stack_args)
288	n/a	{
289	n/a	ffi_cif * const cif = closure->cif;
290	n/a	void ** const avalue = alloca(cif->nargs * sizeof(void *));
291	n/a	void *rvalue;
292	n/a	ffi_type ** const arg_types = cif->arg_types;
293	n/a	ffi_sarg * const reg_args_in = reg_args[0];
294	n/a	ffi_sarg * const reg_args_out = reg_args[1];
295	n/a	ffi_sarg * argp;
296	n/a	long i, arg_word, nargs = cif->nargs;
297	n/a	/* Use a union to guarantee proper alignment for double. */
298	n/a	union { ffi_sarg arg[NUM_ARG_REGS]; double d; UINT64 u64; } closure_ret;
299	n/a
300	n/a	/* Start out reading register arguments. */
301	n/a	argp = reg_args_in;
302	n/a
303	n/a	/* Copy the caller's structure return address to that the closure
304	n/a	returns the data directly to the caller. */
305	n/a	if (cif->flags == FFI_TYPE_STRUCT)
306	n/a	{
307	n/a	/* Return by reference via hidden pointer. */
308	n/a	rvalue = (void )(intptr_t)argp++;
309	n/a	arg_word = 1;
310	n/a	}
311	n/a	else
312	n/a	{
313	n/a	/* Return the value in registers. */
314	n/a	rvalue = &closure_ret;
315	n/a	arg_word = 0;
316	n/a	}
317	n/a
318	n/a	/* Grab the addresses of the arguments. */
319	n/a	for (i = 0; i < nargs; i++)
320	n/a	{
321	n/a	ffi_type * const type = arg_types[i];
322	n/a	const size_t arg_size_in_words =
323	n/a	(type->size + FFI_SIZEOF_ARG - 1) / FFI_SIZEOF_ARG;
324	n/a
325	n/a	#ifndef __tilegx__
326	n/a	/* Doubleword-aligned values are always in an even-number register
327	n/a	pair, or doubleword-aligned stack slot if out of registers. */
328	n/a	long align = arg_word & (type->alignment > FFI_SIZEOF_ARG);
329	n/a	argp += align;
330	n/a	arg_word += align;
331	n/a	#endif
332	n/a
333	n/a	if (arg_word == NUM_ARG_REGS \|\|
334	n/a	(arg_word < NUM_ARG_REGS &&
335	n/a	arg_word + arg_size_in_words > NUM_ARG_REGS))
336	n/a	{
337	n/a	/* Switch to reading arguments from the stack. */
338	n/a	argp = stack_args;
339	n/a	arg_word = NUM_ARG_REGS;
340	n/a	}
341	n/a
342	n/a	avalue[i] = argp;
343	n/a	argp += arg_size_in_words;
344	n/a	arg_word += arg_size_in_words;
345	n/a	}
346	n/a
347	n/a	/* Invoke the closure. */
348	n/a	closure->fun(cif, rvalue, avalue, closure->user_data);
349	n/a
350	n/a	if (cif->flags != FFI_TYPE_STRUCT)
351	n/a	{
352	n/a	/* Canonicalize for register representation. */
353	n/a	assign_to_ffi_arg(reg_args_out, &closure_ret, cif->rtype, 1);
354	n/a	}
355	n/a	}